From 15f59bf9f815f30c174338e86d9d856234da0652 Mon Sep 17 00:00:00 2001 From: vb6174 Date: Mon, 16 Aug 2021 14:20:34 +0000 Subject: [PATCH 1/4] update audio code Signed-off-by: vb6174 --- audio/BUILD.gn | 72 +- audio/audio.gni | 16 +- .../codec/include/hi3516_codec_impl.h} | 4 +- .../codec/include/hi3516_codec_ops.h | 32 + .../codec/src/hi3516_codec_adapter.c | 123 ++ .../codec/src/hi3516_codec_impl.c} | 35 +- .../hi3516dv300/codec/src/hi3516_codec_ops.c | 526 +++++ .../hi3516dv300/dsp/src/dsp_adapter.c | 485 +++++ .../include/audio_device_log.h | 0 .../include/hi3516_common.h | 4 +- .../soc/include/hi3516_aiao_impl.h} | 4 +- .../soc/include/hi3516_platform_ops.h | 45 + .../soc/src/hi3516_aiao_impl.c} | 6 +- .../hi3516dv300/soc/src/hi3516_dai_adapter.c | 335 ++++ .../soc/src/hi3516_platform_adapter.c | 161 ++ .../hi3516dv300/soc/src/hi3516_platform_ops.c | 1286 ++++++++++++ .../include/tfa9879_accessory_impl.h} | 55 +- .../accessory/src/tfa9879_accessory_adapter.c | 103 + .../accessory/src/tfa9879_accessory_impl.c} | 111 +- .../src => config}/adapter_config.json | 0 audio/config/linux/BUILD.gn | 17 + audio/config/lite/BUILD.gn | 12 + .../{hal/pathselect/src => config}/parse.json | 0 audio/hal/hdi_binder/proxy/BUILD.gn | 163 ++ .../proxy/include/audio_proxy_common.h | 22 +- .../proxy/include/audio_proxy_internal.h | 65 +- .../proxy/include/audio_proxy_manager.h | 19 +- audio/hal/hdi_binder/proxy/src/BUILD.gn | 112 -- .../proxy/src/audio_proxy_adapter.c | 138 +- .../proxy/src/audio_proxy_capture.c | 360 +++- .../hdi_binder/proxy/src/audio_proxy_common.c | 246 ++- .../proxy/src/audio_proxy_manager.c | 54 +- .../hdi_binder/proxy/src/audio_proxy_render.c | 440 ++++- audio/hal/hdi_binder/server/BUILD.gn | 147 ++ .../server/include/hdf_audio_server.h | 25 +- .../server/include/hdf_audio_server_capture.h | 19 +- .../server/include/hdf_audio_server_common.h | 15 +- .../server/include/hdf_audio_server_render.h | 23 +- .../hdi_binder/server/src/hdf_audio_server.c | 142 +- .../server/src/hdf_audio_server_capture.c | 245 ++- .../server/src/hdf_audio_server_common.c | 539 +++-- .../server/src/hdf_audio_server_render.c | 311 ++- audio/hal/hdi_passthrough/BUILD.gn | 157 ++ .../include/audio_adapter_info_common.h | 18 +- .../hdi_passthrough/include/audio_common.h | 9 + .../hdi_passthrough/include/audio_internal.h | 103 +- audio/hal/hdi_passthrough/src/audio_adapter.c | 94 +- .../src/audio_adapter_info_common.c | 850 +++++++- audio/hal/hdi_passthrough/src/audio_capture.c | 269 ++- audio/hal/hdi_passthrough/src/audio_common.c | 99 +- audio/hal/hdi_passthrough/src/audio_manager.c | 8 +- audio/hal/hdi_passthrough/src/audio_render.c | 394 +++- .../server/src => pathselect}/BUILD.gn | 124 +- .../hal/pathselect/include/audio_pathselect.h | 8 +- audio/hal/pathselect/src/audio_pathselect.c | 93 +- audio/interfaces/include/audio_attribute.h | 2 +- audio/interfaces/include/audio_types.h | 1 + audio/sample/BUILD.gn | 298 ++- audio/sample/framework_capture.c | 498 +++-- audio/sample/framework_render.c | 531 +++-- audio/supportlibs/adm_adapter/BUILD.gn | 217 +++ .../include/audio_interface_lib_capture.h | 68 +- .../include/audio_interface_lib_common.h | 64 +- .../include/audio_interface_lib_render.h | 66 +- audio/supportlibs/adm_adapter/src/BUILD.gn | 143 -- .../src/audio_interface_lib_capture.c | 723 +++---- .../src/audio_interface_lib_common.c | 50 +- .../src/audio_interface_lib_render.c | 820 ++++---- .../{hal/pathselect/src => test/hdf}/BUILD.gn | 105 +- audio/test/systemtest/BUILD.gn | 12 +- audio/test/systemtest/adm/BUILD.gn | 14 +- .../adm/audio_adm_interface/BUILD.gn | 172 +- .../src/audio_adm_interface_test.cpp | 1321 +++---------- .../systemtest/adm_interface_lib/BUILD.gn | 16 +- .../adm_interface_lib/capture/BUILD.gn | 157 +- .../capture/src/audio_libcapture_test.cpp | 515 +++-- .../adm_interface_lib/render/BUILD.gn | 157 +- .../render/src/audio_librender_test.cpp | 965 +++------ audio/test/systemtest/audio_function/BUILD.gn | 22 +- .../audio_function/audio_pathroute/BUILD.gn | 169 +- .../src/audio_pathroute_test.cpp | 252 +-- .../audio_function/audio_server/BUILD.gn | 138 +- .../src/audio_server_function_test.cpp | 1169 +++-------- .../audio_function/audio_smartpa}/BUILD.gn | 136 +- .../include/audio_smartpa_test.h | 22 + .../audio_smartpa/src/audio_smartpa_test.cpp | 597 ++++++ .../adm_common/include/audio_adm_common.h | 89 +- .../adm_common/src/audio_adm_common.cpp | 264 ++- .../hdi_common/include/audio_hdi_common.h | 160 +- .../hdi_common/src/audio_hdi_common.cpp | 476 ++++- .../lib_common/include/audio_lib_common.h | 44 +- .../lib_common/src/audio_lib_common.cpp | 78 +- audio/test/systemtest/hdi/BUILD.gn | 51 +- audio/test/systemtest/hdi/adapter/BUILD.gn | 142 +- .../hdi/adapter/src/audio_hdiadapter_test.cpp | 268 ++- audio/test/systemtest/hdi/capture/BUILD.gn | 666 +++++-- .../src/audio_hdicapture_attr_test.cpp | 1726 ++++++++++------- .../src/audio_hdicapture_control_test.cpp | 686 +++---- .../src/audio_hdicapture_scene_test.cpp | 306 +-- .../hdi/capture/src/audio_hdicapture_test.cpp | 549 ++---- .../src/audio_hdicapture_volume_test.cpp | 480 ++--- .../systemtest/hdi/hdiperformace/BUILD.gn | 214 ++ .../audio_hdicapture_performace_test.h | 19 + .../include/audio_hdirender_performace_test.h | 19 + .../src/audio_hdicapture_performace_test.cpp | 925 +++++++++ .../src/audio_hdirender_performace_test.cpp | 1375 +++++++++++++ .../systemtest/hdi/hdireliability/BUILD.gn | 541 ++++-- ...udio_hdicapture_control_reliability_test.h | 0 ...audio_hdirender_control_reliability_test.h | 0 ...io_hdicapture_control_reliability_test.cpp | 496 ++--- .../src/audio_hdicapture_reliability_test.cpp | 890 +++++---- ...dio_hdirender_control_reliability_test.cpp | 338 ++-- .../src/audio_hdirender_reliability_test.cpp | 1219 +++++++++--- audio/test/systemtest/hdi/render/BUILD.gn | 663 +++++-- .../render/src/audio_hdirender_attr_test.cpp | 1479 +++++++------- .../src/audio_hdirender_control_test.cpp | 713 +++---- .../render/src/audio_hdirender_scene_test.cpp | 420 +--- .../hdi/render/src/audio_hdirender_test.cpp | 837 ++------ .../src/audio_hdirender_volume_test.cpp | 505 ++--- 119 files changed, 21920 insertions(+), 12881 deletions(-) rename audio/chipsets/{codec/hi3516_codec/include/hi3516_codec.h => hi3516dv300/codec/include/hi3516_codec_impl.h} (99%) create mode 100755 audio/chipsets/hi3516dv300/codec/include/hi3516_codec_ops.h create mode 100755 audio/chipsets/hi3516dv300/codec/src/hi3516_codec_adapter.c rename audio/chipsets/{codec/hi3516_codec/src/hi3516_codec.c => hi3516dv300/codec/src/hi3516_codec_impl.c} (92%) create mode 100755 audio/chipsets/hi3516dv300/codec/src/hi3516_codec_ops.c create mode 100755 audio/chipsets/hi3516dv300/dsp/src/dsp_adapter.c rename audio/chipsets/{ => hi3516dv300}/include/audio_device_log.h (100%) rename audio/chipsets/{codec/hi3516_codec => hi3516dv300}/include/hi3516_common.h (96%) rename audio/chipsets/{codec/hi3516_codec/include/hi3516_aiao.h => hi3516dv300/soc/include/hi3516_aiao_impl.h} (99%) create mode 100755 audio/chipsets/hi3516dv300/soc/include/hi3516_platform_ops.h rename audio/chipsets/{codec/hi3516_codec/src/hi3516_aiao.c => hi3516dv300/soc/src/hi3516_aiao_impl.c} (99%) create mode 100755 audio/chipsets/hi3516dv300/soc/src/hi3516_dai_adapter.c create mode 100755 audio/chipsets/hi3516dv300/soc/src/hi3516_platform_adapter.c create mode 100755 audio/chipsets/hi3516dv300/soc/src/hi3516_platform_ops.c rename audio/chipsets/{accessory/tfa9879_smartpa/include/tfa9879_codec.h => tfa9879/accessory/include/tfa9879_accessory_impl.h} (56%) create mode 100755 audio/chipsets/tfa9879/accessory/src/tfa9879_accessory_adapter.c rename audio/chipsets/{accessory/tfa9879_smartpa/src/tfa9879_codec.c => tfa9879/accessory/src/tfa9879_accessory_impl.c} (88%) rename audio/{hal/hdi_passthrough/src => config}/adapter_config.json (100%) create mode 100755 audio/config/linux/BUILD.gn create mode 100755 audio/config/lite/BUILD.gn rename audio/{hal/pathselect/src => config}/parse.json (100%) create mode 100755 audio/hal/hdi_binder/proxy/BUILD.gn delete mode 100755 audio/hal/hdi_binder/proxy/src/BUILD.gn create mode 100755 audio/hal/hdi_binder/server/BUILD.gn create mode 100755 audio/hal/hdi_passthrough/BUILD.gn rename audio/hal/{hdi_binder/server/src => pathselect}/BUILD.gn (31%) create mode 100755 audio/supportlibs/adm_adapter/BUILD.gn mode change 100644 => 100755 audio/supportlibs/adm_adapter/include/audio_interface_lib_common.h delete mode 100755 audio/supportlibs/adm_adapter/src/BUILD.gn mode change 100644 => 100755 audio/supportlibs/adm_adapter/src/audio_interface_lib_common.c rename audio/{hal/pathselect/src => test/hdf}/BUILD.gn (32%) rename audio/{hal/hdi_passthrough/src => test/systemtest/audio_function/audio_smartpa}/BUILD.gn (32%) create mode 100755 audio/test/systemtest/audio_function/audio_smartpa/include/audio_smartpa_test.h create mode 100755 audio/test/systemtest/audio_function/audio_smartpa/src/audio_smartpa_test.cpp create mode 100755 audio/test/systemtest/hdi/hdiperformace/BUILD.gn create mode 100755 audio/test/systemtest/hdi/hdiperformace/include/audio_hdicapture_performace_test.h create mode 100755 audio/test/systemtest/hdi/hdiperformace/include/audio_hdirender_performace_test.h create mode 100755 audio/test/systemtest/hdi/hdiperformace/src/audio_hdicapture_performace_test.cpp create mode 100755 audio/test/systemtest/hdi/hdiperformace/src/audio_hdirender_performace_test.cpp mode change 100644 => 100755 audio/test/systemtest/hdi/hdireliability/include/audio_hdicapture_control_reliability_test.h mode change 100644 => 100755 audio/test/systemtest/hdi/hdireliability/include/audio_hdirender_control_reliability_test.h mode change 100644 => 100755 audio/test/systemtest/hdi/hdireliability/src/audio_hdicapture_control_reliability_test.cpp mode change 100644 => 100755 audio/test/systemtest/hdi/hdireliability/src/audio_hdirender_control_reliability_test.cpp diff --git a/audio/BUILD.gn b/audio/BUILD.gn index cabb72080e..0417f199f1 100755 --- a/audio/BUILD.gn +++ b/audio/BUILD.gn @@ -20,45 +20,49 @@ import("//drivers/adapter/uhdf2/uhdf.gni") import("//drivers/peripheral/audio/audio.gni") group("hdi_audio") { - if(is_standard_system) { - deps = [ - "hal/hdi_passthrough/src:hdi_audio", - ":hdf_audio_json", - "hal/hdi_binder/proxy/src:audio_hdi_proxy_server", - "hal/hdi_binder/server/src:audio_hdi_adapter_server", - "supportlibs/adm_adapter/src:hdi_audio_interface_lib_capture", - "supportlibs/adm_adapter/src:hdi_audio_interface_lib_render", + + deps = [ + "hal/hdi_passthrough:hdi_audio" + ] + + if (defined(ohos_lite)) { + deps += [ "config/lite:hdf_audio_json" ] + } else { + deps += [ + "config/linux:hdf_audio_json", + "hal/hdi_binder/proxy:audio_hdi_proxy_server", + "hal/hdi_binder/server:audio_hdi_adapter_server" ] - if (enable_audio_hal_notsupport_pathselect == false) { - deps += [ - ":hdf_audio_path_json", - "hal/pathselect/src:hdi_audio_path_select", - ] - } } -} -group("audio_sample_client") { - if(is_standard_system) { - deps = [ - "sample:audio_sample_render", - "sample:audio_sample_capture", + if (enable_audio_device_mpi) { + deps += [ + "//device/hisilicon/hardware/media/proprietary/hal/audio:hdi_audio_interface_lib_capture", + "//device/hisilicon/hardware/media/proprietary/hal/audio:hdi_audio_interface_lib_render", + "//device/hisilicon/hardware/media/proprietary/hal/audio:hdi_audio_interface_lib_mpi", + ] + } else { + deps += [ + "supportlibs/adm_adapter:hdi_audio_interface_lib_capture", + "supportlibs/adm_adapter:hdi_audio_interface_lib_render", ] } -} + if (enable_audio_hal_notsupport_pathselect == false) { + deps += [ + "hal/pathselect:hdi_audio_path_select", + ] -if (is_standard_system) { - ohos_prebuilt_etc("hdf_audio_json") { - source = "//drivers/peripheral/audio/hal/hdi_passthrough/src/adapter_config.json" - relative_install_dir = "hdfconfig" - subsystem_name = "hdf" - part_name = "hdf" + if (defined(ohos_lite)) { + deps += [ "config/lite:hdf_audio_path_json" ] + } else { + deps += [ "config/linux:hdf_audio_path_json" ] + } } +} - ohos_prebuilt_etc("hdf_audio_path_json") { - source = "//drivers/peripheral/audio/hal/pathselect/src/parse.json" - relative_install_dir = "hdfconfig" - subsystem_name = "hdf" - part_name = "hdf" - } -} \ No newline at end of file +group("audio_sample_client") { + deps = [ + "sample:audio_sample_render", + "sample:audio_sample_capture" + ] +} diff --git a/audio/audio.gni b/audio/audio.gni index 4b337a5bc5..61f94ac29c 100755 --- a/audio/audio.gni +++ b/audio/audio.gni @@ -1,7 +1,17 @@ -# Copyright (c) Huawei Technologies Co., Ltd. 2020-2020. All rights reserved. +# Copyright (c) Huawei Technologies Co., Ltd. 2021. All rights reserved. #If set flag is false, the ADM version will be built; if set flag is true, the MPI version will be built. enable_audio_device_mpi = false - #If set flag is false, the pathselect will be built; if set flag is true, the notSupport pathselect version will be built. -enable_audio_hal_notsupport_pathselect = false \ No newline at end of file +enable_audio_hal_notsupport_pathselect = false + +# testcase build switch +#If flag is true, the ADM_SO version testcase will be built; if set flag is true, the other version will be built. +enable_audio_adm_so = false +#If flag is true, the MPI_SO version testcase will be built; if set flag is true, the other version will be built. +enable_audio_mpi_so = false +#If flag is true, the ADM_SERVICE version testcase will be built; if set flag is true, the other version will be built. +enable_audio_adm_service = true +#If flag is true, the MPI_SERVICE version testcase will be built; if set flag is true, the other version will be built. +enable_audio_mpi_service = false +#If all above flag is setted to false, it will build failure.so forbid setting all above flag to false. \ No newline at end of file diff --git a/audio/chipsets/codec/hi3516_codec/include/hi3516_codec.h b/audio/chipsets/hi3516dv300/codec/include/hi3516_codec_impl.h similarity index 99% rename from audio/chipsets/codec/hi3516_codec/include/hi3516_codec.h rename to audio/chipsets/hi3516dv300/codec/include/hi3516_codec_impl.h index 51d8f6edf1..b3dd286f3a 100755 --- a/audio/chipsets/codec/hi3516_codec/include/hi3516_codec.h +++ b/audio/chipsets/hi3516dv300/codec/include/hi3516_codec_impl.h @@ -6,8 +6,8 @@ * See the LICENSE file in the root of this repository for complete details. */ -#ifndef __HI3516_CODEC_H__ -#define __HI3516_CODEC_H__ +#ifndef HI3516_CODEC_IMPL_H +#define HI3516_CODEC_IMPL_H #include "osal_mem.h" #include "osal_time.h" diff --git a/audio/chipsets/hi3516dv300/codec/include/hi3516_codec_ops.h b/audio/chipsets/hi3516dv300/codec/include/hi3516_codec_ops.h new file mode 100755 index 0000000000..2755ed336c --- /dev/null +++ b/audio/chipsets/hi3516dv300/codec/include/hi3516_codec_ops.h @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. + */ + +#ifndef HI3516_CODEC_OPS_H +#define HI3516_CODEC_OPS_H + +#include "audio_core.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +int32_t CodecDeviceInit(struct AudioCard *audioCard, struct CodecDevice *codec); +int32_t CodecDaiDeviceInit(const struct AudioCard *card, const struct DaiDevice *device); +int32_t CodecDaiHwParams(const struct AudioCard *card, + const struct AudioPcmHwParams *param, const struct DaiDevice *device); +int32_t CodecDaiStartup(const struct AudioCard *card, const struct DaiDevice *device); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* HI3516_CODEC_OPS_H */ diff --git a/audio/chipsets/hi3516dv300/codec/src/hi3516_codec_adapter.c b/audio/chipsets/hi3516dv300/codec/src/hi3516_codec_adapter.c new file mode 100755 index 0000000000..2a51f18e06 --- /dev/null +++ b/audio/chipsets/hi3516dv300/codec/src/hi3516_codec_adapter.c @@ -0,0 +1,123 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. + */ + +#include "hi3516_codec_ops.h" +#include "audio_codec_base.h" +#include "audio_core.h" + +#define HDF_LOG_TAG hi3516_codec_adapter + +struct CodecData g_codecData = { + .Init = CodecDeviceInit, + .Read = CodecDeviceReadReg, + .Write = CodecDeviceWriteReg, + .AiaoRead = CodecAiaoDeviceReadReg, + .AiaoWrite = CodecAiaoDeviceWriteReg, +}; + +struct AudioDaiOps g_codecDaiDeviceOps = { + .Startup = CodecDaiStartup, + .HwParams = CodecDaiHwParams, +}; + +struct DaiData g_codecDaiData = { + .DaiInit = CodecDaiDeviceInit, + .ops = &g_codecDaiDeviceOps, +}; + +/* HdfDriverEntry implementations */ +static int32_t CodecDriverBind(struct HdfDeviceObject *device) +{ + struct CodecHost *codecHost = NULL; + + AUDIO_DRIVER_LOG_DEBUG("entry!"); + + if (device == NULL) { + AUDIO_DRIVER_LOG_ERR("input para is NULL."); + return HDF_FAILURE; + } + + codecHost = (struct CodecHost *)OsalMemCalloc(sizeof(*codecHost)); + if (codecHost == NULL) { + AUDIO_DRIVER_LOG_ERR("malloc codecHost fail!"); + return HDF_FAILURE; + } + + codecHost->device = device; + device->service = &codecHost->service; + + AUDIO_DRIVER_LOG_INFO("success!"); + return HDF_SUCCESS; +} + +static int32_t CodecDriverInit(struct HdfDeviceObject *device) +{ + int32_t ret; + + AUDIO_DRIVER_LOG_DEBUG("entry."); + if (device == NULL) { + AUDIO_DRIVER_LOG_ERR("device is NULL."); + return HDF_ERR_INVALID_OBJECT; + } + + ret = CodecGetServiceName(device, &g_codecData.drvCodecName); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("get codec service name fail."); + return ret; + } + + ret = CodecGetDaiName(device, &g_codecDaiData.drvDaiName); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("get codec dai name fail."); + return ret; + } + + ret = AudioRegisterCodec(device, &g_codecData, &g_codecDaiData); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("register dai fail."); + return ret; + } + + AUDIO_DRIVER_LOG_INFO("Success."); + return HDF_SUCCESS; +} + +static void CodecDriverRelease(struct HdfDeviceObject *device) +{ + struct CodecHost *codecHost = NULL; + struct VirtualAddress *virtualAdd = NULL; + + if (device == NULL) { + AUDIO_DRIVER_LOG_ERR("device is NULL"); + return; + } + + if (device->priv != NULL) { + virtualAdd = (struct VirtualAddress *)device->priv; + OsalIoUnmap((void *)((uintptr_t)(void*)&virtualAdd->acodecVir)); + OsalIoUnmap((void *)((uintptr_t)(void*)&virtualAdd->aiaoVir)); + OsalMemFree(device->priv); + } + + codecHost = (struct CodecHost *)device->service; + if (codecHost == NULL) { + HDF_LOGE("CodecDriverRelease: codecHost is NULL"); + return; + } + OsalMemFree(codecHost); +} + +/* HdfDriverEntry definitions */ +struct HdfDriverEntry g_codecDriverEntry = { + .moduleVersion = 1, + .moduleName = "CODEC_HI3516", + .Bind = CodecDriverBind, + .Init = CodecDriverInit, + .Release = CodecDriverRelease, +}; +HDF_INIT(g_codecDriverEntry); diff --git a/audio/chipsets/codec/hi3516_codec/src/hi3516_codec.c b/audio/chipsets/hi3516dv300/codec/src/hi3516_codec_impl.c similarity index 92% rename from audio/chipsets/codec/hi3516_codec/src/hi3516_codec.c rename to audio/chipsets/hi3516dv300/codec/src/hi3516_codec_impl.c index 8d5d360c30..a5b0d328cb 100755 --- a/audio/chipsets/codec/hi3516_codec/src/hi3516_codec.c +++ b/audio/chipsets/hi3516dv300/codec/src/hi3516_codec_impl.c @@ -1,24 +1,20 @@ /* * 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. + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. */ -#include "hi3516_codec.h" + +#include "hi3516_codec_impl.h" #include #include "audio_device_log.h" #include "hdf_base.h" #include "hdf_log.h" #include "osal_io.h" +#define HDF_LOG_TAG hi3516_codec_impl + static void *g_regAcodecBase = NULL; // CODEC Reg Base Addr const int HALF_MINUTE = 30; const int VOLUME_DB_MAX = 6; @@ -177,15 +173,22 @@ void ShowAllAcodecRegister(void) { volatile unsigned int val; - // ACODEC REG 0048 - val = AcodecHalReadReg(AUDIO_CODEC_MASKREG); - AUDIO_DEVICE_LOG_DEBUG("ACODEC REG: AUDIO_CODEC_MASKREG = [%08x]", val); + val = AcodecHalReadReg(ACODEC_ANAREG0_ADDR); + AUDIO_DEVICE_LOG_DEBUG("ACODEC REG: ACODEC_ANAREG0_ADDR 0014 = [%08x]", val); + + val = AcodecHalReadReg(ACODEC_ANAREG3_ADDR); + AUDIO_DEVICE_LOG_DEBUG("ACODEC REG: ACODEC_ANAREG0_ADDR 0020 = [%08x]", val); + // ACODEC REG 0030 val = AcodecHalReadReg(ACODEC_DIGCTRL1_ADDR); - AUDIO_DEVICE_LOG_DEBUG("ACODEC REG: ACODEC_DIGCTRL1_ADDR = [%08x]", val); + AUDIO_DEVICE_LOG_DEBUG("ACODEC REG: ACODEC_DIGCTRL1_ADDR 0030 = [%08x]", val); val = AcodecHalReadReg(ACODEC_DIGCTRL3_ADDR); - AUDIO_DEVICE_LOG_DEBUG("ACODEC REG: ACODEC_DIGCTRL3_ADDR = [%08x]", val); + AUDIO_DEVICE_LOG_DEBUG("ACODEC REG: ACODEC_DIGCTRL3_ADDR 0038 = [%08x]", val); + + // ACODEC REG 0048 + val = AcodecHalReadReg(AUDIO_CODEC_MASKREG); + AUDIO_DEVICE_LOG_DEBUG("ACODEC REG: AUDIO_CODEC_MASKREG 0048 = [%08x]", val); } static unsigned int AcodecGetI2sFs(const unsigned int rate) diff --git a/audio/chipsets/hi3516dv300/codec/src/hi3516_codec_ops.c b/audio/chipsets/hi3516dv300/codec/src/hi3516_codec_ops.c new file mode 100755 index 0000000000..094b51fbf5 --- /dev/null +++ b/audio/chipsets/hi3516dv300/codec/src/hi3516_codec_ops.c @@ -0,0 +1,526 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. + */ + +#include "hi3516_codec_ops.h" +#include "audio_sapm.h" +#include "hi3516_aiao_impl.h" +#include "hi3516_codec_impl.h" +#include "osal_io.h" +#include "osal_irq.h" + +#define HDF_LOG_TAG hi3516_codec_ops + +#define ACODEC_CTRLREG0_ADDR 0x2c /* adcl,adcr, dacl, dacr power ctrl reg */ +#define ACODEC_DACREG1_ADDR 0x38 /* codec ctrl reg 3 */ +#define ACODEC_ADCREG0_ADDR 0x3c /* codec ctrl reg 4 */ +#define ACODEC_REG18_ADDR 0x48 /* codec ctrl reg 18 */ +#define ACODEC_ANACTRLREG0_ADDR 0x14 /* codec ana ctrl reg 0 */ +#define ACODEC_ANACTRLREG3_ADDR 0x20 /* codec ana ctrl reg 0 */ +#define ACODEC_CTRLREG1_ADDR 0x30 /* acodec ctrl reg1 */ +#define AIAO_RX_IF_ATTRI_ADDR 0x1000 /* aiao receive channel interface attribute */ +#define AIAO_TX_IF_ATTRI_ADDR 0x2000 /* aiao tranfer channel interface attribute */ +#define AIAO_TX_DSP_CTRL_ADDR 0x2004 + +static const struct AudioMixerControl g_audioRegParams[] = { + { + .reg = AIAO_TX_DSP_CTRL_ADDR, /* [0] output volume */ + .rreg = AIAO_TX_DSP_CTRL_ADDR, + .shift = 8, + .rshift = 8, + .min = 0x28, + .max = 0x7F, + .mask = 0x7F, + .invert = 0, + }, { + .reg = ACODEC_ADCREG0_ADDR, /* [1] input volume */ + .rreg = ACODEC_ADCREG0_ADDR, + .shift = 24, + .rshift = 24, + .min = 0x0, + .max = 0x57, + .mask = 0x7F, + .invert = 1, + }, { + .reg = ACODEC_DACREG1_ADDR, /* [2] output mute */ + .rreg = ACODEC_DACREG1_ADDR, + .shift = 31, + .rshift = 31, + .min = 0x0, + .max = 0x1, + .mask = 0x1, + .invert = 0, + }, { + .reg = ACODEC_ADCREG0_ADDR, /* [3] input mute */ + .rreg = ACODEC_ADCREG0_ADDR, + .shift = 31, + .rshift = 31, + .min = 0x0, + .max = 0x1, + .mask = 0x1, + .invert = 0, + }, { + .reg = ACODEC_ANACTRLREG3_ADDR, /* [4] left mic gain */ + .rreg = ACODEC_ANACTRLREG3_ADDR, + .shift = 16, + .rshift = 16, + .min = 0x0, + .max = 0xF, + .mask = 0x1F, + .invert = 0, + }, { + .reg = ACODEC_ANACTRLREG3_ADDR, /* [5] right mic gain */ + .rreg = ACODEC_ANACTRLREG3_ADDR, + .shift = 24, + .rshift = 24, + .min = 0x0, + .max = 0xF, + .mask = 0x1F, + .invert = 0, + }, { + .reg = ACODEC_REG18_ADDR, /* [6] external codec enable */ + .rreg = ACODEC_REG18_ADDR, + .shift = 1, + .rshift = 1, + .min = 0x0, + .max = 0x1, + .mask = 0x1, + .invert = 0, + }, { + .reg = ACODEC_REG18_ADDR, /* [7] internally codec enable */ + .rreg = ACODEC_REG18_ADDR, + .shift = 0, + .rshift = 0, + .min = 0x0, + .max = 0x1, + .mask = 0x1, + .invert = 0, + }, { + .reg = AIAO_TX_IF_ATTRI_ADDR, /* [8] aiao render channel mode */ + .rreg = AIAO_TX_IF_ATTRI_ADDR, + .shift = 16, + .rshift = 16, + .min = 0x0, + .max = 0x7, + .mask = 0x7, + .invert = 0, + }, { + .reg = AIAO_RX_IF_ATTRI_ADDR, /* [9] aiao capture channel mode */ + .rreg = AIAO_RX_IF_ATTRI_ADDR, + .shift = 16, + .rshift = 16, + .min = 0x0, + .max = 0x7, + .mask = 0x7, + .invert = 0, + }, +}; + +static const struct AudioKcontrol g_audioControls[] = { + { + .iface = AUDIODRV_CTL_ELEM_IFACE_DAC, + .name = "Master Playback Volume", + .Info = AudioInfoCtrlOps, + .Get = AudioCodecAiaoGetCtrlOps, + .Set = AudioCodecAiaoSetCtrlOps, + .privateValue = (unsigned long)&g_audioRegParams[PLAYBACK_VOLUME], + }, { + .iface = AUDIODRV_CTL_ELEM_IFACE_ADC, + .name = "Master Capture Volume", + .Info = AudioInfoCtrlOps, + .Get = AudioCodecGetCtrlOps, + .Set = AudioCodecSetCtrlOps, + .privateValue = (unsigned long)&g_audioRegParams[CAPTURE_VOLUME], + }, { + .iface = AUDIODRV_CTL_ELEM_IFACE_DAC, + .name = "Playback Mute", + .Info = AudioInfoCtrlOps, + .Get = AudioCodecGetCtrlOps, + .Set = AudioCodecSetCtrlOps, + .privateValue = (unsigned long)&g_audioRegParams[PLAYBACK_MUTE], + }, { + .iface = AUDIODRV_CTL_ELEM_IFACE_ADC, + .name = "Capture Mute", + .Info = AudioInfoCtrlOps, + .Get = AudioCodecGetCtrlOps, + .Set = AudioCodecSetCtrlOps, + .privateValue = (unsigned long)&g_audioRegParams[CAPTURE_MUTE], + }, { + .iface = AUDIODRV_CTL_ELEM_IFACE_GAIN, + .name = "Mic Left Gain", + .Info = AudioInfoCtrlOps, + .Get = AudioCodecGetCtrlOps, + .Set = AudioCodecSetCtrlOps, + .privateValue = (unsigned long)&g_audioRegParams[LEFT_GAIN], + }, { + .iface = AUDIODRV_CTL_ELEM_IFACE_GAIN, + .name = "Mic Right Gain", + .Info = AudioInfoCtrlOps, + .Get = AudioCodecGetCtrlOps, + .Set = AudioCodecSetCtrlOps, + .privateValue = (unsigned long)&g_audioRegParams[RIGHT_GAIN], + }, { + .iface = AUDIODRV_CTL_ELEM_IFACE_ACODEC, + .name = "External Codec Enable", + .Info = AudioInfoCtrlOps, + .Get = AudioCodecGetCtrlOps, + .Set = AudioCodecSetCtrlOps, + .privateValue = (unsigned long)&g_audioRegParams[EXTERNAL_CODEC_ENABLE], + }, { + .iface = AUDIODRV_CTL_ELEM_IFACE_ACODEC, + .name = "Internally Codec Enable", + .Info = AudioInfoCtrlOps, + .Get = AudioCodecGetCtrlOps, + .Set = AudioCodecSetCtrlOps, + .privateValue = (unsigned long)&g_audioRegParams[INTERNALLY_CODEC_ENABLE], + }, { + .iface = AUDIODRV_CTL_ELEM_IFACE_AIAO, + .name = "Render Channel Mode", + .Info = AudioInfoCtrlOps, + .Get = AudioCodecAiaoGetCtrlOps, + .Set = AudioCodecAiaoSetCtrlOps, + .privateValue = (unsigned long)&g_audioRegParams[RENDER_CHANNEL_MODE], + }, { + .iface = AUDIODRV_CTL_ELEM_IFACE_AIAO, + .name = "Captrue Channel Mode", + .Info = AudioInfoCtrlOps, + .Get = AudioCodecAiaoGetCtrlOps, + .Set = AudioCodecAiaoSetCtrlOps, + .privateValue = (unsigned long)&g_audioRegParams[CAPTRUE_CHANNEL_MODE], + }, +}; + +static const struct AudioMixerControl g_audioSapmRegParams[] = { + { + .reg = ACODEC_ANACTRLREG3_ADDR, /* LPGA MIC 0 -- connect MIC */ + .rreg = ACODEC_ANACTRLREG3_ADDR, + .shift = 23, + .rshift = 23, + .min = 0x0, + .max = 0x1, + .mask = 0x1, + .invert = 0, + }, { + .reg = ACODEC_ANACTRLREG3_ADDR, /* RPGA MIC 0 -- connect MIC */ + .rreg = ACODEC_ANACTRLREG3_ADDR, + .shift = 31, + .rshift = 31, + .min = 0x0, + .max = 0x1, + .mask = 0x1, + .invert = 0, + }, { + .reg = ACODEC_CTRLREG1_ADDR, /* [2] dacl to dacr mixer */ + .rreg = ACODEC_CTRLREG1_ADDR, + .shift = 27, + .rshift = 27, + .min = 0x0, + .max = 0x1, + .mask = 0x1, + .invert = 0, + }, { + .reg = ACODEC_CTRLREG1_ADDR, /* [3] dacr to dacl mixer */ + .rreg = ACODEC_CTRLREG1_ADDR, + .shift = 26, + .rshift = 26, + .min = 0x0, + .max = 0x1, + .mask = 0x1, + .invert = 0, + }, +}; + +static struct AudioKcontrol g_audioSapmDACLControls[] = { + { + .iface = AUDIODRV_CTL_ELEM_IFACE_DAC, + .name = "Dacl enable", + .Info = AudioInfoCtrlOps, + .Get = AudioCodecSapmGetCtrlOps, + .Set = AudioCodecSapmSetCtrlOps, + .privateValue = (unsigned long)&g_audioSapmRegParams[DACL2DACR], + }, +}; + +static struct AudioKcontrol g_audioSapmDACRControls[] = { + { + .iface = AUDIODRV_CTL_ELEM_IFACE_DAC, + .name = "Dacr enable", + .Info = AudioInfoCtrlOps, + .Get = AudioCodecSapmGetCtrlOps, + .Set = AudioCodecSapmSetCtrlOps, + .privateValue = (unsigned long)&g_audioSapmRegParams[DACR2DACL], + }, +}; + +static struct AudioKcontrol g_audioSapmLPGAControls[] = { + { + .iface = AUDIODRV_CTL_ELEM_IFACE_PGA, + .name = "LPGA MIC Switch", + .Info = AudioInfoCtrlOps, + .Get = AudioCodecSapmGetCtrlOps, + .Set = AudioCodecSapmSetCtrlOps, + .privateValue = (unsigned long)&g_audioSapmRegParams[LPGA_MIC], + }, +}; + +static struct AudioKcontrol g_audioSapmRPGAControls[] = { + { + .iface = AUDIODRV_CTL_ELEM_IFACE_PGA, + .name = "RPGA MIC Switch", + .Info = AudioInfoCtrlOps, + .Get = AudioCodecSapmGetCtrlOps, + .Set = AudioCodecSapmSetCtrlOps, + .privateValue = (unsigned long)&g_audioSapmRegParams[RPGA_MIC], + }, +}; + +static const struct AudioSapmComponent g_streamDomainComponents[] = { + { + .sapmType = AUDIO_SAPM_ADC, /* ADCL */ + .componentName = "ADCL", + .reg = ACODEC_ANACTRLREG3_ADDR, + .mask = 0x1, + .shift = 15, + .invert = 1, + }, { + .sapmType = AUDIO_SAPM_ADC, /* ADCR */ + .componentName = "ADCR", + .reg = ACODEC_ANACTRLREG3_ADDR, + .mask = 0x1, + .shift = 14, + .invert = 1, + }, { + .sapmType = AUDIO_SAPM_DAC, /* DACL */ + .componentName = "DACL", + .reg = ACODEC_ANACTRLREG0_ADDR, + .mask = 0x1, + .shift = 11, + .invert = 1, + }, { + .sapmType = AUDIO_SAPM_DAC, /* DACR */ + .componentName = "DACR", + .reg = ACODEC_ANACTRLREG0_ADDR, + .mask = 0x1, + .shift = 12, + .invert = 1, + }, { + .sapmType = AUDIO_SAPM_PGA, /* LPGA */ + .componentName = "LPGA", + .reg = ACODEC_ANACTRLREG3_ADDR, + .mask = 0x1, + .shift = 13, + .invert = 1, + .kcontrolNews = g_audioSapmLPGAControls, + .kcontrolsNum = HDF_ARRAY_SIZE(g_audioSapmLPGAControls), + }, { + .sapmType = AUDIO_SAPM_PGA, /* RPGA */ + .componentName = "RPGA", + .reg = ACODEC_ANACTRLREG3_ADDR, + .mask = 0x1, + .shift = 12, + .invert = 1, + .kcontrolNews = g_audioSapmRPGAControls, + .kcontrolsNum = HDF_ARRAY_SIZE(g_audioSapmRPGAControls), + }, { + .sapmType = AUDIO_SAPM_SPK, /* SPKL */ + .componentName = "SPKL", + .reg = AUDIO_SAPM_NOPM, + .mask = 0x1, + .shift = 0, + .invert = 0, + .kcontrolNews = g_audioSapmDACLControls, + .kcontrolsNum = HDF_ARRAY_SIZE(g_audioSapmDACLControls), + }, { + .sapmType = AUDIO_SAPM_SPK, /* SPKR */ + .componentName = "SPKR", + .reg = AUDIO_SAPM_NOPM, + .mask = 0x1, + .shift = 0, + .invert = 0, + .kcontrolNews = g_audioSapmDACRControls, + .kcontrolsNum = HDF_ARRAY_SIZE(g_audioSapmDACRControls), + }, { + .sapmType = AUDIO_SAPM_MIC, /* MIC */ + .componentName = "MIC", + .reg = AUDIO_SAPM_NOPM, + .mask = 0x1, + .shift = 0, + .invert = 0, + }, +}; + +static const struct AudioSapmRoute g_audioRoutes[] = { + { "SPKL", "Dacl enable", "DACL"}, + { "SPKR", "Dacr enable", "DACR"}, + + { "ADCL", NULL, "LPGA"}, + { "LPGA", "LPGA MIC Switch", "MIC"}, + + { "ADCR", NULL, "RPGA"}, + { "RPGA", "RPGA MIC Switch", "MIC"}, +}; + +int32_t CodecDeviceInit(struct AudioCard *audioCard, struct CodecDevice *codec) +{ + const int innerCodecEnable = 7; + struct VirtualAddress *virtualAdd = NULL; + struct AudioMixerControl mixerCtrl = g_audioRegParams[innerCodecEnable]; + + if ((audioCard == NULL) || (codec == NULL || codec->device == NULL)) { + AUDIO_DRIVER_LOG_ERR("input para is NULL."); + return HDF_ERR_INVALID_OBJECT; + } + virtualAdd = (struct VirtualAddress *)OsalMemCalloc(sizeof(struct VirtualAddress)); + if (virtualAdd == NULL) { + AUDIO_DRIVER_LOG_ERR("virtualAdd fail!"); + return HDF_ERR_MALLOC_FAIL; + } + virtualAdd->acodecVir = (uintptr_t)OsalIoRemap(ACODEC_REG_BASE, ACODEC_MAX_REG_SIZE); + virtualAdd->aiaoVir = (uintptr_t)OsalIoRemap(AIAO_REG_BASE, AIAO_MAX_REG_SIZE); + codec->device->priv = virtualAdd; + + /* default inner codec */ + if (AudioUpdateCodecRegBits(codec, &mixerCtrl, 1) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("update reg bits fail."); + return HDF_FAILURE; + } + + if (CodecHalSysInit() != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("CodecHalSysInit fail."); + return HDF_FAILURE; + } + + AcodecDeviceInit(); + + if (AudioAddControls(audioCard, g_audioControls, HDF_ARRAY_SIZE(g_audioControls)) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("add controls fail."); + return HDF_FAILURE; + } + + if (AudioSapmNewComponents(audioCard, g_streamDomainComponents, + HDF_ARRAY_SIZE(g_streamDomainComponents)) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("new components fail."); + return HDF_FAILURE; + } + + if (AudioSapmAddRoutes(audioCard, g_audioRoutes, HDF_ARRAY_SIZE(g_audioRoutes)) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("add route fail."); + return HDF_FAILURE; + } + + if (AudioSapmNewControls(audioCard) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("add sapm controls fail."); + return HDF_FAILURE; + } + + if (AudioSapmSleep(audioCard) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("add sapm sleep modular fail."); + return HDF_FAILURE; + } + + AUDIO_DRIVER_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +int32_t CodecDaiDeviceInit(const struct AudioCard *card, const struct DaiDevice *device) +{ + if (device == NULL || device->devDaiName == NULL) { + AUDIO_DRIVER_LOG_ERR("input para is NULL."); + return HDF_FAILURE; + } + + AUDIO_DRIVER_LOG_DEBUG("codec dai device name: %s\n", device->devDaiName); + (void)card; + return HDF_SUCCESS; +} + +static int32_t FramatToBitWidth(enum AudioFormat format, unsigned int *bitWidth) +{ + switch (format) { + case AUDIO_FORMAT_PCM_8_BIT: + *bitWidth = BIT_WIDTH8; + break; + + case AUDIO_FORMAT_PCM_16_BIT: + *bitWidth = BIT_WIDTH16; + break; + + case AUDIO_FORMAT_PCM_24_BIT: + *bitWidth = BIT_WIDTH24; + break; + + case AUDIO_FORMAT_PCM_32_BIT: + *bitWidth = BIT_WIDTH32; + break; + + case AUDIO_FORMAT_AAC_MAIN: + case AUDIO_FORMAT_AAC_LC: + case AUDIO_FORMAT_AAC_LD: + case AUDIO_FORMAT_AAC_ELD: + case AUDIO_FORMAT_AAC_HE_V1: + case AUDIO_FORMAT_AAC_HE_V2: + break; + + default: + AUDIO_DRIVER_LOG_ERR("format: %d is not define.", format); + return HI_FAILURE; + break; + } + + return HI_SUCCESS; +} + + +int32_t CodecDaiHwParams(const struct AudioCard *card, + const struct AudioPcmHwParams *param, const struct DaiDevice *device) +{ + int ret; + unsigned int bitWidth; + (void)card; + (void)device; + + AUDIO_DRIVER_LOG_DEBUG("entry."); + if (param == NULL || param->cardServiceName == NULL) { + AUDIO_DRIVER_LOG_ERR("input para is NULL."); + return HDF_FAILURE; + } + + ret = FramatToBitWidth(param->format, &bitWidth); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("FramatToBitWidth: fail."); + return HDF_FAILURE; + } + + ret = AcodecSetI2s1Fs(param->rate); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AcodecSetI2s1Fs fail."); + return HDF_FAILURE; + } + + ret = AcodecSetI2s1DataWidth(bitWidth); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AcodecSetI2s1DataWidth fail."); + return HDF_FAILURE; + } + + AUDIO_DRIVER_LOG_DEBUG("channels = %d, rate = %d, periodSize = %d, \ + periodCount = %d, format = %d, cardServiceName = %s \n", + param->channels, param->rate, param->periodSize, + param->periodCount, (uint32_t)param->format, param->cardServiceName); + + AUDIO_DRIVER_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +int32_t CodecDaiStartup(const struct AudioCard *card, const struct DaiDevice *device) +{ + (void)card; + (void)device; + + return HDF_SUCCESS; +} + diff --git a/audio/chipsets/hi3516dv300/dsp/src/dsp_adapter.c b/audio/chipsets/hi3516dv300/dsp/src/dsp_adapter.c new file mode 100755 index 0000000000..e0ea122da7 --- /dev/null +++ b/audio/chipsets/hi3516dv300/dsp/src/dsp_adapter.c @@ -0,0 +1,485 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. + */ + +#include "audio_core.h" +#include "audio_accessory_base.h" +#include "audio_dsp_if.h" +#include "gpio_if.h" +#include "osal_io.h" +#include "spi_if.h" + +#define DEFAULT_SPEED 2000000 +#define BITS_PER_WORD_EIGHT 8 +#define DSP_CS_NUM 1 +#define DSP_SPI_BUS_NUM 1 + +#define HDF_LOG_TAG dsp_adapter + +static int32_t DspLinkDeviceInit(const struct AudioCard *card, const struct DaiDevice *device); +static int32_t DspDeviceInit(const struct DspDevice *device); +static int32_t DspDeviceReadReg(struct DspDevice *device, uint8_t *buf, uint32_t len); +static int32_t DspDeviceWriteReg(struct DspDevice *device, uint8_t *buf, uint32_t len); +static int32_t DspLinkStartup(const struct AudioCard *card, const struct DaiDevice *device); +static int32_t DspLinkHwParams(const struct AudioCard *card, + const struct AudioPcmHwParams *param, const struct DaiDevice *device); +static int32_t DspDecodeAudioStream(const struct AudioCard *card, const uint8_t *buf, const struct DspDevice *device); +static int32_t DspEncodeAudioStream(const struct AudioCard *card, const uint8_t *buf, const struct DspDevice *device); +static int32_t DspEqualizerActive(const struct AudioCard *card, const uint8_t *buf, const struct DspDevice *device); + +struct DspData g_dspData = { + .DspInit = DspDeviceInit, + .Read = DspDeviceReadReg, + .Write = DspDeviceWriteReg, + .decode = DspDecodeAudioStream, + .encode = DspEncodeAudioStream, + .Equalizer = DspEqualizerActive, +}; + +struct AudioDaiOps g_dspLinkDeviceOps = { + .Startup = DspLinkStartup, + .HwParams = DspLinkHwParams, +}; + +struct DaiData g_dspDaiData = { + .DaiInit = DspLinkDeviceInit, + .ops = &g_dspLinkDeviceOps, +}; + +struct SpiDevInfo g_devInfo = { + .busNum = DSP_SPI_BUS_NUM, + .csNum = DSP_CS_NUM, +}; + +static int32_t DspLinkStartup(const struct AudioCard *card, const struct DaiDevice *device) +{ + (void)card; + (void)device; + return HDF_SUCCESS; +} + +static int32_t DspCfgI2sFrequency(uint32_t rate, uint16_t *frequency) +{ + switch (rate) { + case I2S_SAMPLE_FREQUENCY_8000: + *frequency = I2S_SAMPLE_FREQUENCY_REG_VAL_8000; + break; + case I2S_SAMPLE_FREQUENCY_11025: + *frequency = I2S_SAMPLE_FREQUENCY_REG_VAL_11025; + break; + case I2S_SAMPLE_FREQUENCY_12000: + *frequency = I2S_SAMPLE_FREQUENCY_REG_VAL_12000; + break; + case I2S_SAMPLE_FREQUENCY_16000: + *frequency = I2S_SAMPLE_FREQUENCY_REG_VAL_16000; + break; + case I2S_SAMPLE_FREQUENCY_22050: + *frequency = I2S_SAMPLE_FREQUENCY_REG_VAL_22050; + break; + case I2S_SAMPLE_FREQUENCY_24000: + *frequency = I2S_SAMPLE_FREQUENCY_REG_VAL_24000; + break; + case I2S_SAMPLE_FREQUENCY_32000: + *frequency = I2S_SAMPLE_FREQUENCY_REG_VAL_32000; + break; + case I2S_SAMPLE_FREQUENCY_44100: + *frequency = I2S_SAMPLE_FREQUENCY_REG_VAL_44100; + break; + case I2S_SAMPLE_FREQUENCY_48000: + *frequency = I2S_SAMPLE_FREQUENCY_REG_VAL_48000; + break; + case I2S_SAMPLE_FREQUENCY_64000: + *frequency = I2S_SAMPLE_FREQUENCY_REG_VAL_64000; + break; + case I2S_SAMPLE_FREQUENCY_88200: + *frequency = I2S_SAMPLE_FREQUENCY_REG_VAL_88200; + break; + case I2S_SAMPLE_FREQUENCY_96000: + *frequency = I2S_SAMPLE_FREQUENCY_REG_VAL_96000; + break; + default: + AUDIO_DRIVER_LOG_ERR("rate: %d is not support.", rate); + return HDF_ERR_NOT_SUPPORT; + } + return HDF_SUCCESS; +} + +static int32_t DspSetI2sBitWidth(enum AudioFormat format, uint16_t *bitWidth) +{ + switch (format) { + case AUDIO_FORMAT_PCM_8_BIT: + *bitWidth = I2S_SAMPLE_FORMAT_REG_VAL_24; + break; + case AUDIO_FORMAT_PCM_16_BIT: + *bitWidth = I2S_SAMPLE_FORMAT_REG_VAL_24; + break; + case AUDIO_FORMAT_PCM_24_BIT: + *bitWidth = I2S_SAMPLE_FORMAT_REG_VAL_24; + break; + default: + AUDIO_DRIVER_LOG_ERR("format: %d is not support.", format); + return HDF_ERR_NOT_SUPPORT; + } + return HDF_SUCCESS; +} + +static int DspSetI2sFrequency(uint16_t frequencyVal) +{ + return HDF_SUCCESS; +} + +static int DspSetI2sFormat(uint16_t formatVal) +{ + return HDF_SUCCESS; +} + +static int32_t DspLinkHwParams(const struct AudioCard *card, + const struct AudioPcmHwParams *param, const struct DaiDevice *device) +{ + int ret; + uint16_t frequency, bitWidth; + (void)card; + (void)device; + AUDIO_DRIVER_LOG_DEBUG("entry."); + if (param == NULL || param->cardServiceName == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is nullptr."); + return HDF_ERR_INVALID_PARAM; + } + ret = DspCfgI2sFrequency(param->rate, &frequency); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("RateToFrequency fail."); + return HDF_ERR_NOT_SUPPORT; + } + ret = DspSetI2sBitWidth(param->format, &bitWidth); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("FormatToBitWidth fail."); + return HDF_ERR_NOT_SUPPORT; + } + ret = DspSetI2sFrequency(frequency); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("SetDspI2sFs fail."); + return HDF_FAILURE; + } + ret = DspSetI2sFormat(bitWidth); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("SetDspI2sFormat fail."); + return HDF_FAILURE; + } + AUDIO_DRIVER_LOG_DEBUG("DspLinkHwParams: channels = %d, rate = %d, periodSize = %d, \ + periodCount = %d, format = %d, cardServiceName = %s \n", + param->channels, param->rate, param->periodSize, + param->periodCount, (uint32_t)param->format, param->cardServiceName); + AUDIO_DRIVER_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +static int DspPowerEnable(void) +{ + return HDF_SUCCESS; +} + +static int DspGpioPinInit(void) +{ + return HDF_SUCCESS; +} + +static int DspI2cPinInit(void) +{ + return HDF_SUCCESS; +} + +static int DspI2sInit(void) +{ + return HDF_SUCCESS; +} + +static int DspI2cInit(void) +{ + return HDF_SUCCESS; +} + +/* not init dsp gpio */ +static int DspSpiPinInit(void) +{ + return HDF_FAILURE; +} + +static int32_t DspDeviceInit(const struct DspDevice *device) +{ + DevHandle devHandle; + struct SpiCfg devCfg = { + .maxSpeedHz = DEFAULT_SPEED, + .mode = SPI_CLK_POLARITY, + .transferMode = SPI_DMA_TRANSFER, + .bitsPerWord = BITS_PER_WORD_EIGHT, + }; + + if (DspPowerEnable() != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("DspPowerEnable: return Error!"); + return HDF_FAILURE; + } + + if (DspGpioPinInit() != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("DspGpioPinInit: return Error!"); + return HDF_FAILURE; + } + + if (DspI2cPinInit() != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("DspI2cPinInit: return Error!"); + return HDF_FAILURE; + } + + if (DspSpiPinInit() == HDF_SUCCESS) { + devHandle = SpiOpen(&g_devInfo); + if (devHandle == NULL) { + AUDIO_DRIVER_LOG_ERR("DspDeviceOpen: Spi failed!"); + return HDF_FAILURE; + } + + if (SpiSetCfg(devHandle, &devCfg) != HDF_SUCCESS) { + SpiClose(devHandle); + AUDIO_DRIVER_LOG_ERR("DspDeviceCfg: spi failed!"); + return HDF_FAILURE; + } + SpiClose(devHandle); + } else { + AUDIO_DRIVER_LOG_ERR("Dsp Gpio Pin: not init!"); + } + + if (DspI2cInit() != HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (DspI2sInit() != HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t DspDeviceReadReg(struct DspDevice *device, uint8_t *buf, uint32_t len) +{ + int32_t ret; + + DevHandle devHandle = SpiOpen(&g_devInfo); + if (devHandle == NULL) { + AUDIO_DRIVER_LOG_ERR("DspDeviceOpen: Spi failed!"); + return HDF_FAILURE; + } + + ret = SpiRead(devHandle, buf, len); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("DspDeviceRead: spi failed!"); + SpiClose(devHandle); + return HDF_FAILURE; + } + + SpiClose(devHandle); + + return HDF_SUCCESS; +} + +static int32_t DspDeviceWriteReg(struct DspDevice *device, uint8_t *buf, uint32_t len) +{ + int32_t ret; + + DevHandle devHandle = SpiOpen(&g_devInfo); + if (devHandle == NULL) { + AUDIO_DRIVER_LOG_ERR("DspDeviceOpen: Spi failed!"); + return HDF_FAILURE; + } + + ret = SpiWrite(devHandle, buf, len); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("DspDeviceRead: spi failed!"); + SpiClose(devHandle); + return HDF_FAILURE; + } + + SpiClose(devHandle); + + return HDF_SUCCESS; +} + +static int32_t DspLinkDeviceInit(const struct AudioCard *card, const struct DaiDevice *device) +{ + if (device == NULL || device->devDaiName == NULL) { + AUDIO_DRIVER_LOG_ERR("input para is nullptr."); + return HDF_FAILURE; + } + AUDIO_DRIVER_LOG_DEBUG("dsp Link device name: %s\n", device->devDaiName); + (void)card; + return HDF_SUCCESS; +} + +static int32_t DspDriverBind(struct HdfDeviceObject *device) +{ + struct AudioHost *audioHost = NULL; + + AUDIO_DRIVER_LOG_DEBUG("entry."); + if (device == NULL) { + AUDIO_DRIVER_LOG_ERR("device is NULL."); + return HDF_ERR_INVALID_OBJECT; + } + + audioHost = AudioHostCreateAndBind(device); + if (audioHost == NULL) { + AUDIO_DRIVER_LOG_ERR("audioHost create failed!"); + return HDF_FAILURE; + } + + AUDIO_DRIVER_LOG_INFO("success!"); + return HDF_SUCCESS; +} + +static int32_t DspGetServiceName(const struct HdfDeviceObject *device, const char **drvDspName) +{ + const struct DeviceResourceNode *node = NULL; + struct DeviceResourceIface *drsOps = NULL; + int32_t ret; + + if (device == NULL) { + AUDIO_DRIVER_LOG_ERR("device is NULL."); + return HDF_FAILURE; + } + + node = device->property; + if (node == NULL) { + AUDIO_DRIVER_LOG_ERR("deivce property is NULL."); + return HDF_FAILURE; + } + drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (drsOps == NULL || drsOps->GetString == NULL) { + AUDIO_DRIVER_LOG_ERR("from resource get drsops failed!"); + return HDF_FAILURE; + } + + ret = drsOps->GetString(node, "serviceName", drvDspName, 0); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("read DspServiceName fail!"); + return ret; + } + + return HDF_SUCCESS; +} + +static int32_t DspGetDaiName(const struct HdfDeviceObject *device, const char **drvDaiName) +{ + const struct DeviceResourceNode *node = NULL; + struct DeviceResourceIface *drsOps = NULL; + int32_t ret; + + if (device == NULL) { + AUDIO_DRIVER_LOG_ERR("input para is null pointer."); + return HDF_FAILURE; + } + + node = device->property; + if (node == NULL) { + AUDIO_DRIVER_LOG_ERR("drs node is null pointer."); + return HDF_FAILURE; + } + drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (drsOps == NULL || drsOps->GetString == NULL) { + AUDIO_DRIVER_LOG_ERR("drs ops fail!"); + return HDF_FAILURE; + } + + ret = drsOps->GetString(node, "dspDaiName", drvDaiName, 0); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("read dspDaiName fail!"); + return ret; + } + + return HDF_SUCCESS; +} + +static int32_t DspDriverInit(struct HdfDeviceObject *device) +{ + int32_t ret; + AUDIO_DRIVER_LOG_DEBUG("entry.\n"); + if (device == NULL) { + AUDIO_DRIVER_LOG_ERR("device is NULL."); + return HDF_ERR_INVALID_OBJECT; + } + + ret = DspGetServiceName(device, &g_dspData.drvDspName); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("get dsp service name fail."); + return ret; + } + + ret = DspGetDaiName(device, &g_dspDaiData.drvDaiName); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("get dsp dai name fail."); + return ret; + } + + ret = AudioRegisterDsp(device, &g_dspData, &g_dspDaiData); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("register dai fail."); + return ret; + } + AUDIO_DRIVER_LOG_INFO("success!"); + return HDF_SUCCESS; +} + + +static void DspDriverRelease(struct HdfDeviceObject *device) +{ + struct DspHost *dspHost = NULL; + if (device == NULL) { + AUDIO_DRIVER_LOG_ERR("device is NULL"); + return; + } + + dspHost = (struct DspHost *)device->service; + if (dspHost == NULL) { + AUDIO_DRIVER_LOG_ERR("DspHost is NULL"); + return; + } + + OsalIoUnmap((void *)((uintptr_t)(void*)&dspHost->priv)); + OsalMemFree(dspHost); +} + +static int32_t DspEqualizerActive(const struct AudioCard *card, const uint8_t *buf, const struct DspDevice *device) +{ + (void)card; + (void)buf; + (void)device; + AUDIO_DRIVER_LOG_DEBUG("equalizer run!!!"); + return HDF_SUCCESS; +} + +static int32_t DspDecodeAudioStream(const struct AudioCard *card, const uint8_t *buf, const struct DspDevice *device) +{ + (void)card; + (void)buf; + (void)device; + AUDIO_DRIVER_LOG_DEBUG("decode run!!!"); + return HDF_SUCCESS; +} + +static int32_t DspEncodeAudioStream(const struct AudioCard *card, const uint8_t *buf, const struct DspDevice *device) +{ + (void)card; + (void)buf; + (void)device; + AUDIO_DRIVER_LOG_DEBUG("encode run!!!"); + return HDF_SUCCESS; +} + +/* HdfDriverEntry definitions */ +struct HdfDriverEntry g_dspDriverEntry = { + .moduleVersion = 1, + .moduleName = "DSP", + .Bind = DspDriverBind, + .Init = DspDriverInit, + .Release = DspDriverRelease, +}; +HDF_INIT(g_dspDriverEntry); diff --git a/audio/chipsets/include/audio_device_log.h b/audio/chipsets/hi3516dv300/include/audio_device_log.h similarity index 100% rename from audio/chipsets/include/audio_device_log.h rename to audio/chipsets/hi3516dv300/include/audio_device_log.h diff --git a/audio/chipsets/codec/hi3516_codec/include/hi3516_common.h b/audio/chipsets/hi3516dv300/include/hi3516_common.h similarity index 96% rename from audio/chipsets/codec/hi3516_codec/include/hi3516_common.h rename to audio/chipsets/hi3516dv300/include/hi3516_common.h index e1f6254d81..73541a8ed0 100755 --- a/audio/chipsets/codec/hi3516_codec/include/hi3516_common.h +++ b/audio/chipsets/hi3516dv300/include/hi3516_common.h @@ -6,8 +6,8 @@ * See the LICENSE file in the root of this repository for complete details. */ -#ifndef __HI3516_COMMON_H__ -#define __HI3516_COMMON_H__ +#ifndef HI3516_COMMON_H +#define HI3516_COMMON_H enum AuidoBitWidth { BIT_WIDTH8 = 8, /* 8 bit witdth */ diff --git a/audio/chipsets/codec/hi3516_codec/include/hi3516_aiao.h b/audio/chipsets/hi3516dv300/soc/include/hi3516_aiao_impl.h similarity index 99% rename from audio/chipsets/codec/hi3516_codec/include/hi3516_aiao.h rename to audio/chipsets/hi3516dv300/soc/include/hi3516_aiao_impl.h index 5ed53876f5..05d193ae01 100755 --- a/audio/chipsets/codec/hi3516_codec/include/hi3516_aiao.h +++ b/audio/chipsets/hi3516dv300/soc/include/hi3516_aiao_impl.h @@ -6,8 +6,8 @@ * See the LICENSE file in the root of this repository for complete details. */ -#ifndef __HI3516_AIAO_H__ -#define __HI3516_AIAO_H__ +#ifndef HI3516_AIAO_IMPL_H +#define HI3516_AIAO_IMPL_H #include #include "hi3516_common.h" diff --git a/audio/chipsets/hi3516dv300/soc/include/hi3516_platform_ops.h b/audio/chipsets/hi3516dv300/soc/include/hi3516_platform_ops.h new file mode 100755 index 0000000000..d1c0f982aa --- /dev/null +++ b/audio/chipsets/hi3516dv300/soc/include/hi3516_platform_ops.h @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. + */ + +#ifndef HI3516_PLATFORM_OPS_H +#define HI3516_PLATFORM_OPS_H + +#include "audio_core.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +int32_t AudioPlatformDeviceInit(const struct AudioCard *card, const struct PlatformDevice *platform); +int32_t PlatformHwParams(const struct AudioCard *card, const struct AudioPcmHwParams *param); +int32_t PlatformRenderPrepare(const struct AudioCard *card); +int32_t PlatformCapturePrepare(const struct AudioCard *card); +int32_t PlatformCapturePrepare(const struct AudioCard *card); +int32_t PlatformWrite(const struct AudioCard *card, struct AudioTxData *txData); +int32_t PlatformRead(const struct AudioCard *card, struct AudioRxData *rxData); +int32_t PlatformMmapWrite(const struct AudioCard *card, struct AudioTxMmapData *txMmapData); +int32_t PlatformMmapRead(const struct AudioCard *card, struct AudioRxMmapData *rxMmapData); +int32_t PlatformRenderStart(struct AudioCard *card); +int32_t PlatformCaptureStart(struct AudioCard *card); +int32_t PlatformRenderStop(struct AudioCard *card); +int32_t PlatformCaptureStop(struct AudioCard *card); +int32_t PlatformCaptureStop(struct AudioCard *card); +int32_t PlatformRenderPause(struct AudioCard *card); +int32_t PlatformRenderResume(struct AudioCard *card); +int32_t PlatformCapturePause(struct AudioCard *card); +int32_t PlatformCaptureResume(struct AudioCard *card); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* HI3516_CODEC_OPS_H */ diff --git a/audio/chipsets/codec/hi3516_codec/src/hi3516_aiao.c b/audio/chipsets/hi3516dv300/soc/src/hi3516_aiao_impl.c similarity index 99% rename from audio/chipsets/codec/hi3516_codec/src/hi3516_aiao.c rename to audio/chipsets/hi3516dv300/soc/src/hi3516_aiao_impl.c index be36d4f38b..e3746041b1 100755 --- a/audio/chipsets/codec/hi3516_codec/src/hi3516_aiao.c +++ b/audio/chipsets/hi3516dv300/soc/src/hi3516_aiao_impl.c @@ -5,13 +5,16 @@ * the GPL, or the BSD license, at your option. * See the LICENSE file in the root of this repository for complete details. */ -#include "hi3516_aiao.h" + +#include "hi3516_aiao_impl.h" #include #include "audio_device_log.h" #include "hdf_base.h" #include "hdf_log.h" #include "osal_io.h" +#define HDF_LOG_TAG hi3516_aiao_impl + void *g_regAiaoBase = NULL; // AIAO Reg Base Addr AiaoClkInfo g_aioClkInfo = { @@ -148,6 +151,7 @@ int32_t AiaoClockReset(void) OSAL_WRITEL(crgVal, vAddr); AUDIO_DEVICE_LOG_DEBUG("[OHOS] AIAO CLOCK PERI_CRG103, Val: 0x%08x", crgVal); + OsalIoUnmap((void *)((uintptr_t)(void*)vAddr)); return HDF_SUCCESS; } diff --git a/audio/chipsets/hi3516dv300/soc/src/hi3516_dai_adapter.c b/audio/chipsets/hi3516dv300/soc/src/hi3516_dai_adapter.c new file mode 100755 index 0000000000..77eb0d10dc --- /dev/null +++ b/audio/chipsets/hi3516dv300/soc/src/hi3516_dai_adapter.c @@ -0,0 +1,335 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. + */ + +#include "audio_core.h" +#include "hi3516_aiao_impl.h" +#include "hi3516_codec_impl.h" +#include "osal_io.h" + +#define HDF_LOG_TAG hi3516_dai_adapter + +/* HdfDriverEntry implementations */ +static int32_t DaiDriverBind(struct HdfDeviceObject *device) +{ + struct DaiHost *daiHost = NULL; + AUDIO_DRIVER_LOG_DEBUG("entry!"); + + if (device == NULL) { + AUDIO_DRIVER_LOG_ERR("input para is NULL."); + return HDF_FAILURE; + } + + daiHost = (struct DaiHost *)OsalMemCalloc(sizeof(*daiHost)); + if (daiHost == NULL) { + AUDIO_DRIVER_LOG_ERR("malloc host fail!"); + return HDF_FAILURE; + } + + daiHost->device = device; + daiHost->daiInitFlag = false; + device->service = &daiHost->service; + + AUDIO_DRIVER_LOG_DEBUG("success!"); + return HDF_SUCCESS; +} + +int32_t DaiDeviceInit(const struct AudioCard *audioCard, const struct DaiDevice *dai) +{ + int ret; + struct DaiHost *daiHost = NULL; + unsigned int chnId = 0; + + if (dai == NULL || dai->device == NULL || dai->devDaiName == NULL) { + AUDIO_DRIVER_LOG_ERR("dai is nullptr."); + return HDF_FAILURE; + } + AUDIO_DRIVER_LOG_DEBUG("cpu dai device name: %s\n", dai->devDaiName); + (void)audioCard; + + daiHost = (struct DaiHost *)dai->device->service; + if (daiHost == NULL) { + AUDIO_DRIVER_LOG_ERR("dai host is NULL."); + return HDF_FAILURE; + } + + if (daiHost->daiInitFlag == true) { + AUDIO_DRIVER_LOG_DEBUG("dai init complete!"); + return HDF_SUCCESS; + } + + ret = AiaoHalSysInit(); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AiaoHalSysInit: fail."); + return HDF_FAILURE; + } + + ret = I2sCrgCfgInit(chnId); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AiaoHalSysInit: fail."); + return HDF_FAILURE; + } + + daiHost->daiInitFlag = true; + + return HDF_SUCCESS; +} + +static int32_t CheckSampleRate(unsigned int sampleRates) +{ + bool checkSampleRate = (sampleRates == AUDIO_SAMPLE_RATE_8000 || + sampleRates == AUDIO_SAMPLE_RATE_12000 || + sampleRates == AUDIO_SAMPLE_RATE_11025 || + sampleRates == AUDIO_SAMPLE_RATE_16000 || + sampleRates == AUDIO_SAMPLE_RATE_22050 || + sampleRates == AUDIO_SAMPLE_RATE_24000 || + sampleRates == AUDIO_SAMPLE_RATE_32000 || + sampleRates == AUDIO_SAMPLE_RATE_44100 || + sampleRates == AUDIO_SAMPLE_RATE_48000 || + sampleRates == AUDIO_SAMPLE_RATE_64000 || + sampleRates == AUDIO_SAMPLE_RATE_96000); + if (checkSampleRate) { + return HDF_SUCCESS; + } else { + AUDIO_DRIVER_LOG_ERR("FramatToSampleRate fail: Invalid sampling rate: %d.", sampleRates); + return HDF_ERR_NOT_SUPPORT; + } +} + +static int32_t FramatToBitWidth(enum AudioFormat format, unsigned int *bitWidth) +{ + switch (format) { + case AUDIO_FORMAT_PCM_16_BIT: + *bitWidth = BIT_WIDTH16; + break; + + case AUDIO_FORMAT_PCM_24_BIT: + *bitWidth = BIT_WIDTH24; + break; + + default: + AUDIO_DRIVER_LOG_ERR("format: %d is not define.", format); + return HI_FAILURE; + break; + } + + return HDF_SUCCESS; +} + +int32_t AiSetClkAttr(struct PlatformHost *platformHost, const struct AudioPcmHwParams *param) +{ + int ret; + unsigned int bitWidth; + + if (platformHost == NULL) { + AUDIO_DRIVER_LOG_ERR("platform host is NULL."); + return HDF_FAILURE; + } + + if (param == NULL) { + AUDIO_DRIVER_LOG_ERR("param is NULL."); + return HDF_FAILURE; + } + + ret = FramatToBitWidth(param->format, &bitWidth); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("FramatToBitWidth: fail."); + return HDF_FAILURE; + } + platformHost->pcmInfo.bitWidth = bitWidth; + + ret = AipSetSysCtlReg(platformHost->captureBufInfo.chnId, param->channels, bitWidth, param->rate); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AiSetClkAttr: fail."); + return HDF_FAILURE; + } + + ret = AipSetAttr(platformHost->captureBufInfo.chnId, param->channels, bitWidth); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AiSetClkAttr: fail."); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AoSetClkAttr(struct PlatformHost *platformHost, const struct AudioPcmHwParams *param) +{ + int ret; + unsigned int bitWidth; + + if (platformHost == NULL) { + AUDIO_DRIVER_LOG_ERR("platform host is nullptr."); + return HDF_FAILURE; + } + + if (param == NULL) { + AUDIO_DRIVER_LOG_ERR("param is nullptr."); + return HDF_FAILURE; + } + + ret = FramatToBitWidth(param->format, &bitWidth); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("FramatToBitWidth: fail."); + return HDF_FAILURE; + } + platformHost->pcmInfo.bitWidth = bitWidth; + + ret = AopSetSysCtlReg(platformHost->renderBufInfo.chnId, param->channels, bitWidth, param->rate); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("PlatformAopSetSysCtl: fail."); + return HDF_FAILURE; + } + + ret = AopSetAttr(platformHost->renderBufInfo.chnId, param->channels, bitWidth); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("PlatformAopSetAttrReg: fail."); + return HDF_FAILURE; + } + + AUDIO_DRIVER_LOG_DEBUG("bitWidth: %d.", bitWidth); + + return HDF_SUCCESS; +} + +int32_t DaiHwParams(const struct AudioCard *card, const struct AudioPcmHwParams *param, const struct DaiDevice *device) +{ + struct PlatformHost *platformHost = NULL; + int ret; + (void)device; + + AUDIO_DRIVER_LOG_DEBUG("entry."); + + if (card == NULL || card->rtd == NULL || card->rtd->platform == NULL || + param == NULL || param->cardServiceName == NULL) { + AUDIO_DRIVER_LOG_ERR("input para is nullptr."); + return HDF_FAILURE; + } + + ret = CheckSampleRate(param->rate); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("CheckSampleRate: fail."); + return HDF_ERR_NOT_SUPPORT; + } + + platformHost = PlatformHostFromDevice(card->rtd->platform->device); + if (platformHost == NULL) { + AUDIO_DRIVER_LOG_ERR("platformHost is nullptr."); + return HDF_FAILURE; + } + + if (param->streamType == AUDIO_RENDER_STREAM) { + ret = AoSetClkAttr(platformHost, param); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AoSetClkAttr: fail."); + return HDF_FAILURE; + } + } else if (param->streamType == AUDIO_CAPTURE_STREAM) { + ret = AiSetClkAttr(platformHost, param); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AiSetClkAttr: fail."); + return HDF_FAILURE; + } + } else { + AUDIO_DRIVER_LOG_ERR("param streamType is invalid."); + return HDF_FAILURE; + } + + AUDIO_DRIVER_LOG_DEBUG("channels = %d, rate = %d, periodSize = %d, \ + periodCount = %d, format = %d, cardServiceName = %s \n", + param->channels, param->rate, param->periodSize, + param->periodCount, (uint32_t)param->format, param->cardServiceName); + + AUDIO_DRIVER_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +int32_t DaiTrigger(const struct AudioCard *card, int cmd, const struct DaiDevice *device) +{ + (void)card; + (void)device; + (void)cmd; + + return HDF_SUCCESS; +} + +struct AudioDaiOps g_daiDeviceOps = { + .HwParams = DaiHwParams, + .Trigger = DaiTrigger, +}; + +struct DaiData g_daiData = { + .DaiInit = DaiDeviceInit, + .ops = &g_daiDeviceOps, +}; + +static int32_t DaiGetServiceName(const struct HdfDeviceObject *device) +{ + const struct DeviceResourceNode *node = NULL; + struct DeviceResourceIface *drsOps = NULL; + int32_t ret; + + if (device == NULL) { + AUDIO_DRIVER_LOG_ERR("input para is nullptr."); + return HDF_FAILURE; + } + + node = device->property; + if (node == NULL) { + AUDIO_DRIVER_LOG_ERR("drs node is nullptr."); + return HDF_FAILURE; + } + drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (drsOps == NULL || drsOps->GetString == NULL) { + AUDIO_DRIVER_LOG_ERR("invalid drs ops fail!"); + return HDF_FAILURE; + } + + ret = drsOps->GetString(node, "serviceName", &g_daiData.drvDaiName, 0); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("read serviceName fail!"); + return ret; + } + + return HDF_SUCCESS; +} + +static int32_t DaiDriverInit(struct HdfDeviceObject *device) +{ + int32_t ret; + AUDIO_DRIVER_LOG_DEBUG("entry.\n"); + + if (device == NULL) { + AUDIO_DRIVER_LOG_ERR("device is nullptr."); + return HDF_ERR_INVALID_OBJECT; + } + + ret = DaiGetServiceName(device); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("get service name fail."); + return ret; + } + + ret = AudioSocDeviceRegister(device, (void *)&g_daiData, AUDIO_DAI_DEVICE); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("register dai fail."); + return ret; + } + + AUDIO_DRIVER_LOG_DEBUG("success.\n"); + return HDF_SUCCESS; +} + +/* HdfDriverEntry definitions */ +struct HdfDriverEntry g_daiDriverEntry = { + .moduleVersion = 1, + .moduleName = "DAI_HI3516", + .Bind = DaiDriverBind, + .Init = DaiDriverInit, + .Release = NULL, +}; +HDF_INIT(g_daiDriverEntry); diff --git a/audio/chipsets/hi3516dv300/soc/src/hi3516_platform_adapter.c b/audio/chipsets/hi3516dv300/soc/src/hi3516_platform_adapter.c new file mode 100755 index 0000000000..17dea49839 --- /dev/null +++ b/audio/chipsets/hi3516dv300/soc/src/hi3516_platform_adapter.c @@ -0,0 +1,161 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. + */ + +#include "gpio_if.h" +#include +#include "audio_core.h" +#include "audio_platform_base.h" +#include "hi3516_platform_ops.h" +#include "osal_io.h" +#include "osal_mem.h" + +#define HDF_LOG_TAG hi3516_platform_adapter + +struct AudioPlatformOps g_platformDeviceOps = { + .HwParams = PlatformHwParams, + .Write = PlatformWrite, + .Read = PlatformRead, + .MmapWrite = PlatformMmapWrite, + .MmapRead = PlatformMmapRead, + .RenderPrepare = PlatformRenderPrepare, + .CapturePrepare = PlatformCapturePrepare, + .RenderStart = PlatformRenderStart, + .CaptureStart = PlatformCaptureStart, + .RenderStop = PlatformRenderStop, + .CaptureStop = PlatformCaptureStop, + .RenderPause = PlatformRenderPause, + .CapturePause = PlatformCapturePause, + .RenderResume = PlatformRenderResume, + .CaptureResume = PlatformCaptureResume, +}; + +struct PlatformData g_platformData = { + .PlatformInit = AudioPlatformDeviceInit, + .ops = &g_platformDeviceOps, +}; + +/* HdfDriverEntry implementations */ +static int32_t PlatformDriverBind(struct HdfDeviceObject *device) +{ + struct PlatformHost *platformHost = NULL; + AUDIO_DRIVER_LOG_DEBUG("entry!"); + + if (device == NULL) { + AUDIO_DRIVER_LOG_ERR("input para is NULL."); + return HDF_FAILURE; + } + + platformHost = (struct PlatformHost *)OsalMemCalloc(sizeof(*platformHost)); + if (platformHost == NULL) { + AUDIO_DRIVER_LOG_ERR("malloc host fail!"); + return HDF_FAILURE; + } + + platformHost->device = device; + platformHost->platformInitFlag = false; + device->service = &platformHost->service; + + AUDIO_DRIVER_LOG_DEBUG("success!"); + return HDF_SUCCESS; +} + +static int32_t PlatformGetServiceName(const struct HdfDeviceObject *device) +{ + const struct DeviceResourceNode *node = NULL; + struct DeviceResourceIface *drsOps = NULL; + int32_t ret; + + if (device == NULL) { + AUDIO_DRIVER_LOG_ERR("para is NULL."); + return HDF_FAILURE; + } + + node = device->property; + if (node == NULL) { + AUDIO_DRIVER_LOG_ERR("node is NULL."); + return HDF_FAILURE; + } + + drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (drsOps == NULL || drsOps->GetString == NULL) { + AUDIO_DRIVER_LOG_ERR("get drsops object instance fail!"); + return HDF_FAILURE; + } + + ret = drsOps->GetString(node, "serviceName", &g_platformData.drvPlatformName, 0); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("read serviceName fail!"); + return ret; + } + + return HDF_SUCCESS; +} + +static int32_t PlatformDriverInit(struct HdfDeviceObject *device) +{ + int32_t ret; + + AUDIO_DRIVER_LOG_DEBUG("entry.\n"); + struct PlatformHost *platformHost = NULL; + + if (device == NULL) { + AUDIO_DRIVER_LOG_ERR("device is NULL."); + return HDF_ERR_INVALID_OBJECT; + } + + ret = PlatformGetServiceName(device); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("get service name fail."); + return ret; + } + + ret = AudioSocDeviceRegister(device, (void *)&g_platformData, AUDIO_PLATFORM_DEVICE); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("register dai fail."); + return ret; + } + + platformHost = (struct PlatformHost *)device->service; + if (NULL != platformHost) { + OsalMutexInit(&platformHost->renderBufInfo.buffMutex); + OsalMutexInit(&platformHost->captureBufInfo.buffMutex); + } + + AUDIO_DRIVER_LOG_INFO("success.\n"); + return HDF_SUCCESS; +} + +static void PlatformDriverRelease(struct HdfDeviceObject *device) +{ + struct PlatformHost *platformHost = NULL; + + if (device == NULL) { + AUDIO_DRIVER_LOG_ERR("device is NULL"); + return; + } + + platformHost = (struct PlatformHost *)device->service; + if (platformHost == NULL) { + AUDIO_DRIVER_LOG_ERR("platformHost is NULL"); + return; + } + + OsalMutexDestroy(&platformHost->renderBufInfo.buffMutex); + OsalMutexDestroy(&platformHost->captureBufInfo.buffMutex); + OsalMemFree(platformHost); +} + +/* HdfDriverEntry definitions */ +struct HdfDriverEntry g_platformDriverEntry = { + .moduleVersion = 1, + .moduleName = "DMA_HI3516", + .Bind = PlatformDriverBind, + .Init = PlatformDriverInit, + .Release = PlatformDriverRelease, +}; +HDF_INIT(g_platformDriverEntry); diff --git a/audio/chipsets/hi3516dv300/soc/src/hi3516_platform_ops.c b/audio/chipsets/hi3516dv300/soc/src/hi3516_platform_ops.c new file mode 100755 index 0000000000..d639b7c1db --- /dev/null +++ b/audio/chipsets/hi3516dv300/soc/src/hi3516_platform_ops.c @@ -0,0 +1,1286 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. + */ + +#include "hi3516_platform_ops.h" +#ifdef __LITEOS__ +#include +#else +#include +#endif +#include "audio_platform_base.h" +#include "audio_sapm.h" +#include "hi3516_aiao_impl.h" +#include "hi3516_codec_impl.h" +#include "osal_io.h" +#include "osal_uaccess.h" + +#define HDF_LOG_TAG hi3516_platform_ops + +const int AIAO_BUFF_OFFSET = 128; +const int AIAO_BUFF_POINT = 320; +const int AIAO_BUFF_TRANS = 16 * 1024; +const int AIAO_BUFF_SIZE = 128 * 1024; +const int RENDER_TRAF_BUF_SIZE = 1024; +const int CAPTURE_TRAF_BUF_SIZE = 1024 * 16; + +const int AUDIO_BUFF_MIN = 128; +const int AUDIO_RECORD_MIN = 1024 * 16; +const int BITSTOBYTE = 8; + +static int g_captureBuffFreeCount = 0; +static int g_renderBuffFreeCount = 0; +static int g_renderBuffInitCount = 0; + +const int MIN_PERIOD_SIZE = 4096; +const int MAX_PERIOD_SIZE = 1024 * 16; +const int MIN_PERIOD_COUNT = 8; +const int MAX_PERIOD_COUNT = 32; +const int MAX_AIAO_BUFF_SIZE = 128 * 1024; +const int MIN_AIAO_BUFF_SIZE = 16 * 1024; +const int MMAP_MAX_FRAME_SIZE = 4096 * 2 * 3; +const int AUDIO_CACHE_ALIGN_SIZE = 64; +const int DELAY_TIME = 5; +const int LOOP_COUNT = 100; + +int32_t AudioRenderBuffInit(struct PlatformHost *platformHost) +{ + uint64_t buffSize; + if (platformHost == NULL) { + AUDIO_DRIVER_LOG_ERR("input para is NULL."); + return HDF_FAILURE; + } + + if (platformHost->renderBufInfo.virtAddr != NULL) { + return HDF_SUCCESS; + } + + buffSize = platformHost->renderBufInfo.periodCount * platformHost->renderBufInfo.periodSize; + if (buffSize < MIN_AIAO_BUFF_SIZE || buffSize > MAX_AIAO_BUFF_SIZE) { + AUDIO_DRIVER_LOG_ERR("buffSize is invalid."); + return HDF_FAILURE; + } + + platformHost->renderBufInfo.phyAddr = 0; +#ifdef __LITEOS__ + platformHost->renderBufInfo.virtAddr = (uint32_t *)LOS_DmaMemAlloc(&platformHost->renderBufInfo.phyAddr, buffSize, + AUDIO_CACHE_ALIGN_SIZE, DMA_NOCACHE); +#else + platformHost->renderBufInfo.virtAddr = dma_alloc_writecombine(NULL, buffSize, + (dma_addr_t *)&platformHost->renderBufInfo.phyAddr, GFP_DMA | GFP_KERNEL); +#endif + if (platformHost->renderBufInfo.virtAddr == NULL) { + AUDIO_DRIVER_LOG_ERR("mem alloc failed."); + return HDF_FAILURE; + } + platformHost->renderBufInfo.cirBufSize = buffSize; + + AUDIO_DRIVER_LOG_DEBUG("phyAddr = %x virtAddr = %x", + platformHost->renderBufInfo.phyAddr, platformHost->renderBufInfo.virtAddr); + AUDIO_DRIVER_LOG_DEBUG("g_renderBuffInitCount: %d", g_renderBuffInitCount++); + + return HDF_SUCCESS; +} + +int32_t AudioRenderBuffFree(struct PlatformHost *platformHost) +{ + if (platformHost == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is NULL."); + return HDF_FAILURE; + } + + if (platformHost->renderBufInfo.virtAddr != NULL) { +#ifdef __LITEOS__ + LOS_DmaMemFree(platformHost->renderBufInfo.virtAddr); +#else + dma_free_writecombine(NULL, platformHost->renderBufInfo.cirBufSize, platformHost->renderBufInfo.virtAddr, + platformHost->renderBufInfo.phyAddr); +#endif + } + + AUDIO_DRIVER_LOG_DEBUG("g_renderBuffFreeCount: %d", g_renderBuffFreeCount++); + + platformHost->renderBufInfo.virtAddr = NULL; + platformHost->renderBufInfo.phyAddr = 0; + return HDF_SUCCESS; +} + +int32_t AudioCaptureBuffInit(struct PlatformHost *platformHost) +{ + uint64_t buffSize; + if (platformHost == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is NULL."); + return HDF_FAILURE; + } + if (platformHost->captureBufInfo.virtAddr != NULL) { + return HDF_SUCCESS; + } + buffSize = platformHost->captureBufInfo.periodCount * platformHost->captureBufInfo.periodSize; + if (buffSize < MIN_AIAO_BUFF_SIZE || buffSize > MAX_AIAO_BUFF_SIZE) { + AUDIO_DRIVER_LOG_ERR("buffSize is invalid."); + return HDF_FAILURE; + } + + platformHost->captureBufInfo.phyAddr = 0; +#ifdef __LITEOS__ + platformHost->captureBufInfo.virtAddr = (uint32_t *)LOS_DmaMemAlloc(&platformHost->captureBufInfo.phyAddr, buffSize, + AUDIO_CACHE_ALIGN_SIZE, DMA_NOCACHE); +#else + platformHost->captureBufInfo.virtAddr = dma_alloc_writecombine(NULL, buffSize, + (dma_addr_t *)&platformHost->captureBufInfo.phyAddr, GFP_DMA | GFP_KERNEL); +#endif + if (platformHost->captureBufInfo.virtAddr == NULL) { + AUDIO_DRIVER_LOG_ERR("mem alloc failed."); + return HDF_FAILURE; + } + platformHost->captureBufInfo.cirBufSize = buffSize; + + AUDIO_DRIVER_LOG_DEBUG("phyAddr = %x virtAddr = %x", + platformHost->captureBufInfo.phyAddr, platformHost->captureBufInfo.virtAddr); + + return HDF_SUCCESS; +} + +int32_t AudioCaptureBuffFree(struct PlatformHost *platformHost) +{ + if (platformHost == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is NULL."); + return HDF_FAILURE; + } + + if (platformHost->captureBufInfo.virtAddr != NULL) { +#ifdef __LITEOS__ + LOS_DmaMemFree(platformHost->captureBufInfo.virtAddr); +#else + dma_free_writecombine(NULL, platformHost->captureBufInfo.cirBufSize, platformHost->captureBufInfo.virtAddr, + platformHost->captureBufInfo.phyAddr); +#endif + } + AUDIO_DRIVER_LOG_DEBUG("g_captureBuffFreeCount: %d", g_captureBuffFreeCount++); + + platformHost->captureBufInfo.virtAddr = NULL; + platformHost->captureBufInfo.phyAddr = 0; + return HDF_SUCCESS; +} + +int32_t AudioAoInit(const struct PlatformHost *platformHost) +{ + int ret; + + if (platformHost == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is NULL."); + return HDF_FAILURE; + } + + if (platformHost->renderBufInfo.phyAddr == 0) { + AUDIO_DRIVER_LOG_ERR("phyAddr is error"); + return HDF_FAILURE; + } + ret = AopHalSetBufferAddr(0, platformHost->renderBufInfo.phyAddr); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AopHalSetBufferAddr fail."); + return HDF_FAILURE; + } + + ret = AopHalSetBufferSize(0, platformHost->renderBufInfo.cirBufSize); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AopHalSetBufferSize: failed."); + return HDF_FAILURE; + } + + AUDIO_DRIVER_LOG_DEBUG("AopHalSetBufferSize: %d", platformHost->renderBufInfo.cirBufSize); + + ret = AopHalSetTransSize(0, platformHost->renderBufInfo.trafBufSize); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AopHalSetTransSize fail"); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioAiInit(const struct PlatformHost *platformHost) +{ + int ret; + if (platformHost == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is NULL."); + return HDF_FAILURE; + } + + if (platformHost->captureBufInfo.phyAddr == 0) { + AUDIO_DRIVER_LOG_ERR("phyAddr is error"); + return HDF_FAILURE; + } + + ret = AipHalSetBufferAddr(0, platformHost->captureBufInfo.phyAddr); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AipHalSetBufferAddr: failed."); + return HDF_FAILURE; + } + + ret = AipHalSetBufferSize(0, platformHost->captureBufInfo.cirBufSize); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AipHalSetBufferSize: failed."); + return HDF_FAILURE; + } + + ret = AipHalSetTransSize(0, AIAO_BUFF_POINT); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AipHalSetTransSize fail."); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +static void SysWritelI2s(unsigned long addr, unsigned int value) +{ + *(volatile unsigned int *)(addr) = value; +} + +int32_t AiaoSysPinMux(void) +{ + static void *regIocfg2Base = 0; + static void *regIocfg3Base = 0; + static void *regGpioBase = 0; + + regIocfg2Base = OsalIoRemap(IOCFG2_BASE_ADDR, BASE_ADDR_REMAP_SIZE); + if (regIocfg2Base == NULL) { + AUDIO_DRIVER_LOG_ERR("regIocfg2Base is NULL."); + return HDF_FAILURE; + } + + regIocfg3Base = OsalIoRemap(IOCFG3_BASE_ADDR, BASE_ADDR_REMAP_SIZE); + if (regIocfg3Base == NULL) { + AUDIO_DRIVER_LOG_ERR("regIocfg3Base is NULL."); + return HDF_FAILURE; + } + + regGpioBase = OsalIoRemap(GPIO_BASE_ADDR, BASE_ADDR_REMAP_SIZE); + if (regGpioBase == NULL) { + AUDIO_DRIVER_LOG_ERR("regGpioBase is NULL."); + return HDF_FAILURE; + } + + AUDIO_DRIVER_LOG_DEBUG("I2s0PinMuxAmpUnmute i2s0_pin_mux"); + SysWritelI2s((uintptr_t)regIocfg2Base + I2S_IOCFG2_BASE1, I2S_IOCFG2_BASE1_VAL); + SysWritelI2s((uintptr_t)regIocfg2Base + I2S_IOCFG2_BASE2, I2S_IOCFG2_BASE2_VAL); + SysWritelI2s((uintptr_t)regIocfg2Base + I2S_IOCFG2_BASE3, I2S_IOCFG2_BASE3_VAL); + SysWritelI2s((uintptr_t)regIocfg2Base + I2S_IOCFG2_BASE4, I2S_IOCFG2_BASE4_VAL); + SysWritelI2s((uintptr_t)regIocfg2Base + I2S_IOCFG2_BASE5, I2S_IOCFG2_BASE5_VAL); + + AUDIO_DRIVER_LOG_DEBUG("I2s0PinMuxAmpUnmute AmpUnmute"); + SysWritelI2s((uintptr_t)regIocfg3Base + I2S_IOCFG3_BASE1, I2S_IOCFG3_BASE1_VAL); + SysWritelI2s((uintptr_t)regGpioBase + GPIO_BASE1, GPIO_BASE3_VAL); + SysWritelI2s((uintptr_t)regGpioBase + GPIO_BASE2, GPIO_BASE2_VAL); + SysWritelI2s((uintptr_t)regGpioBase + GPIO_BASE3, GPIO_BASE3_VAL); + + OsalIoUnmap(regGpioBase); + OsalIoUnmap(regIocfg3Base); + OsalIoUnmap(regIocfg2Base); + return HDF_SUCCESS; +} + +int32_t AudioPlatformDeviceInit(const struct AudioCard *card, const struct PlatformDevice *platform) +{ + struct PlatformHost *platformHost = NULL; + int ret; + unsigned int chnId = 0; + + if (platform == NULL || platform->device == NULL) { + AUDIO_DRIVER_LOG_ERR("platform is NULL."); + return HDF_FAILURE; + } + (void)card; + + platformHost = (struct PlatformHost *)platform->device->service; + if (platformHost == NULL) { + AUDIO_DRIVER_LOG_ERR("platform host is NULL."); + return HDF_FAILURE; + } + + if (platformHost->platformInitFlag == true) { + AUDIO_DRIVER_LOG_DEBUG("platform init complete!"); + return HDF_SUCCESS; + } + platformHost->platformInitFlag = true; + + ret = AiaoHalSysInit(); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AiaoHalSysInit: fail."); + return HDF_FAILURE; + } + + /* PIN MUX */ + ret = AiaoSysPinMux(); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AiaoSysPinMux: fail."); + return HDF_FAILURE; + } + + /* CLK reset */ + ret = AiaoClockReset(); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AiaoClockReset: fail"); + return HDF_FAILURE; + } + + /* aiao init */ + ret = AiaoDeviceInit(chnId); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AiaoClockReset: fail"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t RenderSetAiaoAttr(struct PlatformHost *platformHost, const struct AudioPcmHwParams *param) +{ + if (platformHost == NULL || param == NULL) { + AUDIO_DRIVER_LOG_ERR("platform is NULL."); + return HDF_FAILURE; + } + platformHost->renderBufInfo.period = param->period; + if (param->periodSize < MIN_PERIOD_SIZE || param->periodSize > MAX_PERIOD_SIZE) { + AUDIO_DRIVER_LOG_ERR("periodSize is invalid."); + return HDF_FAILURE; + } + platformHost->renderBufInfo.periodSize = param->periodSize; + if (param->periodCount < MIN_PERIOD_COUNT || param->periodCount > MAX_PERIOD_COUNT) { + AUDIO_DRIVER_LOG_ERR("periodCount is invalid."); + return HDF_FAILURE; + } + platformHost->renderBufInfo.periodCount = param->periodCount; + + platformHost->renderBufInfo.trafBufSize = RENDER_TRAF_BUF_SIZE; + return HDF_SUCCESS; +} + +int32_t CaptureSetAiaoAttr(struct PlatformHost *platformHost, const struct AudioPcmHwParams *param) +{ + if (platformHost == NULL || param == NULL) { + AUDIO_DRIVER_LOG_ERR("platformHost or param is NULL."); + return HDF_FAILURE; + } + + platformHost->captureBufInfo.period = param->period; + if (param->periodSize < MIN_PERIOD_SIZE || param->periodSize > MAX_PERIOD_SIZE) { + AUDIO_DRIVER_LOG_ERR("periodSize is invalid %d.", param->periodSize); + return HDF_FAILURE; + } + platformHost->captureBufInfo.periodSize = param->periodSize; + if (param->periodCount < MIN_PERIOD_COUNT || param->periodCount > MAX_PERIOD_COUNT) { + AUDIO_DRIVER_LOG_ERR("periodCount is invalid %d.", param->periodCount); + return HDF_FAILURE; + } + platformHost->captureBufInfo.periodCount = param->periodCount; + + if (param->silenceThreshold < MIN_PERIOD_SIZE || param->silenceThreshold > MAX_PERIOD_SIZE) { + AUDIO_DRIVER_LOG_ERR("silenceThreshold is invalid %d.", param->silenceThreshold); + return HDF_FAILURE; + } + platformHost->captureBufInfo.trafBufSize = param->silenceThreshold; + return HDF_SUCCESS; +} + +int32_t PlatformHwParams(const struct AudioCard *card, const struct AudioPcmHwParams *param) +{ + int ret; + const int chnlCntMin = 1; + const int chnlCntMax = 2; + struct PlatformHost *platformHost = NULL; + AUDIO_DRIVER_LOG_DEBUG("entry."); + + if (card == NULL || card->rtd == NULL || card->rtd->platform == NULL || + param == NULL || param->cardServiceName == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is NULL."); + return HDF_FAILURE; + } + + if (param->channels < chnlCntMin || param->channels > chnlCntMax) { + AUDIO_DRIVER_LOG_ERR("channels param is invalid."); + return HDF_FAILURE; + } + + platformHost = PlatformHostFromDevice(card->rtd->platform->device); + if (platformHost == NULL) { + AUDIO_DRIVER_LOG_ERR("platformHost is null."); + return HDF_FAILURE; + } + + platformHost->pcmInfo.rate = param->rate; + platformHost->pcmInfo.frameSize = param->channels * platformHost->pcmInfo.bitWidth / BITSTOBYTE; + + platformHost->renderBufInfo.chnId = 0; + platformHost->captureBufInfo.chnId = 0; + + platformHost->pcmInfo.isBigEndian = param->isBigEndian; + platformHost->pcmInfo.isSignedData = param->isSignedData; + + platformHost->pcmInfo.startThreshold = param->startThreshold; + platformHost->pcmInfo.stopThreshold = param->stopThreshold; + platformHost->pcmInfo.silenceThreshold = param->silenceThreshold; + + if (param->streamType == AUDIO_RENDER_STREAM) { + ret = RenderSetAiaoAttr(platformHost, param); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AoSetClkAttr: fail."); + return HDF_FAILURE; + } + } else if (param->streamType == AUDIO_CAPTURE_STREAM) { + ret = CaptureSetAiaoAttr(platformHost, param); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AiSetClkAttr: fail."); + return HDF_FAILURE; + } + } else { + AUDIO_DRIVER_LOG_ERR("param streamType is invalid."); + return HDF_FAILURE; + } + AUDIO_DRIVER_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +int32_t PlatformRenderPrepare(const struct AudioCard *card) +{ + int ret; + struct PlatformHost *platformHost = NULL; + AUDIO_DRIVER_LOG_DEBUG("PlatformPrepare: entry."); + + ret = PlatformCreatePlatformHost(card, &platformHost); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("PlatformCreatePlatformHost failed."); + return HDF_FAILURE; + } + + if (platformHost->renderBufInfo.virtAddr == NULL) { + ret = AudioRenderBuffInit(platformHost); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioRenderBuffInit: fail."); + return HDF_FAILURE; + } + + ret = AudioAoInit(platformHost); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioAoInit: fail."); + return HDF_FAILURE; + } + } + + if (platformHost->renderBufInfo.virtAddr != NULL) { + (void)memset_s(platformHost->renderBufInfo.virtAddr, + platformHost->renderBufInfo.cirBufSize, 0, + platformHost->renderBufInfo.cirBufSize); + } + platformHost->renderBufInfo.wbufOffSet = 0; + platformHost->renderBufInfo.wptrOffSet = 0; + platformHost->pcmInfo.totalStreamSize = 0; + platformHost->renderBufInfo.framesPosition = 0; + + ret = AopHalSetBuffWptr(0, 0); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AopHalSetBuffWptr: failed."); + return HDF_FAILURE; + } + + ret = AopHalSetBuffRptr(0, 0); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AopHalSetBuffRptr: failed."); + return HDF_FAILURE; + } + AUDIO_DRIVER_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +int32_t PlatformCapturePrepare(const struct AudioCard *card) +{ + int ret; + struct PlatformHost *platformHost = NULL; + AUDIO_DRIVER_LOG_DEBUG("entry."); + + ret = PlatformCreatePlatformHost(card, &platformHost); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("PlatformCreatePlatformHost failed."); + return HDF_FAILURE; + } + + if (platformHost->captureBufInfo.virtAddr == NULL) { + ret = AudioCaptureBuffInit(platformHost); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioCaptureBuffInit: fail."); + return HDF_FAILURE; + } + ret = AudioAiInit(platformHost); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioAiInit: fail."); + return HDF_FAILURE; + } + } + + if (platformHost->captureBufInfo.virtAddr != NULL) { + (void)memset_s(platformHost->captureBufInfo.virtAddr, + platformHost->captureBufInfo.cirBufSize, 0, + platformHost->captureBufInfo.cirBufSize); + } + platformHost->captureBufInfo.wbufOffSet = 0; + platformHost->captureBufInfo.wptrOffSet = 0; + platformHost->captureBufInfo.chnId = 0; + platformHost->pcmInfo.totalStreamSize = 0; + platformHost->captureBufInfo.framesPosition = 0; + + ret = AipHalSetBuffWptr(0, 0); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AipHalSetBuffWptr: failed."); + return HDF_FAILURE; + } + + ret = AipHalSetBuffRptr(0, 0); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AipHalSetBuffRptr: failed."); + return HDF_FAILURE; + } + + AUDIO_DRIVER_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +static int32_t UpdateWriteBufData(struct PlatformHost *platformHost, unsigned int wptr, + unsigned int buffSize, unsigned int *buffOffset, const char *buf) +{ + int ret; + unsigned int buffFirstSize; + unsigned int buffSecordSize; + if (platformHost == NULL || buffOffset == NULL || buf == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is invalid."); + return HDF_ERR_INVALID_PARAM; + } + + if (platformHost->renderBufInfo.cirBufSize - wptr >= buffSize) { + *buffOffset = wptr + buffSize; + ret = memcpy_s((char *)(platformHost->renderBufInfo.virtAddr) + wptr, + buffSize, buf, buffSize); + if (ret != 0) { + AUDIO_DRIVER_LOG_ERR("memcpy_s failed."); + return HDF_FAILURE; + } + if (*buffOffset >= platformHost->renderBufInfo.cirBufSize) { + *buffOffset = 0; + } + } else { + buffFirstSize = platformHost->renderBufInfo.cirBufSize - wptr; + ret = memcpy_s((char *)(platformHost->renderBufInfo.virtAddr) + wptr, + buffFirstSize, buf, buffFirstSize); + if (ret != 0) { + AUDIO_DRIVER_LOG_ERR("memcpy_s failed."); + return HDF_FAILURE; + } + + buffSecordSize = buffSize - buffFirstSize; + ret = memcpy_s((char *)platformHost->renderBufInfo.virtAddr, + buffSecordSize, buf + buffFirstSize, + buffSecordSize); + if (ret != 0) { + AUDIO_DRIVER_LOG_ERR("memcpy_s failed."); + return HDF_FAILURE; + } + *buffOffset = buffSecordSize; + } + return HDF_SUCCESS; +} + +static int32_t UpdateWriteBuffOffset(struct PlatformHost *platformHost, + unsigned int buffSize, unsigned int *buffOffset, struct AudioTxData *txData) +{ + unsigned int buffAvailable; + int ret; + unsigned int wptr; + unsigned int rptr; + int devId; + if (platformHost == NULL || buffOffset == NULL || txData == NULL || txData->buf == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is invalid."); + return HDF_ERR_INVALID_PARAM; + } + + devId = platformHost->renderBufInfo.chnId; + rptr = AiaoHalReadReg(AopBuffRptrReg(devId)); + wptr = AiaoHalReadReg(AopBuffWptrReg(devId)); + AUDIO_DRIVER_LOG_DEBUG("rptrReg = [0x%08x, wptrReg = [0x%08x], input size = [%u]", + rptr, wptr, buffSize); + + if (wptr >= rptr) { + // [S ... R ... W ... E] + buffAvailable = platformHost->renderBufInfo.cirBufSize - (wptr - rptr); + + if (buffAvailable < buffSize + AUDIO_BUFF_MIN) { + AUDIO_DRIVER_LOG_DEBUG("not available buffer."); + txData->status = ENUM_CIR_BUFF_FULL; + return HDF_SUCCESS; + } + + ret = UpdateWriteBufData(platformHost, wptr, buffSize, buffOffset, txData->buf); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("UpdateWriteBufData: fail."); + return HDF_FAILURE; + } + } else { + // [S ... W ... R ... E] + buffAvailable = rptr - wptr; + + if (buffAvailable < buffSize + AUDIO_BUFF_MIN) { + AUDIO_DRIVER_LOG_DEBUG("not available buffer."); + txData->status = ENUM_CIR_BUFF_FULL; + return HDF_SUCCESS; + } + + *buffOffset = wptr + buffSize; + ret = memcpy_s((char *)(platformHost->renderBufInfo.virtAddr) + wptr, + buffSize, txData->buf, buffSize); + if (ret != 0) { + AUDIO_DRIVER_LOG_ERR("memcpy_s failed."); + return HDF_FAILURE; + } + } + txData->status = ENUM_CIR_BUFF_NORMAL; + return HDF_SUCCESS; +} + +static int32_t SetWriteBuffWptr(struct PlatformHost *platformHost, + unsigned int buffSize, struct AudioTxData *txData) +{ + int ret; + int devId; + int buffOffset; + + if (platformHost == NULL || txData == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is invalid."); + return HDF_ERR_INVALID_PARAM; + } + + devId = platformHost->renderBufInfo.chnId; + ret = UpdateWriteBuffOffset(platformHost, buffSize, &buffOffset, txData); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("UpdateWptrRptr: failed."); + return HDF_FAILURE; + } + if (txData->status == ENUM_CIR_BUFF_FULL) { + AUDIO_DRIVER_LOG_DEBUG("not available buffer wait a minute."); + return HDF_SUCCESS; + } + + if (platformHost->renderBufInfo.runStatus == 1) { + platformHost->pcmInfo.totalStreamSize += buffSize; + ret = AopHalSetBuffWptr(devId, buffOffset); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AopHalSetBuffWptr failed."); + return HDF_FAILURE; + } + } + txData->status = ENUM_CIR_BUFF_NORMAL; + return HDF_SUCCESS; +} +int32_t PlatformWriteProcBigEndian(const struct AudioCard *card, struct AudioTxData *txData) +{ + uint64_t buffSize; + struct PlatformHost *platformHost = NULL; + if (card == NULL || card->rtd == NULL || card->rtd->platform == NULL || + txData == NULL || txData->buf == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is null."); + return HDF_FAILURE; + } + platformHost = PlatformHostFromDevice(card->rtd->platform->device); + if (platformHost == NULL) { + AUDIO_DRIVER_LOG_ERR("from PlatformHostFromDevice get platformHost is NULL."); + return HDF_FAILURE; + } + buffSize = txData->frames * platformHost->pcmInfo.frameSize; + if (platformHost->pcmInfo.isBigEndian) { + if (AudioDataBigEndianChange(txData->buf, buffSize, platformHost->pcmInfo.bitWidth) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioDataBigEndianChange: failed."); + return HDF_FAILURE; + } + } + return HDF_SUCCESS; +} + +int32_t PlatformWriteExec(const struct AudioCard *card, struct AudioTxData *txData) +{ + uint64_t buffSize; + uint64_t startThreshold; + struct PlatformHost *platformHost = NULL; + AUDIO_DRIVER_LOG_DEBUG("entry."); + if (card == NULL || card->rtd == NULL || card->rtd->platform == NULL || + txData == NULL || txData->buf == NULL) { + AUDIO_DRIVER_LOG_ERR("param is null."); + return HDF_FAILURE; + } + + platformHost = PlatformHostFromDevice(card->rtd->platform->device); + if (platformHost == NULL) { + AUDIO_DRIVER_LOG_ERR("from PlatformHostFromDevice get platformHost is NULL."); + return HDF_FAILURE; + } + + OsalMutexLock(&platformHost->renderBufInfo.buffMutex); + if (platformHost->renderBufInfo.virtAddr == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformWrite renderBufInfo.virtAddr is nullptr."); + OsalMutexUnlock(&platformHost->renderBufInfo.buffMutex); + return HDF_FAILURE; + } + buffSize = txData->frames * platformHost->pcmInfo.frameSize; + startThreshold = platformHost->pcmInfo.startThreshold * platformHost->pcmInfo.frameSize; + + if (buffSize >= platformHost->renderBufInfo.cirBufSize) { + AUDIO_DRIVER_LOG_ERR("stream data too long."); + OsalMutexUnlock(&platformHost->renderBufInfo.buffMutex); + return HDF_FAILURE; + } + + if (platformHost->renderBufInfo.runStatus == 1) { + if ((platformHost->renderBufInfo.enable == 0) && + (platformHost->pcmInfo.totalStreamSize > startThreshold)) { + AopHalDevEnable(platformHost->captureBufInfo.chnId); + platformHost->renderBufInfo.enable = 1; + } + } + + if (SetWriteBuffWptr(platformHost, buffSize, txData) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("SetWriteBuffWptr: failed."); + OsalMutexUnlock(&platformHost->renderBufInfo.buffMutex); + return HDF_FAILURE; + } + OsalMutexUnlock(&platformHost->renderBufInfo.buffMutex); + + AUDIO_DRIVER_LOG_DEBUG("now total = %d", platformHost->pcmInfo.totalStreamSize); + return HDF_SUCCESS; +} + +int32_t PlatformWrite(const struct AudioCard *card, struct AudioTxData *txData) +{ + int32_t ret; + ret = PlatformWriteProcBigEndian(card, txData); + if (ret != HDF_SUCCESS) { + return ret; + } + return PlatformWriteExec(card, txData); +} + +static int32_t PlatformMmapWriteData(const struct AudioCard *card, struct AudioTxData *txData) +{ + int32_t ret; + int tryCount = LOOP_COUNT; + + if (card == NULL || txData == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is null!"); + return HDF_FAILURE; + } + ret = PlatformWriteProcBigEndian(card, txData); + if (ret != HDF_SUCCESS) { + return HDF_FAILURE; + } + while (tryCount > 0) { + ret = PlatformWriteExec(card, txData); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("PlatformWrite failed."); + return HDF_FAILURE; + } + if (txData->status != ENUM_CIR_BUFF_FULL) { + break; + } + tryCount--; + OsalMDelay(DELAY_TIME); + } + if (tryCount <= 0) { + AUDIO_DRIVER_LOG_ERR("frame drop"); + } + return HDF_SUCCESS; +} + +static int32_t PlatformMmapWriteSub(const struct AudioCard *card, struct PlatformHost *platformHost, + const struct AudioTxMmapData *txMmapData) +{ + int32_t ret; + int32_t count = 1; + struct AudioTxData txData; + + ret = (card == NULL || platformHost == NULL || txMmapData == NULL || txMmapData->memoryAddress == NULL + || txMmapData->transferFrameSize <= 0 || txMmapData->totalBufferFrames <= 0); + if (ret) { + AUDIO_DRIVER_LOG_ERR("param is invalid."); + return HDF_ERR_INVALID_PARAM; + } + uint32_t offset = txMmapData->offset; + uint32_t frameSize = platformHost->pcmInfo.channels * (platformHost->pcmInfo.bitWidth / MIN_PERIOD_COUNT); + uint32_t totalSize = txMmapData->totalBufferFrames * frameSize; + uint32_t buffSize = txMmapData->transferFrameSize * frameSize; + uint32_t pageSize = ((buffSize % MIN_PERIOD_SIZE) == 0) ? + buffSize : (buffSize / MIN_PERIOD_SIZE + 1) * MIN_PERIOD_SIZE; + uint32_t lastBuffSize = ((totalSize % pageSize) == 0) ? pageSize : (totalSize % pageSize); + uint32_t loopTimes = (lastBuffSize == pageSize) ? (totalSize / pageSize) : (totalSize / pageSize + 1); + txData.frames = pageSize / frameSize; + txData.buf = OsalMemCalloc(pageSize); + if (txData.buf == NULL) { + AUDIO_DRIVER_LOG_ERR("txData.buf is null."); + return HDF_FAILURE; + } + platformHost->renderBufInfo.framesPosition = 0; + while (count <= loopTimes) { + uint32_t copyLength = (count < loopTimes) ? pageSize : lastBuffSize; + ret = CopyFromUser(txData.buf, txMmapData->memoryAddress + offset, copyLength); + if (ret != EOK) { + AUDIO_DRIVER_LOG_ERR("memcpy_s failed."); + OsalMemFree(txData.buf); + return HDF_FAILURE; + } + ret = PlatformMmapWriteData(card, &txData); + if (ret != HDF_SUCCESS) { + OsalMemFree(txData.buf); + return HDF_FAILURE; + } + offset += copyLength; + count++; + platformHost->renderBufInfo.framesPosition += copyLength / frameSize; + } + OsalMemFree(txData.buf); + return HDF_SUCCESS; +} + +int32_t PlatformMmapWrite(const struct AudioCard *card, struct AudioTxMmapData *txMmapData) +{ + int32_t ret; + struct PlatformHost *platformHost = NULL; + + AUDIO_DRIVER_LOG_DEBUG("entry."); + ret = (card == NULL || card->rtd == NULL || card->rtd->platform == NULL || txMmapData == NULL + || txMmapData->memoryAddress == NULL || txMmapData->transferFrameSize <= 0 + || txMmapData->totalBufferFrames <= 0); + if (ret) { + AUDIO_DRIVER_LOG_ERR("param is invalid."); + return HDF_ERR_INVALID_PARAM; + } + + platformHost = PlatformHostFromDevice(card->rtd->platform->device); + if (platformHost == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformHostFromDevice fail."); + return HDF_FAILURE; + } + OsalMutexLock(&platformHost->renderBufInfo.buffMutex); + if (platformHost->renderBufInfo.virtAddr == NULL) { + AUDIO_DRIVER_LOG_ERR("renderBufInfo.virtAddr is nullptr."); + OsalMutexUnlock(&platformHost->renderBufInfo.buffMutex); + return HDF_FAILURE; + } + if (!platformHost->pcmInfo.channels) { + platformHost->pcmInfo.channels = CHANNEL_MAX_NUM; + } + if (!platformHost->pcmInfo.bitWidth) { + platformHost->pcmInfo.bitWidth = DATA_BIT_WIDTH16; + } + OsalMutexUnlock(&platformHost->renderBufInfo.buffMutex); + + ret = PlatformMmapWriteSub(card, platformHost, txMmapData); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("PlatformMmapWriteSub failed."); + return HDF_FAILURE; + } + AUDIO_DRIVER_LOG_DEBUG("render mmap write success."); + return HDF_SUCCESS; +} + +static int32_t UpdateReadBuffData(const struct PlatformHost *platformHost, + unsigned int *tranferSize, unsigned int *buffOffset, + struct AudioRxData *rxData) +{ + unsigned int dataAvailable; + unsigned int validData; + unsigned int wptr; + unsigned int rptr; + int devId; + devId = platformHost->captureBufInfo.chnId; + // Buf/DMA offset + rptr = AiaoHalReadReg(AipBuffRptrReg(devId)); + wptr = AiaoHalReadReg(AipBuffWptrReg(devId)); + // Buf manage + if (wptr >= rptr) { + // [S ... R ... W ... E] + dataAvailable = wptr - rptr; + + if (dataAvailable >= platformHost->captureBufInfo.trafBufSize) { + rxData->buf = (char *)(platformHost->captureBufInfo.virtAddr) + rptr; + *tranferSize = platformHost->captureBufInfo.trafBufSize; + *buffOffset = rptr + *tranferSize; + } else { + AUDIO_DRIVER_LOG_DEBUG("PlatformRead: not available data."); + rxData->buf = (char *)(platformHost->captureBufInfo.virtAddr) + rptr; + rxData->status = ENUM_CIR_BUFF_EMPTY; + rxData->bufSize = 0; + rxData->frames = 0; + return HDF_SUCCESS; + } + + AUDIO_DRIVER_LOG_DEBUG("tranferSize : %d buffOffset : %d ", *tranferSize, *buffOffset); + } else { + // [S ... W ... R ... E] + validData = rptr + platformHost->captureBufInfo.trafBufSize; + if (validData < platformHost->captureBufInfo.cirBufSize) { + rxData->buf = (char *)(platformHost->captureBufInfo.virtAddr) + rptr; + *tranferSize = platformHost->captureBufInfo.trafBufSize; + *buffOffset = rptr + *tranferSize; + } else { + rxData->buf = (char *)(platformHost->captureBufInfo.virtAddr) + rptr; + *tranferSize = platformHost->captureBufInfo.cirBufSize - rptr; + *buffOffset = 0; + } + AUDIO_DRIVER_LOG_DEBUG("tranferSize : %d rptrReg.u32 : %d ", *tranferSize, rptr); + } + + AUDIO_DRIVER_LOG_DEBUG("rptrReg = [0x%08x], wptrReg = [0x%08x], max size = [%u]", + rptr, wptr, platformHost->captureBufInfo.trafBufSize); + + return HDF_SUCCESS; +} + +int32_t PlatformRead(const struct AudioCard *card, struct AudioRxData *rxData) +{ + unsigned int buffOffset; + struct PlatformHost *platformHost = NULL; + int devId; + unsigned int tranferSize; + + if (rxData == NULL || card == NULL || card->rtd == NULL || card->rtd->platform == NULL) { + AUDIO_DRIVER_LOG_ERR("param is null."); + return HDF_FAILURE; + } + + platformHost = PlatformHostFromDevice(card->rtd->platform->device); + if (platformHost == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformHostFromDevice: fail."); + return HDF_FAILURE; + } + devId = platformHost->captureBufInfo.chnId; + + OsalMutexLock(&platformHost->captureBufInfo.buffMutex); + if (platformHost->captureBufInfo.virtAddr == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformWrite: capture data buffer is not initialized."); + OsalMutexUnlock(&platformHost->captureBufInfo.buffMutex); + return HDF_FAILURE; + } + + if (UpdateReadBuffData(platformHost, &tranferSize, &buffOffset, rxData) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("UpdateReadBuffData failed."); + OsalMutexUnlock(&platformHost->captureBufInfo.buffMutex); + return HDF_FAILURE; + } + OsalMutexUnlock(&platformHost->captureBufInfo.buffMutex); + + if (rxData->status == ENUM_CIR_BUFF_EMPTY) { + AUDIO_DRIVER_LOG_DEBUG("not available data wait a minute."); + return HDF_SUCCESS; + } + + if (!platformHost->pcmInfo.isBigEndian) { + if (AudioDataBigEndianChange(rxData->buf, tranferSize, platformHost->pcmInfo.bitWidth) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioDataBigEndianChange: failed."); + return HDF_FAILURE; + } + } + + rxData->frames = tranferSize / platformHost->pcmInfo.frameSize; + rxData->bufSize = tranferSize; + rxData->status = ENUM_CIR_BUFF_NORMAL; + + if (buffOffset >= platformHost->captureBufInfo.cirBufSize) { + buffOffset = 0; + } + + if (AipHalSetBuffRptr(devId, buffOffset) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AipHalSetBuffRptr failed."); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t PlatformMmapReadSub(const struct AudioCard *card, struct PlatformHost *platformHost, + const struct AudioRxMmapData *rxMmapData) +{ + int32_t ret; + struct AudioRxData rxData; + uint32_t offset = 0; + uint32_t frameSize; + int totalSize; + int count = LOOP_COUNT; + + ret = (card == NULL || platformHost == NULL || rxMmapData == NULL || rxMmapData->memoryAddress == NULL + || rxMmapData->totalBufferFrames <= 0); + if (ret) { + AUDIO_DRIVER_LOG_ERR("param is invalid."); + return HDF_ERR_INVALID_PARAM; + } + + frameSize = platformHost->pcmInfo.channels * (platformHost->pcmInfo.bitWidth / MIN_PERIOD_COUNT); + totalSize = rxMmapData->totalBufferFrames * frameSize; + platformHost->captureBufInfo.framesPosition = 0; + do { + rxData.status = ENUM_CIR_BUFF_NORMAL; + ret = PlatformRead(card, &rxData); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("PlatformRead failed."); + return HDF_FAILURE; + } + if (rxData.status == ENUM_CIR_BUFF_EMPTY) { + if (count > 0) { + count--; + OsalMDelay(DELAY_TIME); + continue; + } else { + AUDIO_DRIVER_LOG_ERR("Loop out of 50 times."); + return HDF_FAILURE; + } + } + count = LOOP_COUNT; + ret = CopyToUser(rxMmapData->memoryAddress + offset, rxData.buf, rxData.bufSize); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("CopyToUser failed."); + return HDF_FAILURE; + } + offset += rxData.bufSize; + platformHost->captureBufInfo.framesPosition += rxData.bufSize / frameSize; + } while (offset < totalSize); + return HDF_SUCCESS; +} + +int32_t PlatformMmapRead(const struct AudioCard *card, struct AudioRxMmapData *rxMmapData) +{ + int32_t ret; + struct PlatformHost *platformHost = NULL; + + AUDIO_DRIVER_LOG_DEBUG("entry."); + ret = (card == NULL || card->rtd == NULL || card->rtd->platform == NULL || rxMmapData == NULL + || rxMmapData->memoryAddress == NULL || rxMmapData->totalBufferFrames <= 0); + if (ret) { + AUDIO_DRIVER_LOG_ERR("param is invalid."); + return HDF_ERR_INVALID_PARAM; + } + platformHost = PlatformHostFromDevice(card->rtd->platform->device); + if (platformHost == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformHostFromDevice is invalid."); + return HDF_FAILURE; + } + if (!platformHost->pcmInfo.channels) { + platformHost->pcmInfo.channels = CHANNEL_MAX_NUM; + } + if (!platformHost->pcmInfo.bitWidth) { + platformHost->pcmInfo.bitWidth = DATA_BIT_WIDTH16; + } + ret = PlatformMmapReadSub(card, platformHost, rxMmapData); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("PlatformMmapReadSub failed."); + return HDF_FAILURE; + } + AUDIO_DRIVER_LOG_DEBUG("capture mmap read success."); + return HDF_SUCCESS; +} + +int32_t PlatformRenderStart(struct AudioCard *card) +{ + int ret; + struct PlatformHost *platformHost = NULL; + + ret = PlatformCreatePlatformHost(card, &platformHost); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("PlatformCreatePlatformHost failed."); + return HDF_FAILURE; + } + + platformHost->renderBufInfo.runStatus = 1; + platformHost->renderBufInfo.enable = 0; + + ret = AudioSampSetPowerMonitor(card, false); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioSampSetPowerMonitor failed."); + return HDF_FAILURE; + } + + AUDIO_DRIVER_LOG_DEBUG("audio render start"); + return HDF_SUCCESS; +} + +int32_t PlatformCaptureStart(struct AudioCard *card) +{ + int ret; + struct PlatformHost *platformHost = NULL; + + ret = PlatformCreatePlatformHost(card, &platformHost); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("PlatformCreatePlatformHost failed."); + return HDF_FAILURE; + } + + AipHalSetRxStart(platformHost->captureBufInfo.chnId, HI_TRUE); + + ret = AudioSampSetPowerMonitor(card, false); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioSampSetPowerMonitor failed."); + return HDF_FAILURE; + } + + AUDIO_DRIVER_LOG_DEBUG("audio capture start"); + return HDF_SUCCESS; +} + +int32_t PlatformRenderStop(struct AudioCard *card) +{ + int ret; + struct PlatformHost *platformHost = NULL; + + ret = PlatformCreatePlatformHost(card, &platformHost); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("PlatformCreatePlatformHost failed."); + return HDF_FAILURE; + } + + OsalMutexLock(&platformHost->renderBufInfo.buffMutex); + platformHost->renderBufInfo.runStatus = 0; + AopHalSetTxStart(platformHost->renderBufInfo.chnId, HI_FALSE); + ret = AudioRenderBuffFree(platformHost); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioRenderBuffFree failed."); + OsalMutexUnlock(&platformHost->renderBufInfo.buffMutex); + return HDF_FAILURE; + } + OsalMutexUnlock(&platformHost->renderBufInfo.buffMutex); + + ret = AudioSampSetPowerMonitor(card, true); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioSampSetPowerMonitor failed."); + return HDF_FAILURE; + } + + AUDIO_DRIVER_LOG_DEBUG("audio stream stop"); + return HDF_SUCCESS; +} + +int32_t PlatformCaptureStop(struct AudioCard *card) +{ + int ret; + struct PlatformHost *platformHost = NULL; + + ret = PlatformCreatePlatformHost(card, &platformHost); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("PlatformCreatePlatformHost failed."); + return HDF_FAILURE; + } + OsalMutexLock(&platformHost->captureBufInfo.buffMutex); + AipHalSetRxStart(platformHost->captureBufInfo.chnId, HI_FALSE); + ret = AudioCaptureBuffFree(platformHost); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioCaptureBuffFree failed."); + OsalMutexUnlock(&platformHost->captureBufInfo.buffMutex); + return HDF_FAILURE; + } + OsalMutexUnlock(&platformHost->captureBufInfo.buffMutex); + + ret = AudioSampSetPowerMonitor(card, true); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioSampSetPowerMonitor failed."); + return HDF_FAILURE; + } + + AUDIO_DRIVER_LOG_DEBUG("audio stream stop"); + return HDF_SUCCESS; +} + +int32_t PlatformCapturePause(struct AudioCard *card) +{ + int ret; + struct PlatformHost *platformHost = NULL; + + ret = PlatformCreatePlatformHost(card, &platformHost); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("PlatformCreatePlatformHost failed."); + return HDF_FAILURE; + } + + AipHalSetRxStart(platformHost->captureBufInfo.chnId, HI_FALSE); + + ret = AudioSampSetPowerMonitor(card, true); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioSampSetPowerMonitor failed."); + return HDF_FAILURE; + } + + AUDIO_DRIVER_LOG_DEBUG("audio stream pause"); + return HDF_SUCCESS; +} + +int32_t PlatformRenderPause(struct AudioCard *card) +{ + int ret; + struct PlatformHost *platformHost = NULL; + + ret = PlatformCreatePlatformHost(card, &platformHost); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("PlatformCreatePlatformHost failed."); + return HDF_FAILURE; + } + + platformHost->renderBufInfo.runStatus = 0; + AopHalSetTxStart(platformHost->renderBufInfo.chnId, HI_FALSE); + + ret = AudioSampSetPowerMonitor(card, true); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioSampSetPowerMonitor failed."); + return HDF_FAILURE; + } + + AUDIO_DRIVER_LOG_DEBUG("audio stream pause"); + return HDF_SUCCESS; +} + +int32_t PlatformRenderResume(struct AudioCard *card) +{ + int ret = PlatformRenderStart(card); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("PlatformRenderResume failed."); + return HDF_FAILURE; + } + ret = AudioSampPowerUp(card); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioSampPowerUp failed."); + return HDF_FAILURE; + } + ret = AudioSampSetPowerMonitor(card, false); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioSampSetPowerMonitor failed."); + return HDF_FAILURE; + } + + AUDIO_DRIVER_LOG_DEBUG("audio stream resume"); + return HDF_SUCCESS; +} + +int32_t PlatformCaptureResume(struct AudioCard *card) +{ + int ret; + (void)card; + ret = PlatformCaptureStart(card); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("PlatformCaptureStart failed."); + return HDF_FAILURE; + } + ret = AudioSampPowerUp(card); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioSampPowerUp is failure."); + return HDF_FAILURE; + } + ret = AudioSampSetPowerMonitor(card, false); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioSampSetPowerMonitor is failure."); + return HDF_FAILURE; + } + + AUDIO_DRIVER_LOG_DEBUG("audio stream resume"); + return HDF_SUCCESS; +} diff --git a/audio/chipsets/accessory/tfa9879_smartpa/include/tfa9879_codec.h b/audio/chipsets/tfa9879/accessory/include/tfa9879_accessory_impl.h similarity index 56% rename from audio/chipsets/accessory/tfa9879_smartpa/include/tfa9879_codec.h rename to audio/chipsets/tfa9879/accessory/include/tfa9879_accessory_impl.h index 8c5351307f..b5ab4c03bd 100755 --- a/audio/chipsets/accessory/tfa9879_smartpa/include/tfa9879_codec.h +++ b/audio/chipsets/tfa9879/accessory/include/tfa9879_accessory_impl.h @@ -6,9 +6,10 @@ * See the LICENSE file in the root of this repository for complete details. */ -#ifndef _TFA9879_CODEC_H -#define _TFA9879_CODEC_H +#ifndef TFA9879_ACCESSORY_IMPL_H +#define TFA9879_ACCESSORY_IMPL_H +#include "audio_accessory_if.h" #include "osal_mem.h" #include "osal_time.h" #include "osal_io.h" @@ -72,45 +73,6 @@ typedef enum Tfa9879RegAddr { MISCELLANEOUS_STATUS_REG_ADDR = 0x15 } Tfa9879RegAddr; -enum I2sFrequency { - I2S_SAMPLE_FREQUENCY_8000 = 8000, /* 8kHz sample_rate */ - I2S_SAMPLE_FREQUENCY_11025 = 11025, /* 11.025kHz sample_rate */ - I2S_SAMPLE_FREQUENCY_12000 = 12000, /* 12kHz sample_rate */ - I2S_SAMPLE_FREQUENCY_16000 = 16000, /* 16kHz sample_rate */ - I2S_SAMPLE_FREQUENCY_22050 = 22050, /* 22.050kHz sample_rate */ - I2S_SAMPLE_FREQUENCY_24000 = 24000, /* 24kHz sample_rate */ - I2S_SAMPLE_FREQUENCY_32000 = 32000, /* 32kHz sample_rate */ - I2S_SAMPLE_FREQUENCY_44100 = 44100, /* 44.1kHz sample_rate */ - I2S_SAMPLE_FREQUENCY_48000 = 48000, /* 48kHz sample_rate */ - I2S_SAMPLE_FREQUENCY_64000 = 64000, /* 64kHz sample_rate */ - I2S_SAMPLE_FREQUENCY_88200 = 88200, /* 88.2kHz sample_rate */ - I2S_SAMPLE_FREQUENCY_96000 = 96000 /* 96kHz sample_rate */ -}; - -enum I2sFrequencyRegVal { - I2S_SAMPLE_FREQUENCY_REG_VAL_8000 = 0x0, /* 8kHz sample_rate */ - I2S_SAMPLE_FREQUENCY_REG_VAL_11025 = 0x1, /* 11.025kHz sample_rate */ - I2S_SAMPLE_FREQUENCY_REG_VAL_12000 = 0x2, /* 12kHz sample_rate */ - I2S_SAMPLE_FREQUENCY_REG_VAL_16000 = 0x3, /* 16kHz sample_rate */ - I2S_SAMPLE_FREQUENCY_REG_VAL_22050 = 0x4, /* 22.050kHz sample_rate */ - I2S_SAMPLE_FREQUENCY_REG_VAL_24000 = 0x5, /* 24kHz sample_rate */ - I2S_SAMPLE_FREQUENCY_REG_VAL_32000 = 0x6, /* 32kHz sample_rate */ - I2S_SAMPLE_FREQUENCY_REG_VAL_44100 = 0x7, /* 44.1kHz sample_rate */ - I2S_SAMPLE_FREQUENCY_REG_VAL_48000 = 0x8, /* 48kHz sample_rate */ - I2S_SAMPLE_FREQUENCY_REG_VAL_64000 = 0x9, /* 64kHz sample_rate */ - I2S_SAMPLE_FREQUENCY_REG_VAL_88200 = 0xA, /* 88.2kHz sample_rate */ - I2S_SAMPLE_FREQUENCY_REG_VAL_96000 = 0xB /* 96kHz sample_rate */ -}; - -enum I2sFormatRegVal { - I2S_SAMPLE_FORMAT_REG_VAL_MSB_24 = 0x2, /* MSB-justified data up to 24 bits */ - I2S_SAMPLE_FORMAT_REG_VAL_24 = 0x3, /* I2S data up to 24 bits */ - I2S_SAMPLE_FORMAT_REG_VAL_LSB_16 = 0x4, /* LSB-justified 16-bit data */ - I2S_SAMPLE_FORMAT_REG_VAL_LSB_18 = 0x5, /* LSB-justified 18-bit data */ - I2S_SAMPLE_FORMAT_REG_VAL_LSB_20 = 0x6, /* LSB-justified 20-bit data */ - I2S_SAMPLE_FORMAT_REG_VAL_LSB_24 = 0x7, /* LSB-justified 24-bit data */ -}; - enum CodecInputSel { ADSEL1 = 0, ADSEL2 = 1 @@ -126,6 +88,17 @@ struct Tfa9879RegAttr { uint16_t regValue; // 16bit }; +int32_t AccessoryDeviceInit(struct AudioCard *audioCard, const struct AccessoryDevice *device); +int32_t AccessoryDeviceReadReg(const struct AccessoryDevice *codec, uint32_t reg, uint32_t *value); +int32_t AccessoryDeviceWriteReg(const struct AccessoryDevice *codec, uint32_t reg, uint32_t value); +int32_t AccessoryAiaoDeviceReadReg(const struct AccessoryDevice *codec, uint32_t reg, uint32_t *value); +int32_t AccessoryAiaoDeviceWriteReg(const struct AccessoryDevice *codec, uint32_t reg, uint32_t value); +int32_t AccessoryDaiStartup(const struct AudioCard *card, const struct DaiDevice *device); +int32_t AccessoryDaiHwParams(const struct AudioCard *card, const struct AudioPcmHwParams *param, + const struct DaiDevice *device); +int32_t AccessoryDaiDeviceInit(const struct AudioCard *card, const struct DaiDevice *device); + + #ifdef __cplusplus #if __cplusplus } diff --git a/audio/chipsets/tfa9879/accessory/src/tfa9879_accessory_adapter.c b/audio/chipsets/tfa9879/accessory/src/tfa9879_accessory_adapter.c new file mode 100755 index 0000000000..2917501a5e --- /dev/null +++ b/audio/chipsets/tfa9879/accessory/src/tfa9879_accessory_adapter.c @@ -0,0 +1,103 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. + */ + +#include "tfa9879_accessory_impl.h" +#include "audio_accessory_if.h" +#include "audio_core.h" +#include "audio_sapm.h" +#include "hdf_log.h" + +#define HDF_LOG_TAG "accessory" + +struct AccessoryData g_accessoryData = { + .Init = AccessoryDeviceInit, + .Read = AccessoryDeviceReadReg, + .Write = AccessoryDeviceWriteReg, + .AiaoRead = AccessoryAiaoDeviceReadReg, + .AiaoWrite = AccessoryAiaoDeviceWriteReg, +}; + +struct AudioDaiOps g_accessoryDaiDeviceOps = { + .Startup = AccessoryDaiStartup, + .HwParams = AccessoryDaiHwParams, +}; + +struct DaiData g_accessoryDaiData = { + .drvDaiName = "accessory_dai", + .DaiInit = AccessoryDaiDeviceInit, + .ops = &g_accessoryDaiDeviceOps, +}; + +/* HdfDriverEntry */ +static int32_t GetServiceName(const struct HdfDeviceObject *device) +{ + const struct DeviceResourceNode *node = NULL; + struct DeviceResourceIface *drsOps = NULL; + int32_t ret; + if (device == NULL) { + AUDIO_DRIVER_LOG_ERR("input HdfDeviceObject object is nullptr."); + return HDF_FAILURE; + } + node = device->property; + if (node == NULL) { + AUDIO_DRIVER_LOG_ERR("get drs node is nullptr."); + return HDF_FAILURE; + } + drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (drsOps == NULL || drsOps->GetString == NULL) { + AUDIO_DRIVER_LOG_ERR("drsOps or drsOps getString is null!"); + return HDF_FAILURE; + } + ret = drsOps->GetString(node, "serviceName", &g_accessoryData.drvAccessoryName, 0); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("read serviceName fail!"); + return ret; + } + return HDF_SUCCESS; +} + +/* HdfDriverEntry implementations */ +static int32_t AccessoryDriverInit(struct HdfDeviceObject *device) +{ + int32_t ret; + AUDIO_DRIVER_LOG_DEBUG("entry.\n"); + if (device == NULL) { + AUDIO_DRIVER_LOG_ERR("device is NULL."); + return HDF_ERR_INVALID_OBJECT; + } + ret = GetServiceName(device); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("get service name fail."); + return ret; + } + ret = AudioRegisterAccessory(device, &g_accessoryData, &g_accessoryDaiData); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("register dai fail."); + return ret; + } + AUDIO_DRIVER_LOG_INFO("success!"); + return HDF_SUCCESS; +} + +/* HdfDriverEntry implementations */ +static int32_t AccessoryDriverBind(struct HdfDeviceObject *device) +{ + (void)device; + AUDIO_DRIVER_LOG_INFO("success!"); + return HDF_SUCCESS; +} + +/* HdfDriverEntry definitions */ +struct HdfDriverEntry g_accessoryDriverEntry = { + .moduleVersion = 1, + .moduleName = "CODEC_TFA9879", + .Bind = AccessoryDriverBind, + .Init = AccessoryDriverInit, + .Release = NULL, +}; +HDF_INIT(g_accessoryDriverEntry); diff --git a/audio/chipsets/accessory/tfa9879_smartpa/src/tfa9879_codec.c b/audio/chipsets/tfa9879/accessory/src/tfa9879_accessory_impl.c similarity index 88% rename from audio/chipsets/accessory/tfa9879_smartpa/src/tfa9879_codec.c rename to audio/chipsets/tfa9879/accessory/src/tfa9879_accessory_impl.c index 3f21304cda..f63e2cf0ea 100755 --- a/audio/chipsets/accessory/tfa9879_smartpa/src/tfa9879_codec.c +++ b/audio/chipsets/tfa9879/accessory/src/tfa9879_accessory_impl.c @@ -6,8 +6,8 @@ * See the LICENSE file in the root of this repository for complete details. */ -#include "tfa9879_codec.h" -#include "accessory_adapter.h" +#include "tfa9879_accessory_impl.h" +#include "audio_accessory_base.h" #include "audio_core.h" #include "audio_device_log.h" #include "audio_sapm.h" @@ -51,8 +51,7 @@ static uint16_t g_i2cDevAddr; /* Tfa9879 Special Region Begin */ static void SysWritel(unsigned long addr, unsigned int value) { - volatile unsigned int *regAddress = (volatile unsigned int *)addr; - *regAddress = value; + *(volatile unsigned int *)(addr) = value; } /* tfa9879 21 control register default value */ @@ -566,7 +565,7 @@ static const struct AudioMixerControl g_tfa9879AudioRegParams[] = { .rshift = CHANNEL_SHIFT, .min = 0x0, .max = 0x3, - .mask = 0xC00, + .mask = 0x3, .invert = 0, }, }; @@ -576,27 +575,27 @@ static const struct AudioKcontrol g_tfa9879AudioControls[] = { .iface = AUDIODRV_CTL_ELEM_IFACE_DAC, .name = "Master Playback Volume", .Info = AudioInfoCtrlOps, - .Get = AudioGetCtrlOps, - .Set = AudioSetCtrlOps, + .Get = AudioAccessoryGetCtrlOps, + .Set = AudioAccessorySetCtrlOps, .privateValue = (unsigned long) &g_tfa9879AudioRegParams[0], }, { .iface = AUDIODRV_CTL_ELEM_IFACE_DAC, .name = "Playback Mute", .Info = AudioInfoCtrlOps, - .Get = AudioGetCtrlOps, - .Set = AudioSetCtrlOps, + .Get = AudioAccessoryGetCtrlOps, + .Set = AudioAccessorySetCtrlOps, .privateValue = (unsigned long) &g_tfa9879AudioRegParams[1], }, { .iface = AUDIODRV_CTL_ELEM_IFACE_AIAO, .name = "Render Channel Mode", .Info = AudioInfoCtrlOps, - .Get = AiaoGetCtrlOps, - .Set = AiaoSetCtrlOps, + .Get = AudioAccessoryAiaoGetCtrlOps, + .Set = AudioAccessoryAiaoSetCtrlOps, .privateValue = (unsigned long) &g_tfa9879AudioRegParams[2], }, }; -int32_t ExternalCodecDeviceInit(struct AudioCard *audioCard, const struct AccessoryDevice *device) +int32_t AccessoryDeviceInit(struct AudioCard *audioCard, const struct AccessoryDevice *device) { int32_t ret; AUDIO_DEVICE_LOG_DEBUG(" entry."); @@ -609,7 +608,7 @@ int32_t ExternalCodecDeviceInit(struct AudioCard *audioCard, const struct Access AUDIO_DEVICE_LOG_ERR("init tfa9979 device fail."); return HDF_FAILURE; } - ret = AudioAddControls(audioCard, g_tfa9879AudioControls, ARRAY_SIZE(g_tfa9879AudioControls)); + ret = AudioAddControls(audioCard, g_tfa9879AudioControls, HDF_ARRAY_SIZE(g_tfa9879AudioControls)); if (ret != HDF_SUCCESS) { AUDIO_DEVICE_LOG_ERR("add controls fail."); return HDF_FAILURE; @@ -640,7 +639,7 @@ static int32_t TransformGetCtrlResult(uint32_t reg, const uint16_t *resVal) return ret; } -int32_t ExternalCodecDeviceReadReg(const struct AccessoryDevice *codec, uint32_t reg, uint32_t *val) +int32_t AccessoryDeviceReadReg(const struct AccessoryDevice *codec, uint32_t reg, uint32_t *val) { int32_t ret; struct Tfa9879RegAttr regAttr; @@ -688,7 +687,7 @@ static int32_t TransformSetCtrlVal(uint32_t reg, uint16_t *val) return ret; } -int32_t ExternalCodecDeviceWriteReg(const struct AccessoryDevice *codec, uint32_t reg, uint32_t value) +int32_t AccessoryDeviceWriteReg(const struct AccessoryDevice *codec, uint32_t reg, uint32_t value) { int32_t ret; struct Tfa9879RegAttr regAttr; @@ -712,78 +711,40 @@ int32_t ExternalCodecDeviceWriteReg(const struct AccessoryDevice *codec, uint32_ return HDF_SUCCESS; } -int32_t ExternalCodecDaiStartup(const struct AudioCard *card, const struct DaiDevice *device) +int32_t AccessoryAiaoDeviceReadReg(const struct AccessoryDevice *codec, uint32_t reg, uint32_t *val) { - (void)card; - (void)device; + int32_t ret; + ret = AccessoryDeviceReadReg(codec, reg, val); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("AccessoryDeviceReadReg fail, reg=0x%x.", reg); + return HDF_FAILURE; + } + AUDIO_DEVICE_LOG_DEBUG("success"); return HDF_SUCCESS; } -static int32_t FormatToBitWidth(enum AudioFormat format, uint16_t *bitWidth) +int32_t AccessoryAiaoDeviceWriteReg(const struct AccessoryDevice *codec, uint32_t reg, uint32_t value) { - // current set default format(standard) for 16/24 bit - switch (format) { - case AUDIO_FORMAT_PCM_16_BIT: - *bitWidth = I2S_SAMPLE_FORMAT_REG_VAL_24; - break; - case AUDIO_FORMAT_PCM_24_BIT: - *bitWidth = I2S_SAMPLE_FORMAT_REG_VAL_24; - break; - default: - AUDIO_DEVICE_LOG_ERR("format: %d is not support.", format); - return HDF_ERR_NOT_SUPPORT; + int32_t ret; + AUDIO_DEVICE_LOG_DEBUG("entry"); + ret = AccessoryDeviceWriteReg(codec, reg, value); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("AccessoryDeviceWriteReg fail."); + return HDF_FAILURE; } + AUDIO_DEVICE_LOG_DEBUG("success"); return HDF_SUCCESS; } -static int32_t RateToFrequency(uint32_t rate, uint16_t *freq) +int32_t AccessoryDaiStartup(const struct AudioCard *card, const struct DaiDevice *device) { - switch (rate) { - case I2S_SAMPLE_FREQUENCY_8000: - *freq = I2S_SAMPLE_FREQUENCY_REG_VAL_8000; - break; - case I2S_SAMPLE_FREQUENCY_11025: - *freq = I2S_SAMPLE_FREQUENCY_REG_VAL_11025; - break; - case I2S_SAMPLE_FREQUENCY_12000: - *freq = I2S_SAMPLE_FREQUENCY_REG_VAL_12000; - break; - case I2S_SAMPLE_FREQUENCY_16000: - *freq = I2S_SAMPLE_FREQUENCY_REG_VAL_16000; - break; - case I2S_SAMPLE_FREQUENCY_22050: - *freq = I2S_SAMPLE_FREQUENCY_REG_VAL_22050; - break; - case I2S_SAMPLE_FREQUENCY_24000: - *freq = I2S_SAMPLE_FREQUENCY_REG_VAL_24000; - break; - case I2S_SAMPLE_FREQUENCY_32000: - *freq = I2S_SAMPLE_FREQUENCY_REG_VAL_32000; - break; - case I2S_SAMPLE_FREQUENCY_44100: - *freq = I2S_SAMPLE_FREQUENCY_REG_VAL_44100; - break; - case I2S_SAMPLE_FREQUENCY_48000: - *freq = I2S_SAMPLE_FREQUENCY_REG_VAL_48000; - break; - case I2S_SAMPLE_FREQUENCY_64000: - *freq = I2S_SAMPLE_FREQUENCY_REG_VAL_64000; - break; - case I2S_SAMPLE_FREQUENCY_88200: - *freq = I2S_SAMPLE_FREQUENCY_REG_VAL_88200; - break; - case I2S_SAMPLE_FREQUENCY_96000: - *freq = I2S_SAMPLE_FREQUENCY_REG_VAL_96000; - break; - default: - AUDIO_DEVICE_LOG_ERR("rate: %d is not support.", rate); - return HDF_ERR_NOT_SUPPORT; - } + (void)card; + (void)device; return HDF_SUCCESS; } -int32_t ExternalCodecDaiHwParams(const struct AudioCard *card, const struct AudioPcmHwParams *param, - const struct DaiDevice *device) +int32_t AccessoryDaiHwParams(const struct AudioCard *card, const struct AudioPcmHwParams *param, + const struct DaiDevice *device) { int ret; uint16_t frequency, bitWidth; @@ -826,7 +787,7 @@ int32_t ExternalCodecDaiHwParams(const struct AudioCard *card, const struct Audi return HDF_SUCCESS; } -int32_t ExternalCodecDaiDeviceInit(const struct AudioCard *card, const struct DaiDevice *device) +int32_t AccessoryDaiDeviceInit(const struct AudioCard *card, const struct DaiDevice *device) { if (device == NULL || device->devDaiName == NULL) { AUDIO_DEVICE_LOG_ERR("input para is NULL."); diff --git a/audio/hal/hdi_passthrough/src/adapter_config.json b/audio/config/adapter_config.json similarity index 100% rename from audio/hal/hdi_passthrough/src/adapter_config.json rename to audio/config/adapter_config.json diff --git a/audio/config/linux/BUILD.gn b/audio/config/linux/BUILD.gn new file mode 100755 index 0000000000..06f43537b2 --- /dev/null +++ b/audio/config/linux/BUILD.gn @@ -0,0 +1,17 @@ +import("//build/ohos.gni") +if (is_standard_system) { + ohos_prebuilt_etc("hdf_audio_json") { + source = "//drivers/peripheral/audio/config/adapter_config.json" + relative_install_dir = "hdfconfig" + subsystem_name = "hdf" + part_name = "hdf" + } + + ohos_prebuilt_etc("hdf_audio_path_json") { + source = "//drivers/peripheral/audio/config/parse.json" + relative_install_dir = "hdfconfig" + subsystem_name = "hdf" + part_name = "hdf" + } +} + diff --git a/audio/config/lite/BUILD.gn b/audio/config/lite/BUILD.gn new file mode 100755 index 0000000000..d439239d81 --- /dev/null +++ b/audio/config/lite/BUILD.gn @@ -0,0 +1,12 @@ +import("//build/lite/config/component/lite_component.gni") + +copy("hdf_audio_json") { + sources = [ "//drivers/peripheral/audio/config/adapter_config.json" ] + outputs = [ "${root_out_dir}/etc/adapter_config.json" ] +} + +copy("hdf_audio_path_json") { + sources = [ "//drivers/peripheral/audio/config/parse.json" ] + outputs = [ "${root_out_dir}/etc/parse.json" ] +} + diff --git a/audio/hal/pathselect/src/parse.json b/audio/config/parse.json similarity index 100% rename from audio/hal/pathselect/src/parse.json rename to audio/config/parse.json diff --git a/audio/hal/hdi_binder/proxy/BUILD.gn b/audio/hal/hdi_binder/proxy/BUILD.gn new file mode 100755 index 0000000000..1779f037d4 --- /dev/null +++ b/audio/hal/hdi_binder/proxy/BUILD.gn @@ -0,0 +1,163 @@ +# 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. + +if (defined(ohos_lite)) { + import("//build/lite/config/component/lite_component.gni") +} else { + import("//build/ohos.gni") +} +import("//drivers/adapter/uhdf2/uhdf.gni") + +config("hdi_service_proxy_config") { + visibility = [ ":*" ] + + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-DGST_DISABLE_DEPRECATED", + "-DHAVE_CONFIG_H", + "-fno-strict-aliasing", + "-Wno-sign-compare", + "-Wno-builtin-requires-header", + "-Wno-implicit-function-declaration", + "-Wno-format", + "-Wno-int-conversion", + "-Wno-unused-function", + "-Wno-unused-parameter", + "-Wno-thread-safety-attributes", + "-Wno-inconsistent-missing-override", + "-fno-rtti", + "-fno-exceptions", + "-ffunction-sections", + "-fdata-sections", + ] + + ldflags = [ "-Wl" ] +} + +if (defined(ohos_lite)) { + shared_library("audio_hdi_proxy_server") { + include_dirs = [ + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/peripheral/audio/hal/hdi_binder/server/include", + "$hdf_framework_path/include/core", + "$hdf_framework_path/include/utils", + "$hdf_framework_path/include/osal", + "$hdf_framework_path/ability/sbuf/include", + "$hdf_framework_path/utils/include", + "$hdf_framework_path/include", + "$hdf_framework_path/core/sec/include", + "$hdf_framework_path/core/shared/include", + "$hdf_framework_path/core/host/include", + "$hdf_framework_path/core/manager/include", + "$hdf_framework_path/core/common/include/host/", + "//third_party/cJSON", + "//third_party/bounds_checking_function/include", + "//drivers/adapter/khdf/liteos/osal/include", + "$hdf_uhdf_path/shared/include", + "$hdf_uhdf_path/include/hdi/", + "$hdf_uhdf_path/host/include" + ] + + sources = [ + "src/audio_proxy_adapter.c", + "src/audio_proxy_common.c", + "src/audio_proxy_capture.c", + "src/audio_proxy_manager.c", + "src/audio_proxy_render.c", + "//third_party/cJSON/cJSON.c", + "$hdf_framework_path/ability/sbuf/src/hdf_sbuf.c", + "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_common.c", + "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_adapter_info_common.c" + ] + + deps = [ + "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio", + "//third_party/bounds_checking_function:libsec_shared" + ] + + public_configs = [ ":hdi_service_proxy_config" ] + } + + lite_component("hdi_audio") { + features = [ ":audio_hdi_proxy_server" ] + } +} else { + ohos_shared_library("audio_hdi_proxy_server") { + include_dirs = [ + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/peripheral/audio/hal/hdi_binder/server/include", + "//third_party/cJSON", + "$hdf_framework_path/include/core", + "$hdf_framework_path/include/utils", + "$hdf_framework_path/include/osal", + "$hdf_framework_path/include", + "//third_party/bounds_checking_function/include", + "$hdf_framework_path/ability/sbuf/include", + "$hdf_framework_path/utils/include", + "$hdf_framework_path/ability/sbuf/include", + "$hdf_uhdf_path/osal/include", + "$hdf_framework_path/include", + "$hdf_framework_path/core/sec/include", + "$hdf_framework_path/core/shared/include", + "$hdf_framework_path/core/host/include", + "$hdf_framework_path/core/manager/include", + "$hdf_uhdf_path/include/devhost", + "$hdf_uhdf_path/devhost/include", + "$hdf_uhdf_path/devmgr/include", + "$hdf_uhdf_path/host/include", + "$hdf_uhdf_path/manager/include", + "$hdf_uhdf_path/include/host", + ] + + sources = [ + "src/audio_proxy_adapter.c", + "src/audio_proxy_common.c", + "src/audio_proxy_capture.c", + "src/audio_proxy_manager.c", + "src/audio_proxy_render.c", + "//third_party/cJSON/cJSON.c", + "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_common.c", + "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_adapter_info_common.c", + ] + + deps = [ + "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio", + "$hdf_uhdf_path/osal:libhdf_utils", + "$hdf_uhdf_path/manager:hdf_devmgr", + "$hdf_uhdf_path/manager:hdf_devmgr.rc", + "//utils/native/base:utils", + "$hdf_uhdf_path/hdi:libhdi", + "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", + "$hdf_uhdf_path/host:hdf_devhost", + "$hdf_uhdf_path/host:libhdf_host", + "$hdf_uhdf_path/config:libhdf_hcs", + "$hdf_uhdf_path/hcs:hdf_default.hcb", + ] + + if (is_standard_system) { + external_deps = [ "hiviewdfx_hilog_native:libhilog" ] + } else { + external_deps = [ "hilog:libhilog" ] + } + + public_configs = [ ":hdi_service_proxy_config" ] + + subsystem_name = "hdf" + } +} \ No newline at end of file diff --git a/audio/hal/hdi_binder/proxy/include/audio_proxy_common.h b/audio/hal/hdi_binder/proxy/include/audio_proxy_common.h index 554d663eaa..b70f67e1eb 100755 --- a/audio/hal/hdi_binder/proxy/include/audio_proxy_common.h +++ b/audio/hal/hdi_binder/proxy/include/audio_proxy_common.h @@ -15,25 +15,27 @@ #ifndef AUDIO_PROXY_COMMON_H #define AUDIO_PROXY_COMMON_H +#include "audio_internal.h" #include "hdf_audio_server.h" -#include "servmgr_hdi.h" -#include "hdf_remote_service.h" -#include "devmgr_hdi.h" -#include "osal_mem.h" #define CONFIG_CHANNEL_COUNT 2 // two channels #define GAIN_MAX 50.0 +#define STR_MAX 512 struct HdfSBuf *AudioProxyObtainHdfSBuf(); void AudioProxyBufReplyRecycle(struct HdfSBuf *data, struct HdfSBuf *reply); int32_t AudioProxyPreprocessSBuf(struct HdfSBuf **data, struct HdfSBuf **reply); -struct AudioManager *HdfProxyIoBindServiceName(const char *serviceName); -int32_t AudioProxyDispatchCall(int32_t id, struct HdfSBuf *data, struct HdfSBuf *reply); -int32_t AudioProxyPreprocessRender(AudioHandle render, struct HdfSBuf **data, struct HdfSBuf **reply); -int32_t AudioProxyPreprocessCapture(AudioHandle capture, struct HdfSBuf **data, struct HdfSBuf **reply); +int32_t AudioProxyDispatchCall(struct HdfRemoteService *self, int32_t id, struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t AudioProxyPreprocessRender(struct AudioHwRender *render, struct HdfSBuf **data, struct HdfSBuf **reply); +int32_t AudioProxyPreprocessCapture(struct AudioHwCapture *capture, struct HdfSBuf **data, struct HdfSBuf **reply); int32_t AudioProxyWriteSampleAttributes(struct HdfSBuf *data, const struct AudioSampleAttributes *attrs); int32_t AudioProxyReadSapmleAttrbutes(struct HdfSBuf *reply, struct AudioSampleAttributes *attrs); -int32_t AudioProxyCommonSetCtrlParam(int cmId, AudioHandle handle, float param); -int32_t AudioProxyCommonGetCtrlParam(int cmId, AudioHandle handle, float *param); +int32_t AudioProxyCommonSetRenderCtrlParam(int cmId, AudioHandle handle, float param); +int32_t AudioProxyCommonGetRenderCtrlParam(int cmId, AudioHandle handle, float *param); +int32_t AudioProxyCommonSetCaptureCtrlParam(int cmId, AudioHandle handle, float param); +int32_t AudioProxyCommonGetCaptureCtrlParam(int cmId, AudioHandle handle, float *param); +int32_t AudioProxyGetMmapPositionRead(struct HdfSBuf *reply, uint64_t *frames, struct AudioTimeStamp *time); +int32_t AudioProxyReqMmapBufferWrite(struct HdfSBuf *data, int32_t reqSize, + const struct AudioMmapBufferDescripter *desc); #endif diff --git a/audio/hal/hdi_binder/proxy/include/audio_proxy_internal.h b/audio/hal/hdi_binder/proxy/include/audio_proxy_internal.h index 44b224e506..ea2ed9c7ca 100755 --- a/audio/hal/hdi_binder/proxy/include/audio_proxy_internal.h +++ b/audio/hal/hdi_binder/proxy/include/audio_proxy_internal.h @@ -16,15 +16,7 @@ #ifndef AUDIO_PROXY_INTERNAL_H #define AUDIO_PROXY_INTERNAL_H -#include "audio_render.h" -#include "audio_capture.h" #include "audio_adapter.h" -#include "audio_types.h" -#include "audio_control.h" -#include "audio_attribute.h" -#include "audio_scene.h" -#include "audio_volume.h" - int32_t AudioProxyAdapterInitAllPorts(struct AudioAdapter *adapter); int32_t AudioProxyAdapterCreateRender(struct AudioAdapter *adapter, @@ -50,13 +42,13 @@ int32_t AudioProxyRenderStop(AudioHandle handle); int32_t AudioProxyRenderPause(AudioHandle handle); int32_t AudioProxyRenderResume(AudioHandle handle); int32_t AudioProxyRenderFlush(AudioHandle handle); -int32_t AudioProxyRenderGetFrameSize(AudioHandle handle, uint64_t *size); -int32_t AudioProxyRenderGetFrameCount(AudioHandle handle, uint64_t *count); -int32_t AudioProxyRenderSetSampleAttributes(AudioHandle handle, +int32_t AudioProxyRenderGetFrameSize(const AudioHandle handle, uint64_t *size); +int32_t AudioProxyRenderGetFrameCount(const AudioHandle handle, uint64_t *count); +int32_t AudioProxyRenderSetSampleAttributes(const AudioHandle handle, const struct AudioSampleAttributes *attrs); -int32_t AudioProxyRenderGetSampleAttributes(AudioHandle handle, +int32_t AudioProxyRenderGetSampleAttributes(const AudioHandle handle, struct AudioSampleAttributes *attrs); -int32_t AudioProxyRenderGetCurrentChannelId(AudioHandle handle, uint32_t *channelId); +int32_t AudioProxyRenderGetCurrentChannelId(const AudioHandle handle, uint32_t *channelId); int32_t AudioProxyRenderCheckSceneCapability(AudioHandle handle, const struct AudioSceneDescriptor *scene, bool *supported); int32_t AudioProxyRenderSelectScene(AudioHandle handle, @@ -77,32 +69,47 @@ int32_t AudioProxyRenderSetRenderSpeed(struct AudioRender *render, float speed); int32_t AudioProxyRenderGetRenderSpeed(struct AudioRender *render, float *speed); int32_t AudioProxyRenderSetChannelMode(struct AudioRender *render, enum AudioChannelMode mode); int32_t AudioProxyRenderGetChannelMode(struct AudioRender *render, enum AudioChannelMode *mode); -int32_t AudioProxyCaptureStart(AudioHandle handle); -int32_t AudioProxyCaptureStop(AudioHandle handle); -int32_t AudioProxyCapturePause(AudioHandle handle); -int32_t AudioProxyCaptureResume(AudioHandle handle); -int32_t AudioProxyCaptureFlush(AudioHandle handle); +int32_t AudioProxyRenderSetExtraParams(AudioHandle render, const char *keyValueList); +int32_t AudioProxyRenderGetExtraParams(AudioHandle render, char *keyValueList, int32_t listLenth); +int32_t AudioProxyRenderReqMmapBuffer(AudioHandle render, int32_t reqSize, struct AudioMmapBufferDescripter *desc); +int32_t AudioProxyRenderGetMmapPosition(AudioHandle render, uint64_t *frames, struct AudioTimeStamp *time); +int32_t AudioProxyRenderTurnStandbyMode(AudioHandle render); +int32_t AudioProxyRenderAudioDevDump(AudioHandle render, int32_t range, int32_t fd); +int32_t AudioProxyRenderRegCallback(struct AudioRender *render, RenderCallback callback, void *cookie); +int32_t AudioProxyRenderDrainBuffer(struct AudioRender *render, enum AudioDrainNotifyType *type); +int32_t AudioProxyCaptureStart(const AudioHandle handle); +int32_t AudioProxyCaptureStop(const AudioHandle handle); +int32_t AudioProxyCapturePause(const AudioHandle handle); +int32_t AudioProxyCaptureResume(const AudioHandle handle); +int32_t AudioProxyCaptureFlush(const AudioHandle handle); int32_t AudioProxyCaptureGetFrameSize(AudioHandle handle, uint64_t *size); int32_t AudioProxyCaptureGetFrameCount(AudioHandle handle, uint64_t *count); int32_t AudioProxyCaptureSetSampleAttributes(AudioHandle handle, const struct AudioSampleAttributes *attrs); -int32_t AudioProxyCaptureGetSampleAttributes(AudioHandle handle, +int32_t AudioProxyCaptureGetSampleAttributes(const AudioHandle handle, struct AudioSampleAttributes *attrs); -int32_t AudioProxyCaptureGetCurrentChannelId(AudioHandle handle, uint32_t *channelId); -int32_t AudioProxyCaptureCheckSceneCapability(AudioHandle handle, +int32_t AudioProxyCaptureGetCurrentChannelId(const AudioHandle handle, uint32_t *channelId); +int32_t AudioProxyCaptureCheckSceneCapability(const AudioHandle handle, const struct AudioSceneDescriptor *scene, bool *supported); -int32_t AudioProxyCaptureSelectScene(AudioHandle handle, +int32_t AudioProxyCaptureSelectScene(const AudioHandle handle, const struct AudioSceneDescriptor *scene); -int32_t AudioProxyCaptureSetMute(AudioHandle handle, bool mute); -int32_t AudioProxyCaptureGetMute(AudioHandle handle, bool *mute); -int32_t AudioProxyCaptureSetVolume(AudioHandle handle, float volume); -int32_t AudioProxyCaptureGetVolume(AudioHandle handle, float *volume); -int32_t AudioProxyCaptureGetGainThreshold(AudioHandle handle, float *min, float *max); -int32_t AudioProxyCaptureGetGain(AudioHandle handle, float *gain); -int32_t AudioProxyCaptureSetGain(AudioHandle handle, float gain); +int32_t AudioProxyCaptureSetMute(const AudioHandle handle, bool mute); +int32_t AudioProxyCaptureGetMute(const AudioHandle handle, bool *mute); +int32_t AudioProxyCaptureSetVolume(const AudioHandle handle, float volume); +int32_t AudioProxyCaptureGetVolume(const AudioHandle handle, float *volume); +int32_t AudioProxyCaptureGetGainThreshold(const AudioHandle handle, float *min, float *max); +int32_t AudioProxyCaptureGetGain(const AudioHandle handle, float *gain); +int32_t AudioProxyCaptureSetGain(const AudioHandle handle, float gain); int32_t AudioProxyCaptureCaptureFrame(struct AudioCapture *capture, void *frame, uint64_t requestBytes, uint64_t *replyBytes); int32_t AudioProxyCaptureGetCapturePosition(struct AudioCapture *capture, uint64_t *frames, struct AudioTimeStamp *time); +int32_t AudioProxyCaptureSetExtraParams(AudioHandle capture, const char *keyValueList); +int32_t AudioProxyCaptureGetExtraParams(const AudioHandle capture, char *keyValueList, int32_t listLenth); +int32_t AudioProxyCaptureReqMmapBuffer(const AudioHandle capture, + int32_t reqSize, struct AudioMmapBufferDescripter *desc); +int32_t AudioProxyCaptureGetMmapPosition(const AudioHandle capture, uint64_t *frames, struct AudioTimeStamp *time); +int32_t AudioProxyCaptureTurnStandbyMode(const AudioHandle capture); +int32_t AudioProxyCaptureAudioDevDump(AudioHandle capture, int32_t range, int32_t fd); #endif diff --git a/audio/hal/hdi_binder/proxy/include/audio_proxy_manager.h b/audio/hal/hdi_binder/proxy/include/audio_proxy_manager.h index 553e67a4b5..68e8c9db60 100755 --- a/audio/hal/hdi_binder/proxy/include/audio_proxy_manager.h +++ b/audio/hal/hdi_binder/proxy/include/audio_proxy_manager.h @@ -35,27 +35,28 @@ #ifndef AUDIO_PROXY_MANAGER_H #define AUDIO_PROXY_MANAGER_H -#include "audio_types.h" #include "audio_adapter.h" -#include "audio_manager.h" -#include #ifdef __cplusplus extern "C" { #endif -struct HDIAudioManager { +struct AudioProxyManager { struct HdfRemoteService *remote; - struct AudioManager proxyAudioManager; + int32_t (*GetAllAdapters)(struct AudioProxyManager *manager, struct AudioAdapterDescriptor **descs, int32_t *size); + int32_t (*LoadAdapter)(struct AudioProxyManager *manager, const struct AudioAdapterDescriptor *desc, + struct AudioAdapter **adapter); + void (*UnloadAdapter)(struct AudioProxyManager *manager, struct AudioAdapter *adapter); }; -int32_t AudioProxyManagerGetAllAdapters(struct AudioManager *manager, + +int32_t AudioProxyManagerGetAllAdapters(struct AudioProxyManager *manager, struct AudioAdapterDescriptor **descs, int *size); -int32_t AudioProxyManagerLoadAdapter(struct AudioManager *manager, const struct AudioAdapterDescriptor *desc, +int32_t AudioProxyManagerLoadAdapter(struct AudioProxyManager *manager, const struct AudioAdapterDescriptor *desc, struct AudioAdapter **adapter); -void AudioProxyManagerUnloadAdapter(struct AudioManager *manager, struct AudioAdapter *adapter); +void AudioProxyManagerUnloadAdapter(struct AudioProxyManager *manager, struct AudioAdapter *adapter); -struct AudioManager *GetAudioProxyManagerFuncs(void); +struct AudioProxyManager *GetAudioProxyManagerFuncs(void); #ifdef __cplusplus } diff --git a/audio/hal/hdi_binder/proxy/src/BUILD.gn b/audio/hal/hdi_binder/proxy/src/BUILD.gn deleted file mode 100755 index d13c349cbd..0000000000 --- a/audio/hal/hdi_binder/proxy/src/BUILD.gn +++ /dev/null @@ -1,112 +0,0 @@ -# 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. - -if (defined(ohos_lite)) { - import("//build/lite/config/component/lite_component.gni") -} else { - import("//build/ohos.gni") -} -import("//drivers/adapter/uhdf2/uhdf.gni") - -config("hdi_service_proxy_config") { - visibility = [ ":*" ] - - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-DGST_DISABLE_DEPRECATED", - "-DHAVE_CONFIG_H", - "-fno-strict-aliasing", - "-Wno-sign-compare", - "-Wno-builtin-requires-header", - "-Wno-implicit-function-declaration", - "-Wno-format", - "-Wno-int-conversion", - "-Wno-unused-function", - "-Wno-unused-parameter", - "-Wno-thread-safety-attributes", - "-Wno-inconsistent-missing-override", - "-fno-rtti", - "-fno-exceptions", - "-ffunction-sections", - "-fdata-sections", - ] - - ldflags = [ "-Wl" ] -} - -ohos_shared_library("audio_hdi_proxy_server") { - include_dirs = [ - "//drivers/peripheral/audio/interfaces/include", - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", - "//drivers/peripheral/audio/hal/hdi_binder/server/include", - "//third_party/cJSON", - "$hdf_framework_path/include/core", - "$hdf_framework_path/include/utils", - "$hdf_framework_path/include/osal", - "$hdf_framework_path/include", - "//third_party/bounds_checking_function/include", - "$hdf_framework_path/ability/sbuf/include", - "$hdf_framework_path/utils/include", - "$hdf_framework_path/ability/sbuf/include", - "$hdf_uhdf_path/osal/include", - "$hdf_framework_path/include", - "$hdf_framework_path/core/sec/include", - "$hdf_framework_path/core/shared/include", - "$hdf_framework_path/core/host/include", - "$hdf_framework_path/core/manager/include", - "$hdf_uhdf_path/include/devhost", - "$hdf_uhdf_path/devhost/include", - "$hdf_uhdf_path/devmgr/include", - "$hdf_uhdf_path/host/include", - "$hdf_uhdf_path/manager/include", - "$hdf_uhdf_path/include/host", - ] - - sources = [ - "audio_proxy_adapter.c", - "audio_proxy_common.c", - "audio_proxy_capture.c", - "audio_proxy_manager.c", - "audio_proxy_render.c", - "//third_party/cJSON/cJSON.c", - "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_common.c", - "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_adapter_info_common.c", - ] - - deps = [ - "//drivers/peripheral/audio/hal/hdi_passthrough/src:hdi_audio", - "$hdf_uhdf_path/osal:libhdf_utils", - "$hdf_uhdf_path/manager:hdf_devmgr", - "$hdf_uhdf_path/manager:hdf_devmgr.rc", - "//utils/native/base:utils", - "$hdf_uhdf_path/hdi:libhdi", - "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", - "$hdf_uhdf_path/host:hdf_devhost", - "$hdf_uhdf_path/host:libhdf_host", - "$hdf_uhdf_path/config:libhdf_hcs", - "$hdf_uhdf_path/hcs:hdf_default.hcb", - ] - - if (is_standard_system) { - external_deps = [ "hiviewdfx_hilog_native:libhilog" ] - } else { - external_deps = [ "hilog:libhilog" ] - } - - public_configs = [ ":hdi_service_proxy_config" ] - - subsystem_name = "hdf" -} \ No newline at end of file diff --git a/audio/hal/hdi_binder/proxy/src/audio_proxy_adapter.c b/audio/hal/hdi_binder/proxy/src/audio_proxy_adapter.c index 38f6b074d5..2d17dda21e 100755 --- a/audio/hal/hdi_binder/proxy/src/audio_proxy_adapter.c +++ b/audio/hal/hdi_binder/proxy/src/audio_proxy_adapter.c @@ -59,7 +59,7 @@ int32_t AudioProxyCommonInitAttrs(struct HdfSBuf *data, const struct AudioSample return HDF_SUCCESS; } -int32_t AudioProxyCommonInitCreateData(struct HdfSBuf *data, struct AudioAdapter *adapter, +int32_t AudioProxyCommonInitCreateData(struct HdfSBuf *data, struct AudioHwAdapter *adapter, const struct AudioDeviceDescriptor *desc, const struct AudioSampleAttributes *attrs) { LOG_FUN_INFO(); @@ -70,8 +70,7 @@ int32_t AudioProxyCommonInitCreateData(struct HdfSBuf *data, struct AudioAdapter uint32_t tempDesc; uint32_t tempAtrr; uint32_t pid = getpid(); - struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; - const char *adapterName = hwAdapter->adapterDescriptor.adapterName; + const char *adapterName = adapter->adapterDescriptor.adapterName; if (adapterName == NULL) { return HDF_FAILURE; } @@ -101,7 +100,6 @@ int32_t AudioProxyCommonInitCreateData(struct HdfSBuf *data, struct AudioAdapter if (!HdfSbufWriteUint32(data, tempDesc)) { return HDF_FAILURE; } - LOG_FUN_INFO(); return HDF_SUCCESS; } @@ -115,11 +113,17 @@ int32_t GetAudioProxyRenderFunc(struct AudioHwRender *hwRender) hwRender->common.control.Pause = AudioProxyRenderPause; hwRender->common.control.Resume = AudioProxyRenderResume; hwRender->common.control.Flush = AudioProxyRenderFlush; + hwRender->common.control.TurnStandbyMode = AudioProxyRenderTurnStandbyMode; + hwRender->common.control.AudioDevDump = AudioProxyRenderAudioDevDump; hwRender->common.attr.GetFrameSize = AudioProxyRenderGetFrameSize; hwRender->common.attr.GetFrameCount = AudioProxyRenderGetFrameCount; hwRender->common.attr.SetSampleAttributes = AudioProxyRenderSetSampleAttributes; hwRender->common.attr.GetSampleAttributes = AudioProxyRenderGetSampleAttributes; hwRender->common.attr.GetCurrentChannelId = AudioProxyRenderGetCurrentChannelId; + hwRender->common.attr.SetExtraParams = AudioProxyRenderSetExtraParams; + hwRender->common.attr.GetExtraParams = AudioProxyRenderGetExtraParams; + hwRender->common.attr.ReqMmapBuffer = AudioProxyRenderReqMmapBuffer; + hwRender->common.attr.GetMmapPosition = AudioProxyRenderGetMmapPosition; hwRender->common.scene.CheckSceneCapability = AudioProxyRenderCheckSceneCapability; hwRender->common.scene.SelectScene = AudioProxyRenderSelectScene; hwRender->common.volume.SetMute = AudioProxyRenderSetMute; @@ -136,6 +140,8 @@ int32_t GetAudioProxyRenderFunc(struct AudioHwRender *hwRender) hwRender->common.GetRenderSpeed = AudioProxyRenderGetRenderSpeed; hwRender->common.SetChannelMode = AudioProxyRenderSetChannelMode; hwRender->common.GetChannelMode = AudioProxyRenderGetChannelMode; + hwRender->common.RegCallback = AudioProxyRenderRegCallback; + hwRender->common.DrainBuffer = AudioProxyRenderDrainBuffer; return HDF_SUCCESS; } @@ -178,7 +184,7 @@ int32_t InitForGetPortCapability(struct AudioPort portIndex, struct AudioPortCap capabilityIndex->subPorts = (struct AudioSubPortCapability *)calloc(capabilityIndex->subPortsNum, sizeof(struct AudioSubPortCapability)); if (capabilityIndex->subPorts == NULL) { - LOG_FUN_ERR("The pointer is null!"); + LOG_FUN_ERR("pointer is null!"); return HDF_FAILURE; } capabilityIndex->subPorts->portId = portIndex.portId; @@ -203,7 +209,7 @@ int32_t InitForGetPortCapability(struct AudioPort portIndex, struct AudioPortCap return HDF_FAILURE; } -void AudioAdapterReleaseCapSubPorts(struct AudioPortAndCapability *portCapabilitys, const int32_t num) +void AudioAdapterReleaseCapSubPorts(const struct AudioPortAndCapability *portCapabilitys, const int32_t num) { int32_t i = 0; if (portCapabilitys == NULL) { @@ -225,14 +231,14 @@ int32_t AudioProxyAdapterInitAllPorts(struct AudioAdapter *adapter) struct HdfSBuf *reply = NULL; const char *adapterName = NULL; struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; - if (hwAdapter == NULL) { + if (hwAdapter == NULL || hwAdapter->proxyRemoteHandle == NULL) { LOG_FUN_ERR("hwAdapter Is NULL"); return HDF_FAILURE; } /* Fake data */ - int32_t portNum = hwAdapter->adapterDescriptor.portNum; + uint32_t portNum = hwAdapter->adapterDescriptor.portNum; struct AudioPort *ports = hwAdapter->adapterDescriptor.ports; - if (ports == NULL) { + if (ports == NULL || portNum == 0) { LOG_FUN_ERR("ports is NULL!"); return HDF_FAILURE; } @@ -245,7 +251,7 @@ int32_t AudioProxyAdapterInitAllPorts(struct AudioAdapter *adapter) for (int i = 0; i < portNum; i++) { portCapability[i].port = ports[i]; if (InitForGetPortCapability(ports[i], &portCapability[i].capability)) { - LOG_FUN_ERR("ports Init Fail!"); + LOG_FUN_ERR("ports Init Invalid!"); AudioAdapterReleaseCapSubPorts(portCapability, portNum); AudioMemFree((void **)&portCapability); return HDF_FAILURE; @@ -261,7 +267,7 @@ int32_t AudioProxyAdapterInitAllPorts(struct AudioAdapter *adapter) AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_ADT_INIT_PORTS, data, reply); + int32_t ret = AudioProxyDispatchCall(hwAdapter->proxyRemoteHandle, AUDIO_HDI_ADT_INIT_PORTS, data, reply); if (ret < 0) { LOG_FUN_ERR("Get Failed AudioAdapter!"); AudioProxyBufReplyRecycle(data, reply); @@ -271,13 +277,32 @@ int32_t AudioProxyAdapterInitAllPorts(struct AudioAdapter *adapter) return HDF_SUCCESS; } +int32_t AudioProxyAdapterCreateRenderSplit(struct AudioHwAdapter *hwAdapter, struct AudioHwRender *hwRender) +{ + if (hwAdapter == NULL || hwRender == NULL) { + return HDF_FAILURE; + } + if (hwAdapter->adapterDescriptor.adapterName == NULL) { + return HDF_FAILURE; + } + uint32_t adapterNameLen = strlen(hwAdapter->adapterDescriptor.adapterName); + /* Get Adapter name */ + int32_t ret = strncpy_s(hwRender->renderParam.renderMode.hwInfo.adapterName, NAME_LEN - 1, + hwAdapter->adapterDescriptor.adapterName, adapterNameLen); + if (ret != EOK) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + int32_t AudioProxyAdapterCreateRender(struct AudioAdapter *adapter, const struct AudioDeviceDescriptor *desc, const struct AudioSampleAttributes *attrs, struct AudioRender **render) { LOG_FUN_INFO(); struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (adapter == NULL || desc == NULL || attrs == NULL || render == NULL) { + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + if (hwAdapter == NULL || hwAdapter->proxyRemoteHandle == NULL || desc == NULL || attrs == NULL || render == NULL) { return HDF_FAILURE; } struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); @@ -285,6 +310,7 @@ int32_t AudioProxyAdapterCreateRender(struct AudioAdapter *adapter, const struct LOG_FUN_ERR("hwRender is NULL!"); return HDF_FAILURE; } + hwRender->proxyRemoteHandle = hwAdapter->proxyRemoteHandle; if (GetAudioProxyRenderFunc(hwRender) < 0) { AudioMemFree((void **)&hwRender); return HDF_FAILURE; @@ -298,13 +324,13 @@ int32_t AudioProxyAdapterCreateRender(struct AudioAdapter *adapter, const struct AudioMemFree((void **)&hwRender); return HDF_FAILURE; } - if (AudioProxyCommonInitCreateData(data, adapter, desc, attrs) < 0) { + if (AudioProxyCommonInitCreateData(data, hwAdapter, desc, attrs) < 0) { LOG_FUN_ERR("Failed to obtain reply"); AudioProxyBufReplyRecycle(data, reply); AudioMemFree((void **)&hwRender); return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_RENDER_CREATE_RENDER, data, reply); + int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_CREATE_RENDER, data, reply); if (ret < 0) { LOG_FUN_ERR("Send Server fail!"); AudioProxyBufReplyRecycle(data, reply); @@ -312,12 +338,7 @@ int32_t AudioProxyAdapterCreateRender(struct AudioAdapter *adapter, const struct return ret; } AudioProxyBufReplyRecycle(data, reply); - struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; - uint32_t adapterNameLen = strlen(hwAdapter->adapterDescriptor.adapterName); - /* Get Adapter name */ - ret = strncpy_s(hwRender->renderParam.renderMode.hwInfo.adapterName, NAME_LEN - 1, - hwAdapter->adapterDescriptor.adapterName, adapterNameLen); - if (ret != EOK) { + if (AudioProxyAdapterCreateRenderSplit(hwAdapter, hwRender) < 0) { AudioMemFree((void **)&hwRender); return HDF_FAILURE; } @@ -333,13 +354,13 @@ int32_t AudioProxyAdapterDestroyRender(struct AudioAdapter *adapter, struct Audi return HDF_FAILURE; } struct AudioHwRender *hwRender = (struct AudioHwRender *)render; - if (hwRender == NULL) { + if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) { return HDF_FAILURE; } if (AudioProxyPreprocessRender((AudioHandle)render, &data, &reply) < 0) { return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_RENDER_DESTROY, data, reply); + int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_DESTROY, data, reply); if (ret < 0) { if (ret != HDF_ERR_INVALID_OBJECT) { LOG_FUN_ERR("AudioRenderRenderFrame FAIL"); @@ -363,11 +384,17 @@ int32_t GetAudioProxyCaptureFunc(struct AudioHwCapture *hwCapture) hwCapture->common.control.Pause = AudioProxyCapturePause; hwCapture->common.control.Resume = AudioProxyCaptureResume; hwCapture->common.control.Flush = AudioProxyCaptureFlush; + hwCapture->common.control.TurnStandbyMode = AudioProxyCaptureTurnStandbyMode; + hwCapture->common.control.AudioDevDump = AudioProxyCaptureAudioDevDump; hwCapture->common.attr.GetFrameSize = AudioProxyCaptureGetFrameSize; hwCapture->common.attr.GetFrameCount = AudioProxyCaptureGetFrameCount; hwCapture->common.attr.SetSampleAttributes = AudioProxyCaptureSetSampleAttributes; hwCapture->common.attr.GetSampleAttributes = AudioProxyCaptureGetSampleAttributes; hwCapture->common.attr.GetCurrentChannelId = AudioProxyCaptureGetCurrentChannelId; + hwCapture->common.attr.SetExtraParams = AudioProxyCaptureSetExtraParams; + hwCapture->common.attr.GetExtraParams = AudioProxyCaptureGetExtraParams; + hwCapture->common.attr.ReqMmapBuffer = AudioProxyCaptureReqMmapBuffer; + hwCapture->common.attr.GetMmapPosition = AudioProxyCaptureGetMmapPosition; hwCapture->common.scene.CheckSceneCapability = AudioProxyCaptureCheckSceneCapability; hwCapture->common.scene.SelectScene = AudioProxyCaptureSelectScene; hwCapture->common.volume.SetMute = AudioProxyCaptureSetMute; @@ -394,13 +421,33 @@ int32_t InitProxyHwCaptureParam(struct AudioHwCapture *hwCapture, const struct A return HDF_SUCCESS; } +int32_t AudioProxyAdapterCreateCaptureSplit(struct AudioHwAdapter *hwAdapter, struct AudioHwCapture *hwCapture) +{ + if (hwAdapter == NULL || hwCapture == NULL) { + return HDF_FAILURE; + } + if (hwAdapter->adapterDescriptor.adapterName == NULL) { + return HDF_FAILURE; + } + uint32_t adapterNameLen = strlen(hwAdapter->adapterDescriptor.adapterName); + /* Get AdapterName */ + int32_t ret = strncpy_s(hwCapture->captureParam.captureMode.hwInfo.adapterName, NAME_LEN - 1, + hwAdapter->adapterDescriptor.adapterName, adapterNameLen); + if (ret != EOK) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + int32_t AudioProxyAdapterCreateCapture(struct AudioAdapter *adapter, const struct AudioDeviceDescriptor *desc, const struct AudioSampleAttributes *attrs, struct AudioCapture **capture) { LOG_FUN_INFO(); struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (adapter == NULL || desc == NULL || attrs == NULL || capture == NULL) { + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + if (hwAdapter == NULL || hwAdapter->proxyRemoteHandle == NULL || desc == NULL || + attrs == NULL || capture == NULL) { return HDF_FAILURE; } struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)calloc(1, sizeof(struct AudioHwCapture)); @@ -408,6 +455,7 @@ int32_t AudioProxyAdapterCreateCapture(struct AudioAdapter *adapter, const struc LOG_FUN_ERR("hwCapture is NULL!"); return HDF_FAILURE; } + hwCapture->proxyRemoteHandle = hwAdapter->proxyRemoteHandle; if (GetAudioProxyCaptureFunc(hwCapture) < 0) { AudioMemFree((void **)&hwCapture); return HDF_FAILURE; @@ -421,13 +469,13 @@ int32_t AudioProxyAdapterCreateCapture(struct AudioAdapter *adapter, const struc AudioMemFree((void **)&hwCapture); return HDF_FAILURE; } - if (AudioProxyCommonInitCreateData(data, adapter, desc, attrs) < 0) { + if (AudioProxyCommonInitCreateData(data, hwAdapter, desc, attrs) < 0) { LOG_FUN_ERR("Failed to obtain reply"); AudioProxyBufReplyRecycle(data, reply); AudioMemFree((void **)&hwCapture); return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_CAPTURE_CREATE_CAPTURE, data, reply); + int32_t ret = AudioProxyDispatchCall(hwCapture->proxyRemoteHandle, AUDIO_HDI_CAPTURE_CREATE_CAPTURE, data, reply); if (ret < 0) { LOG_FUN_ERR("Send Server fail!"); AudioProxyBufReplyRecycle(data, reply); @@ -435,12 +483,7 @@ int32_t AudioProxyAdapterCreateCapture(struct AudioAdapter *adapter, const struc return ret; } AudioProxyBufReplyRecycle(data, reply); - struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; - uint32_t adapterNameLen = strlen(hwAdapter->adapterDescriptor.adapterName); - /* Get AdapterName */ - ret = strncpy_s(hwCapture->captureParam.captureMode.hwInfo.adapterName, NAME_LEN - 1, - hwAdapter->adapterDescriptor.adapterName, adapterNameLen); - if (ret != EOK) { + if (AudioProxyAdapterCreateCaptureSplit(hwAdapter, hwCapture) < 0) { AudioMemFree((void **)&hwCapture); return HDF_FAILURE; } @@ -456,13 +499,13 @@ int32_t AudioProxyAdapterDestroyCapture(struct AudioAdapter *adapter, struct Aud return HDF_FAILURE; } struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; - if (hwCapture == NULL) { + if (hwCapture == NULL || hwCapture->proxyRemoteHandle == NULL) { return HDF_FAILURE; } if (AudioProxyPreprocessCapture((AudioHandle)capture, &data, &reply) < 0) { return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_CAPTURE_DESTROY, data, reply); + int32_t ret = AudioProxyDispatchCall(hwCapture->proxyRemoteHandle, AUDIO_HDI_CAPTURE_DESTROY, data, reply); if (ret < 0) { LOG_FUN_ERR("Send Server fail!"); AudioProxyBufReplyRecycle(data, reply); @@ -473,12 +516,15 @@ int32_t AudioProxyAdapterDestroyCapture(struct AudioAdapter *adapter, struct Aud AudioProxyBufReplyRecycle(data, reply); return HDF_SUCCESS; } -int32_t AudioProxyAdapterWritePortCapability(struct AudioHwAdapter *hwAdapter, +int32_t AudioProxyAdapterWritePortCapability(const struct AudioHwAdapter *hwAdapter, const struct AudioPort *port, struct HdfSBuf *data) { if (hwAdapter == NULL || port == NULL || data == NULL) { return HDF_FAILURE; } + if (hwAdapter->adapterDescriptor.adapterName == NULL) { + return HDF_FAILURE; + } const char *adapterName = hwAdapter->adapterDescriptor.adapterName; if (!HdfSbufWriteString(data, adapterName)) { return HDF_FAILURE; @@ -490,6 +536,9 @@ int32_t AudioProxyAdapterWritePortCapability(struct AudioHwAdapter *hwAdapter, if (!HdfSbufWriteUint32(data, port->portId)) { return HDF_FAILURE; } + if (port->portName == NULL) { + return HDF_FAILURE; + } if (!HdfSbufWriteString(data, port->portName)) { return HDF_FAILURE; } @@ -512,7 +561,7 @@ int32_t AudioProxyAdapterGetPortCapability(struct AudioAdapter *adapter, return HDF_FAILURE; } struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; - if (hwAdapter == NULL) { + if (hwAdapter == NULL || hwAdapter->proxyRemoteHandle == NULL) { AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; } @@ -520,7 +569,7 @@ int32_t AudioProxyAdapterGetPortCapability(struct AudioAdapter *adapter, AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_ADT_GET_PORT_CAPABILITY, data, reply); + int32_t ret = AudioProxyDispatchCall(hwAdapter->proxyRemoteHandle, AUDIO_HDI_ADT_GET_PORT_CAPABILITY, data, reply); if (ret < 0) { AudioProxyBufReplyRecycle(data, reply); return ret; @@ -546,9 +595,9 @@ int32_t AudioProxyAdapterGetPortCapability(struct AudioAdapter *adapter, } int32_t AudioProxyAdapterSetAndGetPassthroughModeSBuf(struct HdfSBuf *data, - struct HdfSBuf *reply, const struct AudioPort *port) + const struct HdfSBuf *reply, const struct AudioPort *port) { - if (data == NULL || port == NULL) { + if (data == NULL || port == NULL || port->portName == NULL) { return HDF_FAILURE; } uint32_t tempDir = port->dir; @@ -582,7 +631,8 @@ int32_t AudioProxyAdapterSetPassthroughMode(struct AudioAdapter *adapter, return HDF_FAILURE; } struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; - if (hwAdapter == NULL) { + if (hwAdapter == NULL || hwAdapter->proxyRemoteHandle == NULL || + hwAdapter->adapterDescriptor.adapterName == NULL) { AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; } @@ -603,7 +653,7 @@ int32_t AudioProxyAdapterSetPassthroughMode(struct AudioAdapter *adapter, AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_ADT_SET_PASS_MODE, data, reply); + int32_t ret = AudioProxyDispatchCall(hwAdapter->proxyRemoteHandle, AUDIO_HDI_ADT_SET_PASS_MODE, data, reply); if (ret < 0) { AudioProxyBufReplyRecycle(data, reply); LOG_FUN_ERR("Failed to send server"); @@ -628,7 +678,11 @@ int32_t AudioProxyAdapterGetPassthroughMode(struct AudioAdapter *adapter, return HDF_FAILURE; } struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; - if (hwAdapter == NULL) { + if (hwAdapter == NULL || hwAdapter->proxyRemoteHandle == NULL) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + if (hwAdapter->adapterDescriptor.adapterName == NULL) { AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; } @@ -642,7 +696,7 @@ int32_t AudioProxyAdapterGetPassthroughMode(struct AudioAdapter *adapter, AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_ADT_GET_PASS_MODE, data, reply); + int32_t ret = AudioProxyDispatchCall(hwAdapter->proxyRemoteHandle, AUDIO_HDI_ADT_GET_PASS_MODE, data, reply); if (ret < 0) { AudioProxyBufReplyRecycle(data, reply); return ret; diff --git a/audio/hal/hdi_binder/proxy/src/audio_proxy_capture.c b/audio/hal/hdi_binder/proxy/src/audio_proxy_capture.c index 4fcb88f34f..3d3302887d 100755 --- a/audio/hal/hdi_binder/proxy/src/audio_proxy_capture.c +++ b/audio/hal/hdi_binder/proxy/src/audio_proxy_capture.c @@ -15,43 +15,48 @@ #include "audio_proxy_common.h" -static int32_t AudioProxyCaptureCtrl(int cmId, AudioHandle handle) +static int32_t AudioProxyCaptureCtrl(int cmId, const AudioHandle handle) { struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (AudioProxyPreprocessCapture(handle, &data, &reply) < 0) { + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL || hwCapture->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The pointer is null"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessCapture(hwCapture, &data, &reply) < 0) { return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(cmId, data, reply); + int32_t ret = AudioProxyDispatchCall(hwCapture->proxyRemoteHandle, cmId, data, reply); AudioProxyBufReplyRecycle(data, reply); return ret; } -int32_t AudioProxyCaptureStart(AudioHandle handle) +int32_t AudioProxyCaptureStart(const AudioHandle handle) { LOG_FUN_INFO(); return AudioProxyCaptureCtrl(AUDIO_HDI_CAPTURE_START, handle); } -int32_t AudioProxyCaptureStop(AudioHandle handle) +int32_t AudioProxyCaptureStop(const AudioHandle handle) { LOG_FUN_INFO(); return AudioProxyCaptureCtrl(AUDIO_HDI_CAPTURE_STOP, handle); } -int32_t AudioProxyCapturePause(AudioHandle handle) +int32_t AudioProxyCapturePause(const AudioHandle handle) { LOG_FUN_INFO(); return AudioProxyCaptureCtrl(AUDIO_HDI_CAPTURE_PAUSE, handle); } -int32_t AudioProxyCaptureResume(AudioHandle handle) +int32_t AudioProxyCaptureResume(const AudioHandle handle) { LOG_FUN_INFO(); return AudioProxyCaptureCtrl(AUDIO_HDI_CAPTURE_RESUME, handle); } -int32_t AudioProxyCaptureFlush(AudioHandle handle) +int32_t AudioProxyCaptureFlush(const AudioHandle handle) { LOG_FUN_INFO(); struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; @@ -68,10 +73,15 @@ int32_t AudioProxyCaptureGetFrameParameter(int cmId, AudioHandle handle, uint64_ } struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (AudioProxyPreprocessCapture(handle, &data, &reply) < 0) { + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL || hwCapture->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The pointer is empty"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessCapture(hwCapture, &data, &reply) < 0) { return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(cmId, data, reply); + int32_t ret = AudioProxyDispatchCall(hwCapture->proxyRemoteHandle, cmId, data, reply); if (ret < 0) { LOG_FUN_ERR("AudioCaptureGetFrameSize FAIL"); AudioProxyBufReplyRecycle(data, reply); @@ -95,36 +105,47 @@ int32_t AudioProxyCaptureGetFrameCount(AudioHandle handle, uint64_t *count) return AudioProxyCaptureGetFrameParameter(AUDIO_HDI_CAPTURE_GET_FRAME_COUNT, handle, count); } -int32_t AudioProxyCaptureSetSampleAttributes(AudioHandle handle, const struct AudioSampleAttributes *attrs) +int32_t AudioProxyCaptureSetSampleAttributes(const AudioHandle handle, const struct AudioSampleAttributes *attrs) { if (handle == NULL || attrs == NULL) { return HDF_FAILURE; } struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (AudioProxyPreprocessCapture(handle, &data, &reply) < 0) { + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL || hwCapture->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("hwCapture or hwCapture->proxyRemoteHandle is NULL"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessCapture(hwCapture, &data, &reply) < 0) { + LOG_FUN_ERR("AudioProxyPreprocessCapture Fail"); return HDF_FAILURE; } if (AudioProxyWriteSampleAttributes(data, attrs) < 0) { AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_CAPTURE_SET_SAMPLE_ATTR, data, reply); + int32_t ret = AudioProxyDispatchCall(hwCapture->proxyRemoteHandle, AUDIO_HDI_CAPTURE_SET_SAMPLE_ATTR, data, reply); AudioProxyBufReplyRecycle(data, reply); return ret; } -int32_t AudioProxyCaptureGetSampleAttributes(AudioHandle handle, struct AudioSampleAttributes *attrs) +int32_t AudioProxyCaptureGetSampleAttributes(const AudioHandle handle, struct AudioSampleAttributes *attrs) { if (attrs == NULL) { return HDF_FAILURE; } struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (AudioProxyPreprocessCapture(handle, &data, &reply) < 0) { + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL || hwCapture->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The Invalid is pointer"); return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_CAPTURE_GET_SAMPLE_ATTR, data, reply); + if (AudioProxyPreprocessCapture(hwCapture, &data, &reply) < 0) { + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(hwCapture->proxyRemoteHandle, AUDIO_HDI_CAPTURE_GET_SAMPLE_ATTR, data, reply); if (ret < 0) { LOG_FUN_ERR("AudioCaptureGetSampleAttributes FAIL"); AudioProxyBufReplyRecycle(data, reply); @@ -138,17 +159,23 @@ int32_t AudioProxyCaptureGetSampleAttributes(AudioHandle handle, struct AudioSam return HDF_SUCCESS; } -int32_t AudioProxyCaptureGetCurrentChannelId(AudioHandle handle, uint32_t *channelId) +int32_t AudioProxyCaptureGetCurrentChannelId(const AudioHandle handle, uint32_t *channelId) { if (channelId == NULL) { return HDF_FAILURE; } struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (AudioProxyPreprocessCapture(handle, &data, &reply) < 0) { + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL || hwCapture->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("hwCapture parameter is invalid"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessCapture(hwCapture, &data, &reply) < 0) { return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_CAPTURE_GET_CUR_CHANNEL_ID, data, reply); + int32_t ret = AudioProxyDispatchCall(hwCapture->proxyRemoteHandle, + AUDIO_HDI_CAPTURE_GET_CUR_CHANNEL_ID, data, reply); if (ret < 0) { LOG_FUN_ERR("AudioCaptureGetFrameSize FAIL"); AudioProxyBufReplyRecycle(data, reply); @@ -163,7 +190,7 @@ int32_t AudioProxyCaptureGetCurrentChannelId(AudioHandle handle, uint32_t *chann return HDF_SUCCESS; } -int32_t AudioProxyCaptureCheckSceneCapability(AudioHandle handle, +int32_t AudioProxyCaptureCheckSceneCapability(const AudioHandle handle, const struct AudioSceneDescriptor *scene, bool *supported) { if (scene == NULL || supported == NULL) { @@ -173,7 +200,12 @@ int32_t AudioProxyCaptureCheckSceneCapability(AudioHandle handle, uint32_t tempSupported = 0; struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (AudioProxyPreprocessCapture(handle, &data, &reply) < 0) { + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL || hwCapture->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("pointer invalid"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessCapture(hwCapture, &data, &reply) < 0) { return HDF_FAILURE; } if (!HdfSbufWriteUint32(data, scene->scene.id)) { @@ -185,7 +217,8 @@ int32_t AudioProxyCaptureCheckSceneCapability(AudioHandle handle, AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_CAPTURE_CHECK_SCENE_CAPABILITY, data, reply); + int32_t ret = AudioProxyDispatchCall(hwCapture->proxyRemoteHandle, + AUDIO_HDI_CAPTURE_CHECK_SCENE_CAPABILITY, data, reply); if (ret < 0) { LOG_FUN_ERR("AudioProxyCaptureCheckSceneCapability FAIL"); AudioProxyBufReplyRecycle(data, reply); @@ -200,14 +233,19 @@ int32_t AudioProxyCaptureCheckSceneCapability(AudioHandle handle, return HDF_SUCCESS; } -int32_t AudioProxyCaptureSelectScene(AudioHandle handle, const struct AudioSceneDescriptor *scene) +int32_t AudioProxyCaptureSelectScene(const AudioHandle handle, const struct AudioSceneDescriptor *scene) { if (scene == NULL) { return HDF_FAILURE; } struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (AudioProxyPreprocessCapture(handle, &data, &reply) < 0) { + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL || hwCapture->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The hwCapture pointer is null"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessCapture(hwCapture, &data, &reply) < 0) { return HDF_FAILURE; } if (!HdfSbufWriteUint32(data, (enum AudioCategory)scene->scene.id)) { @@ -219,16 +257,21 @@ int32_t AudioProxyCaptureSelectScene(AudioHandle handle, const struct AudioScene AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_CAPTURE_SELECT_SCENE, data, reply); + int32_t ret = AudioProxyDispatchCall(hwCapture->proxyRemoteHandle, AUDIO_HDI_CAPTURE_SELECT_SCENE, data, reply); AudioProxyBufReplyRecycle(data, reply); return ret; } -int32_t AudioProxyCaptureSetMute(AudioHandle handle, bool mute) +int32_t AudioProxyCaptureSetMute(const AudioHandle handle, bool mute) { struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (AudioProxyPreprocessCapture(handle, &data, &reply) < 0) { + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL || hwCapture->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The hwCapture parameter is null"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessCapture(hwCapture, &data, &reply) < 0) { return HDF_FAILURE; } uint32_t tempMute = (uint32_t)mute; @@ -236,22 +279,27 @@ int32_t AudioProxyCaptureSetMute(AudioHandle handle, bool mute) AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_CAPTURE_SET_MUTE, data, reply); + int32_t ret = AudioProxyDispatchCall(hwCapture->proxyRemoteHandle, AUDIO_HDI_CAPTURE_SET_MUTE, data, reply); AudioProxyBufReplyRecycle(data, reply); return ret; } -int32_t AudioProxyCaptureGetMute(AudioHandle handle, bool *mute) +int32_t AudioProxyCaptureGetMute(const AudioHandle handle, bool *mute) { struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; if (mute == NULL) { return HDF_FAILURE; } - if (AudioProxyPreprocessCapture(handle, &data, &reply) < 0) { + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL || hwCapture->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The hwCapture parameter is null"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessCapture(hwCapture, &data, &reply) < 0) { return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_CAPTURE_GET_MUTE, data, reply); + int32_t ret = AudioProxyDispatchCall(hwCapture->proxyRemoteHandle, AUDIO_HDI_CAPTURE_GET_MUTE, data, reply); if (ret < 0) { LOG_FUN_ERR("AudioCaptureGetMute FAIL"); AudioProxyBufReplyRecycle(data, reply); @@ -267,33 +315,39 @@ int32_t AudioProxyCaptureGetMute(AudioHandle handle, bool *mute) return HDF_SUCCESS; } -int32_t AudioProxyCaptureSetVolume(AudioHandle handle, float volume) +int32_t AudioProxyCaptureSetVolume(const AudioHandle handle, float volume) { - return AudioProxyCommonSetCtrlParam(AUDIO_HDI_CAPTURE_SET_VOLUME, handle, volume); + return AudioProxyCommonSetCaptureCtrlParam(AUDIO_HDI_CAPTURE_SET_VOLUME, handle, volume); } -int32_t AudioProxyCaptureGetVolume(AudioHandle handle, float *volume) +int32_t AudioProxyCaptureGetVolume(const AudioHandle handle, float *volume) { - return AudioProxyCommonGetCtrlParam(AUDIO_HDI_CAPTURE_GET_VOLUME, handle, volume); + return AudioProxyCommonGetCaptureCtrlParam(AUDIO_HDI_CAPTURE_GET_VOLUME, handle, volume); } -int32_t AudioProxyCaptureGetGainThreshold(AudioHandle handle, float *min, float *max) +int32_t AudioProxyCaptureGetGainThreshold(const AudioHandle handle, float *min, float *max) { if (NULL == min || NULL == max) { return HDF_FAILURE; } struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (AudioProxyPreprocessCapture(handle, &data, &reply) < 0) { + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL || hwCapture->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The hwCapture pointer is invalid"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessCapture(hwCapture, &data, &reply) < 0) { return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_CAPTURE_GET_GAIN_THRESHOLD, data, reply); + int32_t ret = AudioProxyDispatchCall(hwCapture->proxyRemoteHandle, + AUDIO_HDI_CAPTURE_GET_GAIN_THRESHOLD, data, reply); if (ret < 0) { LOG_FUN_ERR("AudioCaptureGetGainThreshold FAIL"); AudioProxyBufReplyRecycle(data, reply); return ret; } - uint32_t temp; + uint32_t temp = 0; if (!HdfSbufReadUint32(reply, &temp)) { AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; @@ -308,35 +362,40 @@ int32_t AudioProxyCaptureGetGainThreshold(AudioHandle handle, float *min, float return HDF_SUCCESS; } -int32_t AudioProxyCaptureGetGain(AudioHandle handle, float *gain) +int32_t AudioProxyCaptureGetGain(const AudioHandle handle, float *gain) { - return AudioProxyCommonGetCtrlParam(AUDIO_HDI_CAPTURE_GET_GAIN, handle, gain); + return AudioProxyCommonGetCaptureCtrlParam(AUDIO_HDI_CAPTURE_GET_GAIN, handle, gain); } -int32_t AudioProxyCaptureSetGain(AudioHandle handle, float gain) +int32_t AudioProxyCaptureSetGain(const AudioHandle handle, float gain) { - return AudioProxyCommonSetCtrlParam(AUDIO_HDI_CAPTURE_SET_GAIN, handle, gain); + return AudioProxyCommonSetCaptureCtrlParam(AUDIO_HDI_CAPTURE_SET_GAIN, handle, gain); } int32_t AudioProxyCaptureCaptureFrame(struct AudioCapture *capture, void *frame, uint64_t requestBytes, uint64_t *replyBytes) { const char *buffer = NULL; - uint32_t length; + uint32_t length = 0; if (frame == NULL || replyBytes == NULL) { LOG_FUN_ERR("capture Frame Paras is NULL!"); return HDF_FAILURE; } struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (AudioProxyPreprocessCapture((AudioHandle)capture, &data, &reply) < 0) { + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + if (hwCapture == NULL || hwCapture->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The pointer is empty"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessCapture(hwCapture, &data, &reply) < 0) { return HDF_FAILURE; } if (!HdfSbufWriteUint64(data, requestBytes)) { AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_CAPTURE_CAPTURE_FRAME, data, reply); + int32_t ret = AudioProxyDispatchCall(hwCapture->proxyRemoteHandle, AUDIO_HDI_CAPTURE_CAPTURE_FRAME, data, reply); if (ret < 0) { if (ret != HDF_ERR_INVALID_OBJECT) { LOG_FUN_ERR("AudioCaptureCaptureFrame FAIL"); @@ -352,7 +411,11 @@ int32_t AudioProxyCaptureCaptureFrame(struct AudioCapture *capture, void *frame, AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; } - memcpy_s(frame, requestBytes, buffer, length); + ret = memcpy_s(frame, requestBytes, buffer, length); + if (ret != EOK) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } if (!HdfSbufReadUint64(reply, replyBytes)) { AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; @@ -361,37 +424,222 @@ int32_t AudioProxyCaptureCaptureFrame(struct AudioCapture *capture, void *frame, return HDF_SUCCESS; } -int32_t AudioProxyCaptureGetCapturePosition(struct AudioCapture *capture, uint64_t *frames, struct AudioTimeStamp *time) +int32_t AudioProxyCaptureGetCapturePosition(struct AudioCapture *capture, + uint64_t *frames, struct AudioTimeStamp *time) { if (frames == NULL || time == NULL) { return HDF_FAILURE; } struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (AudioProxyPreprocessCapture((AudioHandle)capture, &data, &reply) < 0) { + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + if (hwCapture == NULL || hwCapture->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The hwCapture parameter is null"); return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_CAPTURE_GET_CAPTURE_POSITION, data, reply); + if (AudioProxyPreprocessCapture(hwCapture, &data, &reply) < 0) { + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(hwCapture->proxyRemoteHandle, + AUDIO_HDI_CAPTURE_GET_CAPTURE_POSITION, data, reply); if (ret < 0) { LOG_FUN_ERR("AudioCaptureGetCapturePosition FAIL"); AudioProxyBufReplyRecycle(data, reply); return ret; } - if (!HdfSbufReadUint64(reply, frames)) { - LOG_FUN_ERR("Read Buf FAIL"); + if (AudioProxyGetMmapPositionRead(reply, frames, time) < 0) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + AudioProxyBufReplyRecycle(data, reply); + return HDF_SUCCESS; +} +int32_t AudioProxyCaptureSetExtraParams(const AudioHandle handle, const char *keyValueList) +{ + if (NULL == handle || NULL == keyValueList) { + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL || hwCapture->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("hwCapture or hwCapture->proxyRemoteHandle is NULL"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessCapture((AudioHandle)hwCapture, &data, &reply) < 0) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(data, keyValueList)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(hwCapture->proxyRemoteHandle, AUDIO_HDI_CAPTURE_SET_EXTRA_PARAMS, data, reply); + AudioProxyBufReplyRecycle(data, reply); + return ret; +} +int32_t AudioProxyCaptureGetExtraParams(const AudioHandle handle, char *keyValueList, int32_t listLenth) +{ + if (NULL == handle || NULL == keyValueList || listLenth <= 0) { + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL || hwCapture->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The parameter is null"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessCapture((AudioHandle)hwCapture, &data, &reply) < 0) { + LOG_FUN_ERR("AudioProxyCaptureGetExtraParams FAIL"); + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(data, listLenth)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(hwCapture->proxyRemoteHandle, AUDIO_HDI_CAPTURE_GET_EXTRA_PARAMS, data, reply); + if (ret < 0) { + LOG_FUN_ERR("AudioProxyCaptureGetExtraParams FAIL"); + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + const char *strKeyValueList = NULL; + if ((strKeyValueList = HdfSbufReadString(reply)) == NULL) { + LOG_FUN_ERR("keyValueList Is NULL"); + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + ret = strncpy_s(keyValueList, listLenth - 1, strKeyValueList, strlen(strKeyValueList) + 1); + if (ret != 0) { + LOG_FUN_ERR("strncpy_s failed!"); AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; } - if (!HdfSbufReadInt64(reply, &time->tvSec)) { - LOG_FUN_ERR("Read Buf FAIL"); + AudioProxyBufReplyRecycle(data, reply); + return ret; +} +int32_t AudioProxyCaptureReqMmapBuffer(const AudioHandle handle, + int32_t reqSize, struct AudioMmapBufferDescripter *desc) +{ + if (NULL == handle || NULL == desc) { + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL || hwCapture->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("hwCapture parameter is null"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessCapture((AudioHandle)hwCapture, &data, &reply) < 0) { + LOG_FUN_ERR("AudioProxyCaptureReqMmapBuffer FAIL"); + return HDF_FAILURE; + } + if (AudioProxyReqMmapBufferWrite(data, reqSize, desc) < 0) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(hwCapture->proxyRemoteHandle, AUDIO_HDI_CAPTURE_REQ_MMAP_BUFFER, data, reply); + if (ret < 0) { + LOG_FUN_ERR("AudioProxyCaptureReqMmapBuffer FAIL"); AudioProxyBufReplyRecycle(data, reply); + return ret; + } + + AudioProxyBufReplyRecycle(data, reply); + return ret; +} + +int32_t AudioProxyCaptureGetMmapPosition(const AudioHandle handle, uint64_t *frames, struct AudioTimeStamp *time) +{ + if (NULL == handle || NULL == frames || NULL == time) { + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL || hwCapture->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The parameter is empty"); return HDF_FAILURE; } - if (!HdfSbufReadInt64(reply, &time->tvNSec)) { - LOG_FUN_ERR("Read Buf FAIL"); + if (AudioProxyPreprocessCapture((AudioHandle)hwCapture, &data, &reply) < 0) { + LOG_FUN_ERR("AudioProxyCaptureGetMmapPosition FAIL"); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(hwCapture->proxyRemoteHandle, + AUDIO_HDI_CAPTURE_GET_MMAP_POSITION, data, reply); + if (ret < 0) { + AudioProxyBufReplyRecycle(data, reply); + LOG_FUN_ERR("AudioProxyCaptureGetMmapPosition FAIL"); + return ret; + } + if (AudioProxyGetMmapPositionRead(reply, frames, time) < 0) { AudioProxyBufReplyRecycle(data, reply); + LOG_FUN_ERR("AudioProxyGetMmapPositionRead FAIL"); return HDF_FAILURE; } AudioProxyBufReplyRecycle(data, reply); return HDF_SUCCESS; } + +int32_t AudioProxyCaptureTurnStandbyMode(const AudioHandle handle) +{ + if (NULL == handle) { + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL || hwCapture->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The hwCapture parameter is empty"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessCapture((AudioHandle)hwCapture, &data, &reply) < 0) { + LOG_FUN_ERR("AudioProxyCaptureTurnStandbyMode FAIL"); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(hwCapture->proxyRemoteHandle, + AUDIO_HDI_CAPTURE_TURN_STAND_BY_MODE, data, reply); + if (ret < 0) { + LOG_FUN_ERR("AudioProxyCaptureTurnStandbyMode FAIL"); + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + AudioProxyBufReplyRecycle(data, reply); + return ret; +} +int32_t AudioProxyCaptureAudioDevDump(const AudioHandle handle, int32_t range, int32_t fd) +{ + if (NULL == handle) { + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL || hwCapture->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("hwCapture parameter is empty"); + return HDF_FAILURE; + } + + if (AudioProxyPreprocessCapture((AudioHandle)hwCapture, &data, &reply) < 0) { + LOG_FUN_ERR("AudioProxyCaptureAudioDevDump FAIL"); + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(data, range)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(data, fd)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(hwCapture->proxyRemoteHandle, AUDIO_HDI_CAPTURE_DEV_DUMP, data, reply); + if (ret < 0) { + LOG_FUN_ERR("AudioProxyCaptureAudioDevDump FAIL"); + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + AudioProxyBufReplyRecycle(data, reply); + return ret; +} + diff --git a/audio/hal/hdi_binder/proxy/src/audio_proxy_common.c b/audio/hal/hdi_binder/proxy/src/audio_proxy_common.c index fa608c5b09..e0acdbbea0 100755 --- a/audio/hal/hdi_binder/proxy/src/audio_proxy_common.c +++ b/audio/hal/hdi_binder/proxy/src/audio_proxy_common.c @@ -14,14 +14,11 @@ */ #include "audio_proxy_common.h" -#include "audio_proxy_manager.h" +#include #define AUDIO_HDF_SBUF_IPC 1 #define PROXY_VOLUME_CHANGE 100 -struct HDIAudioManager *g_serviceObj; - - struct HdfSBuf *AudioProxyObtainHdfSBuf() { enum HdfSbufType bufType; @@ -33,54 +30,17 @@ struct HdfSBuf *AudioProxyObtainHdfSBuf() return HdfSBufTypedObtain(bufType); } -static void ProxyMgrConstruct(struct AudioManager *proxyMgr) -{ - proxyMgr->GetAllAdapters = AudioProxyManagerGetAllAdapters; - proxyMgr->LoadAdapter = AudioProxyManagerLoadAdapter; - proxyMgr->UnloadAdapter = AudioProxyManagerUnloadAdapter; -} - -struct AudioManager *HdfProxyIoBindServiceName(const char *serviceName) -{ - LOG_FUN_INFO(); - if (serviceName == NULL) { - LOG_FUN_ERR("ServiceName is null"); - return NULL; - } - struct HDIServiceManager *serviceMgr = HDIServiceManagerGet(); - if (serviceMgr == NULL) { - LOG_FUN_ERR("serviceMgr is null"); - return NULL; - } - struct HdfRemoteService *remote = serviceMgr->GetService(serviceMgr, serviceName); - if (remote == NULL) { - LOG_FUN_ERR("Remote GetService failed!"); - HDIServiceManagerRelease(serviceMgr); - return NULL; - } - HDIServiceManagerRelease(serviceMgr); - g_serviceObj = OsalMemAlloc(sizeof(struct HDIAudioManager)); - if (g_serviceObj == NULL) { - LOG_FUN_ERR("malloc failed!"); - HdfRemoteServiceRecycle(remote); - return NULL; - } - g_serviceObj->remote = remote; - ProxyMgrConstruct(&g_serviceObj->proxyAudioManager); - return &g_serviceObj->proxyAudioManager; -} - -int32_t AudioProxyDispatchCall(int32_t id, struct HdfSBuf *data, struct HdfSBuf *reply) +int32_t AudioProxyDispatchCall(struct HdfRemoteService *self, + int32_t id, struct HdfSBuf *data, struct HdfSBuf *reply) { - if (data == NULL || reply == NULL || g_serviceObj == NULL) { + if (data == NULL || reply == NULL || self == NULL) { return HDF_FAILURE; } - if (g_serviceObj->remote == NULL || g_serviceObj->remote->dispatcher == NULL || - g_serviceObj->remote->dispatcher->Dispatch == NULL) { + if (self->dispatcher == NULL || self->dispatcher->Dispatch == NULL) { LOG_FUN_ERR("AudioProxyDispatchCall obj is null"); return HDF_ERR_INVALID_OBJECT; } - return g_serviceObj->remote->dispatcher->Dispatch(g_serviceObj->remote, id, data, reply); + return self->dispatcher->Dispatch(self, id, data, reply); } void AudioProxyBufReplyRecycle(struct HdfSBuf *data, struct HdfSBuf *reply) @@ -113,18 +73,18 @@ int32_t AudioProxyPreprocessSBuf(struct HdfSBuf **data, struct HdfSBuf **reply) return HDF_SUCCESS; } -int32_t AudioProxyPreprocessRender(AudioHandle render, struct HdfSBuf **data, struct HdfSBuf **reply) +int32_t AudioProxyPreprocessRender(struct AudioHwRender *render, struct HdfSBuf **data, struct HdfSBuf **reply) { - if (data == NULL || reply == NULL) { + struct AudioHwRender *hwRender = render; + if (hwRender == NULL || data == NULL || reply == NULL) { return HDF_FAILURE; } - const char *adapterName; - uint32_t renderPid = getpid(); - struct AudioHwRender *hwRender = (struct AudioHwRender *)render; - if (hwRender == NULL) { + uint32_t renderPid = (uint32_t)getpid(); + const char *adapterName = hwRender->renderParam.renderMode.hwInfo.adapterName; + if (adapterName == NULL) { + LOG_FUN_ERR("adapterName is NULL"); return HDF_FAILURE; } - adapterName = hwRender->renderParam.renderMode.hwInfo.adapterName; if (AudioProxyPreprocessSBuf(data, reply) < 0) { return HDF_FAILURE; } @@ -139,18 +99,18 @@ int32_t AudioProxyPreprocessRender(AudioHandle render, struct HdfSBuf **data, st return HDF_SUCCESS; } -int32_t AudioProxyPreprocessCapture(AudioHandle capture, struct HdfSBuf **data, struct HdfSBuf **reply) +int32_t AudioProxyPreprocessCapture(struct AudioHwCapture *capture, struct HdfSBuf **data, struct HdfSBuf **reply) { - if (data == NULL || reply == NULL) { + struct AudioHwCapture *hwCapture = capture; + if (hwCapture == NULL || data == NULL || reply == NULL) { return HDF_FAILURE; } - const char *adapterName; - uint32_t capturePid = getpid(); - struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; - if (hwCapture == NULL) { + uint32_t capturePid = (uint32_t)getpid(); + const char *adapterName = hwCapture->captureParam.captureMode.hwInfo.adapterName; + if (adapterName == NULL) { + LOG_FUN_ERR("The pointer is null"); return HDF_FAILURE; } - adapterName = hwCapture->captureParam.captureMode.hwInfo.adapterName; if (AudioProxyPreprocessSBuf(data, reply) < 0) { return HDF_FAILURE; } @@ -261,44 +221,110 @@ int32_t AudioProxyReadSapmleAttrbutes(struct HdfSBuf *reply, struct AudioSampleA return HDF_SUCCESS; } -int32_t AudioProxyCommonSetCtrlParam(int cmId, AudioHandle handle, float param) +int32_t AudioProxyCommonSetRenderCtrlParam(int cmId, AudioHandle handle, float param) { LOG_FUN_INFO(); struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (cmId == AUDIO_HDI_RENDER_SET_VOLUME || cmId == AUDIO_HDI_CAPTURE_SET_VOLUME) { - if (param < 0 || param > 1.0) { + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The hwRender parameter is null"); + return HDF_FAILURE; + } + if (param < 0) { + LOG_FUN_ERR("Set param is invalid, Please check param!"); + return HDF_FAILURE; + } + if (cmId == AUDIO_HDI_RENDER_SET_VOLUME) { + if (param > 1.0) { LOG_FUN_ERR("volume param Is error!"); return HDF_FAILURE; } param = param * PROXY_VOLUME_CHANGE; } - if (cmId == AUDIO_HDI_RENDER_SET_GAIN || cmId == AUDIO_HDI_CAPTURE_SET_GAIN) { - if (param < 0) { - LOG_FUN_ERR("Set gain is error, Please check param!"); - return HDF_FAILURE; - } + if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) { + return HDF_FAILURE; } - if (cmId >= AUDIO_HDI_CAPTURE_CREATE_CAPTURE) { - if (AudioProxyPreprocessCapture(handle, &data, &reply) < 0) { - return HDF_FAILURE; - } + uint32_t tempParam = (uint32_t)param; + if (!HdfSbufWriteUint32(data, tempParam)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, cmId, data, reply); + AudioProxyBufReplyRecycle(data, reply); + return ret; +} + +int32_t AudioProxyCommonGetRenderCtrlParam(int cmId, AudioHandle handle, float *param) +{ + LOG_FUN_INFO(); + if (param == NULL) { + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The pointer is empty"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) { + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, cmId, data, reply); + if (ret < 0) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + uint32_t tempParam = 0; + if (!HdfSbufReadUint32(reply, &tempParam)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + if (cmId == AUDIO_HDI_RENDER_GET_VOLUME) { + *param = (float)tempParam / PROXY_VOLUME_CHANGE; } else { - if (AudioProxyPreprocessRender(handle, &data, &reply) < 0) { + *param = (float)tempParam; + } + AudioProxyBufReplyRecycle(data, reply); + return HDF_SUCCESS; +} + +int32_t AudioProxyCommonSetCaptureCtrlParam(int cmId, AudioHandle handle, float param) +{ + LOG_FUN_INFO(); + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL || hwCapture->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The hwCapture parameter is null"); + return HDF_FAILURE; + } + if (param < 0) { + LOG_FUN_ERR("Set param is invalid, Please check param!"); + return HDF_FAILURE; + } + if (cmId == AUDIO_HDI_CAPTURE_SET_VOLUME) { + if (param > 1.0) { + LOG_FUN_ERR("volume param Is error!"); return HDF_FAILURE; } + param = param * PROXY_VOLUME_CHANGE; + } + if (AudioProxyPreprocessCapture(hwCapture, &data, &reply) < 0) { + return HDF_FAILURE; } uint32_t tempParam = (uint32_t)param; if (!HdfSbufWriteUint32(data, tempParam)) { AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(cmId, data, reply); + int32_t ret = AudioProxyDispatchCall(hwCapture->proxyRemoteHandle, cmId, data, reply); AudioProxyBufReplyRecycle(data, reply); return ret; } -int32_t AudioProxyCommonGetCtrlParam(int cmId, AudioHandle handle, float *param) +int32_t AudioProxyCommonGetCaptureCtrlParam(int cmId, AudioHandle handle, float *param) { LOG_FUN_INFO(); if (param == NULL) { @@ -306,26 +332,25 @@ int32_t AudioProxyCommonGetCtrlParam(int cmId, AudioHandle handle, float *param) } struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (cmId >= AUDIO_HDI_CAPTURE_CREATE_CAPTURE) { - if (AudioProxyPreprocessCapture(handle, &data, &reply) < 0) { - return HDF_FAILURE; - } - } else { - if (AudioProxyPreprocessRender(handle, &data, &reply) < 0) { - return HDF_FAILURE; - } + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL || hwCapture->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The hwCapture parameter is invalid"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessCapture(hwCapture, &data, &reply) < 0) { + return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(cmId, data, reply); + int32_t ret = AudioProxyDispatchCall(hwCapture->proxyRemoteHandle, cmId, data, reply); if (ret < 0) { AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; } - uint32_t tempParam; + uint32_t tempParam = 0; if (!HdfSbufReadUint32(reply, &tempParam)) { AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; } - if (cmId == AUDIO_HDI_RENDER_GET_VOLUME || cmId == AUDIO_HDI_CAPTURE_GET_VOLUME) { + if (cmId == AUDIO_HDI_CAPTURE_GET_VOLUME) { *param = (float)tempParam / PROXY_VOLUME_CHANGE; } else { *param = (float)tempParam; @@ -333,3 +358,52 @@ int32_t AudioProxyCommonGetCtrlParam(int cmId, AudioHandle handle, float *param) AudioProxyBufReplyRecycle(data, reply); return HDF_SUCCESS; } + +int32_t AudioProxyGetMmapPositionRead(struct HdfSBuf *reply, uint64_t *frames, struct AudioTimeStamp *time) +{ + if (reply == NULL || frames == NULL || time == NULL) { + return HDF_FAILURE; + } + if (!HdfSbufReadUint64(reply, frames)) { + return HDF_FAILURE; + } + if (!HdfSbufReadInt64(reply, &time->tvSec)) { + return HDF_FAILURE; + } + if (!HdfSbufReadInt64(reply, &time->tvNSec)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioProxyReqMmapBufferWrite(struct HdfSBuf *data, int32_t reqSize, + const struct AudioMmapBufferDescripter *desc) +{ + if (data == NULL || desc == NULL) { + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(data, reqSize)) { + return HDF_FAILURE; + } + uint64_t memAddr = (uint64_t)desc->memoryAddress; + if (!HdfSbufWriteUint64(data, memAddr)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(data, desc->memoryFd)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(data, desc->totalBufferFrames)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(data, desc->transferFrameSize)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(data, desc->isShareable)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, desc->offset)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + diff --git a/audio/hal/hdi_binder/proxy/src/audio_proxy_manager.c b/audio/hal/hdi_binder/proxy/src/audio_proxy_manager.c index be4a846483..82573babc3 100755 --- a/audio/hal/hdi_binder/proxy/src/audio_proxy_manager.c +++ b/audio/hal/hdi_binder/proxy/src/audio_proxy_manager.c @@ -12,9 +12,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - #include "audio_proxy_manager.h" -#include "audio_adapter_info_common.h" +#include #include "audio_proxy_common.h" #include "audio_proxy_internal.h" @@ -23,7 +22,7 @@ #define FRAME_SIZE 1024 #define CONFIG_FRAME_COUNT ((8000 * 2 * 1 + (CONFIG_FRAME_SIZE - 1)) / CONFIG_FRAME_SIZE) -int32_t AudioProxyManagerGetAllAdapters(struct AudioManager *manager, +int32_t AudioProxyManagerGetAllAdapters(struct AudioProxyManager *manager, struct AudioAdapterDescriptor **descs, int *size) { @@ -31,7 +30,7 @@ int32_t AudioProxyManagerGetAllAdapters(struct AudioManager *manager, struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; int32_t ret; - if (manager == NULL || descs == NULL || size == NULL) { + if (manager == NULL || manager->remote == NULL || descs == NULL || size == NULL) { return HDF_FAILURE; } if (AudioProxyPreprocessSBuf(&data, &reply) < 0) { @@ -43,7 +42,7 @@ int32_t AudioProxyManagerGetAllAdapters(struct AudioManager *manager, LOG_FUN_ERR("AudioAdaptersForUser FAIL!"); return ret; } - ret = AudioProxyDispatchCall(AUDIO_HDI_MGR_GET_ALL_ADAPTER, data, reply); + ret = AudioProxyDispatchCall(manager->remote, AUDIO_HDI_MGR_GET_ALL_ADAPTER, data, reply); if (ret != HDF_SUCCESS) { AudioProxyBufReplyRecycle(data, reply); LOG_FUN_ERR("Failed to send service call!"); @@ -53,14 +52,15 @@ int32_t AudioProxyManagerGetAllAdapters(struct AudioManager *manager, return HDF_SUCCESS; } -int32_t AudioProxyManagerLoadAdapter(struct AudioManager *manager, const struct AudioAdapterDescriptor *desc, +int32_t AudioProxyManagerLoadAdapter(struct AudioProxyManager *manager, const struct AudioAdapterDescriptor *desc, struct AudioAdapter **adapter) { LOG_FUN_INFO(); struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (manager == NULL || desc == NULL || desc->adapterName == NULL || adapter == NULL) { + if (manager == NULL || manager->remote == NULL || desc == NULL || + desc->adapterName == NULL || desc->ports == NULL || adapter == NULL) { return HDF_FAILURE; } if (AudioAdapterExist(desc->adapterName)) { @@ -86,7 +86,7 @@ int32_t AudioProxyManagerLoadAdapter(struct AudioManager *manager, const struct return HDF_FAILURE; } int32_t ret; - ret = AudioProxyDispatchCall(AUDIO_HDI_MGR_LOAD_ADAPTER, data, reply); + ret = AudioProxyDispatchCall(manager->remote, AUDIO_HDI_MGR_LOAD_ADAPTER, data, reply); if (ret < 0) { LOG_FUN_ERR("Failed to send service call!!"); AudioProxyBufReplyRecycle(data, reply); @@ -103,13 +103,14 @@ int32_t AudioProxyManagerLoadAdapter(struct AudioManager *manager, const struct hwAdapter->common.SetPassthroughMode = AudioProxyAdapterSetPassthroughMode; hwAdapter->common.GetPassthroughMode = AudioProxyAdapterGetPassthroughMode; hwAdapter->adapterDescriptor = *desc; + hwAdapter->proxyRemoteHandle = manager->remote; // get dispatch Server *adapter = &hwAdapter->common; AudioProxyBufReplyRecycle(data, reply); LOG_FUN_INFO(); return HDF_SUCCESS; } -void AudioProxyManagerUnloadAdapter(struct AudioManager *manager, struct AudioAdapter *adapter) +void AudioProxyManagerUnloadAdapter(struct AudioProxyManager *manager, struct AudioAdapter *adapter) { struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; @@ -117,7 +118,7 @@ void AudioProxyManagerUnloadAdapter(struct AudioManager *manager, struct AudioAd int32_t i = 0; int32_t portNum; struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; - if (manager == NULL || adapter == NULL) { + if (manager == NULL || manager->remote == NULL || adapter == NULL) { return; } if (hwAdapter->portCapabilitys != NULL) { @@ -133,7 +134,7 @@ void AudioProxyManagerUnloadAdapter(struct AudioManager *manager, struct AudioAd if (AudioProxyPreprocessSBuf(&data, &reply) == HDF_SUCCESS) { adapterName = hwAdapter->adapterDescriptor.adapterName; if (HdfSbufWriteString(data, adapterName)) { - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_MGR_UNLOAD_ADAPTER, data, reply); + int32_t ret = AudioProxyDispatchCall(manager->remote, AUDIO_HDI_MGR_UNLOAD_ADAPTER, data, reply); if (ret < 0) { LOG_FUN_ERR("Send Server fail!"); } @@ -144,9 +145,36 @@ void AudioProxyManagerUnloadAdapter(struct AudioManager *manager, struct AudioAd return; } -struct AudioManager *GetAudioProxyManagerFuncs(void) +static void ProxyMgrConstruct(struct AudioProxyManager *proxyMgr) +{ + proxyMgr->GetAllAdapters = AudioProxyManagerGetAllAdapters; + proxyMgr->LoadAdapter = AudioProxyManagerLoadAdapter; + proxyMgr->UnloadAdapter = AudioProxyManagerUnloadAdapter; +} + +struct AudioProxyManager *GetAudioProxyManagerFuncs(void) { LOG_FUN_INFO(); - return HdfProxyIoBindServiceName(HDI_SERVER_NAME); + struct HDIServiceManager *serviceMgr = HDIServiceManagerGet(); + if (serviceMgr == NULL) { + LOG_FUN_ERR("HDIServiceManagerGet failed!"); + return NULL; + } + struct HdfRemoteService *remote = serviceMgr->GetService(serviceMgr, HDI_SERVER_NAME); + if (remote == NULL) { + LOG_FUN_ERR("Remote GetService failed!"); + HDIServiceManagerRelease(serviceMgr); + return NULL; + } + HDIServiceManagerRelease(serviceMgr); + struct AudioProxyManager *proxyDevMgr = OsalMemAlloc(sizeof(struct AudioProxyManager)); + if (proxyDevMgr == NULL) { + LOG_FUN_ERR("malloc failed!"); + HdfRemoteServiceRecycle(remote); + return NULL; + } + ProxyMgrConstruct(proxyDevMgr); + proxyDevMgr->remote = remote; + return proxyDevMgr; } diff --git a/audio/hal/hdi_binder/proxy/src/audio_proxy_render.c b/audio/hal/hdi_binder/proxy/src/audio_proxy_render.c index 154a938576..da1a64917c 100755 --- a/audio/hal/hdi_binder/proxy/src/audio_proxy_render.c +++ b/audio/hal/hdi_binder/proxy/src/audio_proxy_render.c @@ -19,10 +19,15 @@ int32_t AudioProxyRenderCtrl(int cmId, AudioHandle handle) { struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (AudioProxyPreprocessRender(handle, &data, &reply) < 0) { + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The hwRender parameter is null"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) { return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(cmId, data, reply); + int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, cmId, data, reply); AudioProxyBufReplyRecycle(data, reply); return ret; } @@ -60,17 +65,23 @@ int32_t AudioProxyRenderFlush(AudioHandle handle) return HDF_ERR_NOT_SUPPORT; } -int32_t AudioProxyRenderGetFrameParameter(int cmId, AudioHandle handle, uint64_t *param) +int32_t AudioProxyRenderGetFrameParameter(int cmId, const AudioHandle handle, uint64_t *param) { if (param == NULL) { return HDF_FAILURE; } + int32_t ret; struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (AudioProxyPreprocessRender(handle, &data, &reply) < 0) { + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("invalid pointer"); return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(cmId, data, reply); + if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) { + return HDF_FAILURE; + } + ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, cmId, data, reply); if (ret < 0) { AudioProxyBufReplyRecycle(data, reply); return ret; @@ -83,46 +94,57 @@ int32_t AudioProxyRenderGetFrameParameter(int cmId, AudioHandle handle, uint64_t return HDF_SUCCESS; } -int32_t AudioProxyRenderGetFrameSize(AudioHandle handle, uint64_t *size) +int32_t AudioProxyRenderGetFrameSize(const AudioHandle handle, uint64_t *size) { return AudioProxyRenderGetFrameParameter(AUDIO_HDI_RENDER_GET_FRAME_SIZE, handle, size); } -int32_t AudioProxyRenderGetFrameCount(AudioHandle handle, uint64_t *count) +int32_t AudioProxyRenderGetFrameCount(const AudioHandle handle, uint64_t *count) { return AudioProxyRenderGetFrameParameter(AUDIO_HDI_RENDER_GET_FRAME_COUNT, handle, count); } -int32_t AudioProxyRenderSetSampleAttributes(AudioHandle handle, const struct AudioSampleAttributes *attrs) +int32_t AudioProxyRenderSetSampleAttributes(const AudioHandle handle, const struct AudioSampleAttributes *attrs) { if (handle == NULL || attrs == NULL) { return HDF_FAILURE; } struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (AudioProxyPreprocessRender(handle, &data, &reply) < 0) { + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("pointer is invalid"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) { return HDF_FAILURE; } if (AudioProxyWriteSampleAttributes(data, attrs) < 0) { AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_RENDER_SET_SAMPLE_ATTR, data, reply); + int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_SET_SAMPLE_ATTR, data, reply); AudioProxyBufReplyRecycle(data, reply); return ret; } -int32_t AudioProxyRenderGetSampleAttributes(AudioHandle handle, struct AudioSampleAttributes *attrs) +int32_t AudioProxyRenderGetSampleAttributes(const AudioHandle handle, + struct AudioSampleAttributes *attrs) { if (attrs == NULL) { return HDF_FAILURE; } struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (AudioProxyPreprocessRender(handle, &data, &reply) < 0) { + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The hwRender parameter is empty"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) { return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_RENDER_GET_SAMPLE_ATTR, data, reply); + int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_GET_SAMPLE_ATTR, data, reply); if (ret < 0) { LOG_FUN_ERR("AudioRenderGetSampleAttributes FAIL"); AudioProxyBufReplyRecycle(data, reply); @@ -137,17 +159,22 @@ int32_t AudioProxyRenderGetSampleAttributes(AudioHandle handle, struct AudioSamp return HDF_SUCCESS; } -int32_t AudioProxyRenderGetCurrentChannelId(AudioHandle handle, uint32_t *channelId) +int32_t AudioProxyRenderGetCurrentChannelId(const AudioHandle handle, uint32_t *channelId) { if (channelId == NULL) { return HDF_FAILURE; } struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (AudioProxyPreprocessRender(handle, &data, &reply) < 0) { + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("pointer is null"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) { return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_RENDER_GET_CUR_CHANNEL_ID, data, reply); + int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_GET_CUR_CHANNEL_ID, data, reply); if (ret < 0) { LOG_FUN_ERR("AudioRenderGetCurrentChannelId FAIL"); AudioProxyBufReplyRecycle(data, reply); @@ -170,7 +197,13 @@ int32_t AudioProxyRenderCheckSceneCapability(AudioHandle handle, uint32_t tempPins; struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (AudioProxyPreprocessRender(handle, &data, &reply) < 0) { + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The hwRender pointer is null"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) { + LOG_FUN_ERR("AudioProxyPreprocessRender FAIL"); return HDF_FAILURE; } if (!HdfSbufWriteUint32(data, scene->scene.id)) { @@ -178,13 +211,14 @@ int32_t AudioProxyRenderCheckSceneCapability(AudioHandle handle, AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; } - tempPins = scene->desc.pins; + tempPins = (uint32_t)scene->desc.pins; if (!HdfSbufWriteUint32(data, tempPins)) { LOG_FUN_ERR("tempPins Write FAIL"); AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_RENDER_CHECK_SCENE_CAPABILITY, data, reply); + int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, + AUDIO_HDI_RENDER_CHECK_SCENE_CAPABILITY, data, reply); if (ret < 0) { LOG_FUN_ERR("AudioRenderCheckSceneCapability FAIL"); AudioProxyBufReplyRecycle(data, reply); @@ -207,7 +241,12 @@ int32_t AudioProxyRenderSelectScene(AudioHandle handle, const struct AudioSceneD } struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (AudioProxyPreprocessRender(handle, &data, &reply) < 0) { + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("parameter is null"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) { return HDF_FAILURE; } if (!HdfSbufWriteUint32(data, scene->scene.id)) { @@ -219,7 +258,7 @@ int32_t AudioProxyRenderSelectScene(AudioHandle handle, const struct AudioSceneD AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_RENDER_SELECT_SCENE, data, reply); + int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_SELECT_SCENE, data, reply); AudioProxyBufReplyRecycle(data, reply); return ret; } @@ -228,7 +267,12 @@ int32_t AudioProxyRenderSetMute(AudioHandle handle, bool mute) { struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (AudioProxyPreprocessRender(handle, &data, &reply) < 0) { + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The pointer is null"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) { return HDF_FAILURE; } uint32_t tempMute = (uint32_t)mute; @@ -236,7 +280,7 @@ int32_t AudioProxyRenderSetMute(AudioHandle handle, bool mute) AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_RENDER_SET_MUTE, data, reply); + int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_SET_MUTE, data, reply); AudioProxyBufReplyRecycle(data, reply); return ret; } @@ -248,11 +292,16 @@ int32_t AudioProxyRenderGetMute(AudioHandle handle, bool *mute) } struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (AudioProxyPreprocessRender(handle, &data, &reply) < 0) { + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The parameter is null"); return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_RENDER_GET_MUTE, data, reply); - uint32_t tempMute; + if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) { + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_GET_MUTE, data, reply); + uint32_t tempMute = 0; if (!HdfSbufReadUint32(reply, &tempMute)) { AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; @@ -263,17 +312,16 @@ int32_t AudioProxyRenderGetMute(AudioHandle handle, bool *mute) return ret; } - int32_t AudioProxyRenderSetVolume(AudioHandle handle, float volume) { LOG_FUN_INFO(); - return AudioProxyCommonSetCtrlParam(AUDIO_HDI_RENDER_SET_VOLUME, handle, volume); + return AudioProxyCommonSetRenderCtrlParam(AUDIO_HDI_RENDER_SET_VOLUME, handle, volume); } int32_t AudioProxyRenderGetVolume(AudioHandle handle, float *volume) { LOG_FUN_INFO(); - return AudioProxyCommonGetCtrlParam(AUDIO_HDI_RENDER_GET_VOLUME, handle, volume); + return AudioProxyCommonGetRenderCtrlParam(AUDIO_HDI_RENDER_GET_VOLUME, handle, volume); } int32_t AudioProxyRenderGetGainThreshold(AudioHandle handle, float *min, float *max) @@ -283,17 +331,22 @@ int32_t AudioProxyRenderGetGainThreshold(AudioHandle handle, float *min, float * } struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (AudioProxyPreprocessRender(handle, &data, &reply) < 0) { + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The pointer is invalid"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) { return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_RENDER_GET_GAIN_THRESHOLD, data, reply); + int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_GET_GAIN_THRESHOLD, data, reply); if (ret < 0) { LOG_FUN_ERR("AudioRenderGetGainThreshold FAIL"); AudioProxyBufReplyRecycle(data, reply); return ret; } - uint32_t tempMin; - uint32_t tempMax; + uint32_t tempMin = 0; + uint32_t tempMax = 0; if (!HdfSbufReadUint32(reply, &tempMin)) { AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; @@ -310,22 +363,27 @@ int32_t AudioProxyRenderGetGainThreshold(AudioHandle handle, float *min, float * int32_t AudioProxyRenderGetGain(AudioHandle handle, float *gain) { - return AudioProxyCommonGetCtrlParam(AUDIO_HDI_RENDER_GET_GAIN, handle, gain); + return AudioProxyCommonGetRenderCtrlParam(AUDIO_HDI_RENDER_GET_GAIN, handle, gain); } int32_t AudioProxyRenderSetGain(AudioHandle handle, float gain) { - return AudioProxyCommonSetCtrlParam(AUDIO_HDI_RENDER_SET_GAIN, handle, gain); + return AudioProxyCommonSetRenderCtrlParam(AUDIO_HDI_RENDER_SET_GAIN, handle, gain); } int32_t AudioProxyRenderGetLatency(struct AudioRender *render, uint32_t *ms) { struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (AudioProxyPreprocessRender((AudioHandle)render, &data, &reply) < 0) { + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The pointer is empty"); return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_RENDER_GET_LATENCY, data, reply); + if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) { + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_GET_LATENCY, data, reply); if (ret < 0) { LOG_FUN_ERR("AudioRenderGetLatency FAIL"); AudioProxyBufReplyRecycle(data, reply); @@ -348,7 +406,12 @@ int32_t AudioProxyRenderRenderFrame(struct AudioRender *render, const void *fram } struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (AudioProxyPreprocessRender((AudioHandle)render, &data, &reply) < 0) { + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The hwRender parameter is null"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) { LOG_FUN_ERR("AudioProxyPreprocessRender FAIL"); return HDF_FAILURE; } @@ -357,7 +420,7 @@ int32_t AudioProxyRenderRenderFrame(struct AudioRender *render, const void *fram LOG_FUN_ERR("HdfSbufWriteBuffer FAIL"); return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_RENDER_RENDER_FRAME, data, reply); + int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_RENDER_FRAME, data, reply); if (ret < 0) { if (ret != HDF_ERR_INVALID_OBJECT) { LOG_FUN_ERR("AudioRenderRenderFrame FAIL"); @@ -377,24 +440,24 @@ int32_t AudioProxyRenderGetRenderPosition(struct AudioRender *render, uint64_t * } struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (AudioProxyPreprocessRender((AudioHandle)render, &data, &reply) < 0) { + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("hwRender or hwRender->proxyRemoteHandle invalid"); return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_RENDER_GET_RENDER_POSITION, data, reply); + if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) { + LOG_FUN_ERR("AudioProxyPreprocessRender FAIL"); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, + AUDIO_HDI_RENDER_GET_RENDER_POSITION, data, reply); if (ret < 0) { LOG_FUN_ERR("AudioRenderGetRenderPosition FAIL"); AudioProxyBufReplyRecycle(data, reply); return ret; } - if (!HdfSbufReadUint64(reply, frames)) { - AudioProxyBufReplyRecycle(data, reply); - return HDF_FAILURE; - } - if (!HdfSbufReadInt64(reply, &time->tvSec)) { - AudioProxyBufReplyRecycle(data, reply); - return HDF_FAILURE; - } - if (!HdfSbufReadInt64(reply, &time->tvNSec)) { + if (AudioProxyGetMmapPositionRead(reply, frames, time) < 0) { + LOG_FUN_ERR("AudioProxyGetMmapPositionRead FAIL"); AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; } @@ -424,7 +487,13 @@ int32_t AudioProxyRenderSetChannelMode(struct AudioRender *render, enum AudioCha { struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (AudioProxyPreprocessRender((AudioHandle)render, &data, &reply) < 0) { + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("parameter is null"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) { + LOG_FUN_ERR("AudioProxyPreprocessRender FAIL"); return HDF_FAILURE; } uint32_t tempMode = (uint32_t)mode; @@ -432,7 +501,7 @@ int32_t AudioProxyRenderSetChannelMode(struct AudioRender *render, enum AudioCha AudioProxyBufReplyRecycle(data, reply); return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_RENDER_SET_CHANNEL_MODE, data, reply); + int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_SET_CHANNEL_MODE, data, reply); AudioProxyBufReplyRecycle(data, reply); return ret; } @@ -444,11 +513,16 @@ int32_t AudioProxyRenderGetChannelMode(struct AudioRender *render, enum AudioCha } struct HdfSBuf *data = NULL; struct HdfSBuf *reply = NULL; - if (AudioProxyPreprocessRender((AudioHandle)render, &data, &reply) < 0) { - LOG_FUN_ERR("AudioProxyRenderGetChannelMode FAIL"); + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("hwRender or hwRender->proxyRemoteHandle is NULL"); return HDF_FAILURE; } - int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_RENDER_GET_CHANNEL_MODE, data, reply); + if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) { + LOG_FUN_ERR("AudioProxyPreprocessRender FAIL"); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_GET_CHANNEL_MODE, data, reply); if (ret < 0) { LOG_FUN_ERR("AudioRenderGetChannelMode FAIL"); AudioProxyBufReplyRecycle(data, reply); @@ -464,3 +538,259 @@ int32_t AudioProxyRenderGetChannelMode(struct AudioRender *render, enum AudioCha return HDF_SUCCESS; } +int32_t AudioProxyRenderSetExtraParams(AudioHandle handle, const char *keyValueList) +{ + if (NULL == handle || NULL == keyValueList) { + LOG_FUN_ERR("The parameter is empty"); + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The parameter is null"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessRender((AudioHandle)hwRender, &data, &reply) < 0) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(data, keyValueList)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_SET_EXTRA_PARAMS, data, reply); + AudioProxyBufReplyRecycle(data, reply); + return ret; +} +int32_t AudioProxyRenderGetExtraParams(AudioHandle handle, char *keyValueList, int32_t listLenth) +{ + LOG_PARA_INFO("AudioProxyRenderGetExtraParams enter!"); + if (NULL == handle || NULL == keyValueList || listLenth <= 0) { + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("parameter is null"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessRender((AudioHandle)hwRender, &data, &reply) < 0) { + LOG_FUN_ERR("AudioProxyRenderGetExtraParams FAIL"); + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(data, listLenth)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_GET_EXTRA_PARAMS, data, reply); + if (ret < 0) { + LOG_FUN_ERR("AudioProxyRenderGetExtraParams FAIL"); + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + const char *strKeyValueList = NULL; + if ((strKeyValueList = HdfSbufReadString(reply)) == NULL) { + LOG_FUN_ERR("keyValueList Is empty"); + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + ret = strncpy_s(keyValueList, listLenth - 1, strKeyValueList, strlen(strKeyValueList) + 1); + if (ret != 0) { + LOG_FUN_ERR("Copy failed!"); + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + AudioProxyBufReplyRecycle(data, reply); + return ret; +} + +int32_t AudioProxyRenderReqMmapBuffer(AudioHandle handle, int32_t reqSize, struct AudioMmapBufferDescripter *desc) +{ + if (NULL == handle || NULL == desc) { + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("hwRender or hwRender->proxyRemoteHandle is NULL"); + return HDF_FAILURE; + } + + if (AudioProxyPreprocessRender((AudioHandle)hwRender, &data, &reply) < 0) { + LOG_FUN_ERR("AudioProxyRenderReqMmapBuffer FAIL"); + return HDF_FAILURE; + } + if (AudioProxyReqMmapBufferWrite(data, reqSize, desc) < 0) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_REQ_MMAP_BUFFER, data, reply); + if (ret < 0) { + LOG_FUN_ERR("AudioProxyRenderReqMmapBuffer FAIL"); + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + + AudioProxyBufReplyRecycle(data, reply); + return ret; +} + +int32_t AudioProxyRenderGetMmapPosition(AudioHandle handle, uint64_t *frames, struct AudioTimeStamp *time) +{ + if (NULL == handle || NULL == frames || NULL == time) { + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The parameter is empty"); + return HDF_FAILURE; + } + + if (AudioProxyPreprocessRender((AudioHandle)hwRender, &data, &reply) < 0) { + LOG_FUN_ERR("AudioProxyRenderGetMmapPosition FAIL"); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_GET_MMAP_POSITION, data, reply); + if (ret < 0) { + AudioProxyBufReplyRecycle(data, reply); + LOG_FUN_ERR("AudioProxyRenderGetMmapPosition FAIL"); + return ret; + } + if (AudioProxyGetMmapPositionRead(reply, frames, time) < 0) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + AudioProxyBufReplyRecycle(data, reply); + return HDF_SUCCESS; +} + +int32_t AudioProxyRenderTurnStandbyMode(AudioHandle handle) +{ + if (NULL == handle) { + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("parameter is empty"); + return HDF_FAILURE; + } + + if (AudioProxyPreprocessRender((AudioHandle)hwRender, &data, &reply) < 0) { + LOG_FUN_ERR("AudioProxyRenderTurnStandbyMode FAIL"); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_TURN_STAND_BY_MODE, data, reply); + if (ret < 0) { + LOG_FUN_ERR("AudioProxyRenderTurnStandbyMode FAIL"); + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + AudioProxyBufReplyRecycle(data, reply); + return ret; +} +int32_t AudioProxyRenderAudioDevDump(AudioHandle handle, int32_t range, int32_t fd) +{ + if (NULL == handle) { + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The hwRender parameter is empty"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessRender((AudioHandle)hwRender, &data, &reply) < 0) { + LOG_FUN_ERR("AudioProxyRenderAudioDevDump FAIL"); + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(data, range)) { + AudioProxyBufReplyRecycle(data, reply); + LOG_FUN_ERR("Write FAIL"); + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(data, fd)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_DEV_DUMP, data, reply); + if (ret < 0) { + LOG_FUN_ERR("AudioProxyRenderAudioDevDump FAIL"); + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + AudioProxyBufReplyRecycle(data, reply); + return ret; +} +int32_t AudioProxyRenderRegCallback(struct AudioRender *render, RenderCallback callback, void *cookie) +{ + if (NULL == render || NULL == callback || NULL == cookie) { + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The parameter is empty"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessRender((AudioHandle)hwRender, &data, &reply) < 0) { + LOG_FUN_ERR("AudioProxyRenderRegCallback FAIL"); + return HDF_FAILURE; + } + uint64_t tempAddr = (uint64_t)cookie; + if (!HdfSbufWriteUint64(data, tempAddr)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + tempAddr = (uint64_t)callback; + if (!HdfSbufWriteUint64(data, tempAddr)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_REG_CALLBACK, data, reply); + if (ret < 0) { + LOG_FUN_ERR("AudioProxyRenderRegCallback FAIL"); + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + AudioProxyBufReplyRecycle(data, reply); + return ret; +} +int32_t AudioProxyRenderDrainBuffer(struct AudioRender *render, enum AudioDrainNotifyType *type) +{ + if (NULL == render) { + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) { + LOG_FUN_ERR("The hwRender parameter is empty"); + return HDF_FAILURE; + } + if (AudioProxyPreprocessRender((AudioHandle)hwRender, &data, &reply) < 0) { + LOG_FUN_ERR("AudioProxyRenderDrainBuffer FAIL"); + return HDF_FAILURE; + } + uint32_t tempType = (uint32_t)type; + if (!HdfSbufWriteUint32(data, tempType)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_DRAIN_BUFFER, data, reply); + if (ret < 0) { + LOG_FUN_ERR("AudioProxyRenderDrainBuffer FAIL"); + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + AudioProxyBufReplyRecycle(data, reply); + return ret; +} + diff --git a/audio/hal/hdi_binder/server/BUILD.gn b/audio/hal/hdi_binder/server/BUILD.gn new file mode 100755 index 0000000000..1a26454a1d --- /dev/null +++ b/audio/hal/hdi_binder/server/BUILD.gn @@ -0,0 +1,147 @@ +# 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. + +if (defined(ohos_lite)) { + import("//build/lite/config/component/lite_component.gni") +} else { + import("//build/ohos.gni") +} +import("//drivers/adapter/uhdf2/uhdf.gni") +import("//drivers/peripheral/audio/audio.gni") + +config("hdi_service_config") { + visibility = [ ":*" ] + + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-DGST_DISABLE_DEPRECATED", + "-DHAVE_CONFIG_H", + "-fno-strict-aliasing", + "-Wno-sign-compare", + "-Wno-builtin-requires-header", + "-Wno-implicit-function-declaration", + "-Wno-format", + "-Wno-int-conversion", + "-Wno-unused-function", + "-Wno-unused-parameter", + "-Wno-thread-safety-attributes", + "-Wno-inconsistent-missing-override", + "-fno-rtti", + "-fno-exceptions", + "-ffunction-sections", + "-fdata-sections", + ] + + ldflags = [ "-Wl" ] +} + +if (defined(ohos_lite)) { + shared_library("audio_hdi_adapter_server") { + include_dirs = [ + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/peripheral/audio/hal/hdi_binder/server/include", + "$hdf_framework_path/include/core", + "$hdf_framework_path/include/utils", + "$hdf_framework_path/include/osal", + "$hdf_framework_path/ability/sbuf/include", + "$hdf_framework_path/utils/include", + "$hdf_framework_path/include", + "$hdf_framework_path/core/sec/include", + "$hdf_framework_path/core/shared/include", + "$hdf_framework_path/core/host/include", + "$hdf_framework_path/core/manager/include", + "$hdf_framework_path/core/common/include/host/", + "//third_party/bounds_checking_function/include", + "//drivers/adapter/khdf/liteos/osal/include", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/adapter/uhdf2/include/hdi/" + ] + + sources = [ + "src/hdf_audio_server.c", + "src/hdf_audio_server_capture.c", + "src/hdf_audio_server_common.c", + "src/hdf_audio_server_render.c", + "$hdf_framework_path/support/posix/src/osal_mem.c", + "$hdf_framework_path/ability/sbuf/src/hdf_sbuf.c" + ] + + deps = [ + "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio", + "//third_party/bounds_checking_function:libsec_shared" + ] + + public_configs = [ ":hdi_service_config" ] + } + + lite_component("hdi") { + features = [ ":audio_hdi_adapter_server" ] + } +} else { + ohos_shared_library("audio_hdi_adapter_server") { + include_dirs = [ + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/server/include", + "$hdf_framework_path/include/core", + "$hdf_framework_path/include/utils", + "$hdf_framework_path/include/osal", + "$hdf_framework_path/include", + "//third_party/bounds_checking_function/include", + "$hdf_framework_path/ability/sbuf/include", + "$hdf_framework_path/utils/include", + "$hdf_framework_path/ability/sbuf/include", + "$hdf_uhdf_path/osal/include" + ] + + sources = [ + "src/hdf_audio_server.c", + "src/hdf_audio_server_capture.c", + "src/hdf_audio_server_common.c", + "src/hdf_audio_server_render.c", + ] + + deps = [ + "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio", + "$hdf_uhdf_path/osal:libhdf_utils", + "$hdf_uhdf_path/manager:hdf_devmgr", + "$hdf_uhdf_path/manager:hdf_devmgr.rc", + "//utils/native/base:utils", + "$hdf_uhdf_path/hdi:libhdi", + "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", + "$hdf_uhdf_path/host:hdf_devhost", + "$hdf_uhdf_path/host:libhdf_host", + "$hdf_uhdf_path/config:libhdf_hcs", + "$hdf_uhdf_path/hcs:hdf_default.hcb", + ] + + defines = [] + if (enable_audio_device_mpi) { + defines += [ "AUDIO_HAL_USER" ] + } + if (is_standard_system) { + external_deps = [ "hiviewdfx_hilog_native:libhilog" ] + } else { + external_deps = [ "hilog:libhilog" ] + } + + public_configs = [ ":hdi_service_config" ] + + subsystem_name = "hdf" + } +} + diff --git a/audio/hal/hdi_binder/server/include/hdf_audio_server.h b/audio/hal/hdi_binder/server/include/hdf_audio_server.h index 277acf62f1..d94e150a68 100755 --- a/audio/hal/hdi_binder/server/include/hdf_audio_server.h +++ b/audio/hal/hdi_binder/server/include/hdf_audio_server.h @@ -15,16 +15,7 @@ #ifndef HDF_AUDIO_SERVER_H #define HDF_AUDIO_SERVER_H -#include -#include -#include -#include "hdf_log.h" -#include "hdf_base.h" #include "hdf_device_desc.h" -#include "hdf_remote_service.h" -#include "audio_internal.h" -#include "hdf_audio_server_render.h" -#include "hdf_audio_server_capture.h" enum AudioHdiServerCmdId { /*************public*************/ @@ -66,6 +57,14 @@ enum AudioHdiServerCmdId { AUDIO_HDI_RENDER_SET_SPEED, AUDIO_HDI_RENDER_SET_CHANNEL_MODE, AUDIO_HDI_RENDER_GET_CHANNEL_MODE, + AUDIO_HDI_RENDER_SET_EXTRA_PARAMS, + AUDIO_HDI_RENDER_GET_EXTRA_PARAMS, + AUDIO_HDI_RENDER_REQ_MMAP_BUFFER, + AUDIO_HDI_RENDER_GET_MMAP_POSITION, + AUDIO_HDI_RENDER_TURN_STAND_BY_MODE, + AUDIO_HDI_RENDER_DEV_DUMP, + AUDIO_HDI_RENDER_REG_CALLBACK, + AUDIO_HDI_RENDER_DRAIN_BUFFER, /***********capture*************/ AUDIO_HDI_CAPTURE_CREATE_CAPTURE, AUDIO_HDI_CAPTURE_DESTROY, @@ -89,7 +88,13 @@ enum AudioHdiServerCmdId { AUDIO_HDI_CAPTURE_GET_GAIN, AUDIO_HDI_CAPTURE_SET_GAIN, AUDIO_HDI_CAPTURE_CAPTURE_FRAME, - AUDIO_HDI_CAPTURE_GET_CAPTURE_POSITION + AUDIO_HDI_CAPTURE_GET_CAPTURE_POSITION, + AUDIO_HDI_CAPTURE_SET_EXTRA_PARAMS, + AUDIO_HDI_CAPTURE_GET_EXTRA_PARAMS, + AUDIO_HDI_CAPTURE_REQ_MMAP_BUFFER, + AUDIO_HDI_CAPTURE_GET_MMAP_POSITION, + AUDIO_HDI_CAPTURE_TURN_STAND_BY_MODE, + AUDIO_HDI_CAPTURE_DEV_DUMP }; typedef int32_t (*AudioAllfunc)(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply); diff --git a/audio/hal/hdi_binder/server/include/hdf_audio_server_capture.h b/audio/hal/hdi_binder/server/include/hdf_audio_server_capture.h index ffc650d8cc..9de1008cbb 100755 --- a/audio/hal/hdi_binder/server/include/hdf_audio_server_capture.h +++ b/audio/hal/hdi_binder/server/include/hdf_audio_server_capture.h @@ -15,14 +15,7 @@ #ifndef HDF_AUDIO_SERVER_CAPTURE_H #define HDF_AUDIO_SERVER_CAPTURE_H -#include -#include -#include -#include "hdf_log.h" -#include "hdf_base.h" #include "hdf_device_desc.h" -#include "hdf_remote_service.h" -#include "hdf_audio_server_common.h" int32_t HdiServiceCreatCapture(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply); @@ -70,5 +63,17 @@ int32_t HdiServiceCaptureCaptureFrame(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply); int32_t HdiServiceCaptureGetCapturePosition(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCaptureSetExtraParams(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCaptureGetExtraParams(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCaptureReqMmapBuffer(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCaptureGetMmapPosition(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCaptureTurnStandbyMode(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCaptureDevDump(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); #endif diff --git a/audio/hal/hdi_binder/server/include/hdf_audio_server_common.h b/audio/hal/hdi_binder/server/include/hdf_audio_server_common.h index ec25f556f0..a8e0a4b4ff 100755 --- a/audio/hal/hdi_binder/server/include/hdf_audio_server_common.h +++ b/audio/hal/hdi_binder/server/include/hdf_audio_server_common.h @@ -16,12 +16,12 @@ #ifndef HDF_AUDIO_SERVER_COMMON_H #define HDF_AUDIO_SERVER_COMMON_H -#include "audio_manager.h" -#include "audio_types.h" +#include "hdf_device_desc.h" +#include "hdf_log.h" #include "audio_internal.h" -#include "hdf_audio_server.h" -#define MAX_AUDIO_ADAPTER_NUM_SERVER 3 +#define MAX_AUDIO_ADAPTER_NUM_SERVER 8 // Limit the number of sound cards supported to a maximum of 8 +#define STR_MAX 512 /* RenderManage Info */ struct AudioInfoInAdapter { @@ -79,6 +79,13 @@ int32_t ReadAudioSapmleAttrbutes(struct HdfSBuf *data, struct AudioSampleAttribu int32_t WriteAudioSampleAttributes(struct HdfSBuf *reply, const struct AudioSampleAttributes *attrs); void AudioSetCaptureStatus(const char *adapterName, bool captureStatus); int32_t AudioGetCaptureStatus(const char *adapterName); +int32_t ServerManageGetAdapterNum(void); +struct AudioInfoInAdapter *ServerManageGetAdapters(void); +void AdaptersServerManageRelease(struct AudioInfoInAdapter *adaptersManage, int32_t num); +void AdaptersServerManageInfomationRecycle(void); +int32_t AdaptersServerManageInit(struct AudioAdapterDescriptor *descs, int32_t num); +int32_t HdiServicePositionWrite(struct HdfSBuf *reply, + uint64_t frames, struct AudioTimeStamp time); #endif diff --git a/audio/hal/hdi_binder/server/include/hdf_audio_server_render.h b/audio/hal/hdi_binder/server/include/hdf_audio_server_render.h index 4f83e5600b..ca8453c55b 100755 --- a/audio/hal/hdi_binder/server/include/hdf_audio_server_render.h +++ b/audio/hal/hdi_binder/server/include/hdf_audio_server_render.h @@ -16,14 +16,7 @@ #ifndef HDF_AUDIO_SERVER_RENDER_H #define HDF_AUDIO_SERVER_RENDER_H -#include -#include -#include -#include "hdf_log.h" -#include "hdf_base.h" #include "hdf_device_desc.h" -#include "hdf_remote_service.h" -#include "hdf_audio_server_common.h" int32_t HdiServiceCreatRender(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply); @@ -81,6 +74,22 @@ int32_t HdiServiceRenderSetChannelMode(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply); int32_t HdiServiceRenderGetChannelMode(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderSetExtraParams(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderGetExtraParams(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderReqMmapBuffer(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderGetMmapPosition(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderTurnStandbyMode(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderDevDump(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderRegCallback(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderDrainBuffer(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); #endif diff --git a/audio/hal/hdi_binder/server/src/hdf_audio_server.c b/audio/hal/hdi_binder/server/src/hdf_audio_server.c index c09e67d19b..2b17a4ccde 100755 --- a/audio/hal/hdi_binder/server/src/hdf_audio_server.c +++ b/audio/hal/hdi_binder/server/src/hdf_audio_server.c @@ -14,22 +14,28 @@ */ #include "hdf_audio_server.h" +#include "hdf_audio_server_capture.h" #include "hdf_audio_server_common.h" +#include "hdf_audio_server_render.h" #define HDF_LOG_TAG hdf_audio_server + struct AudioAdapterDescriptor *g_descs = NULL; struct AudioManager *g_serverManager = NULL; - +#ifdef AUDIO_HAL_USER +static void *g_mpiInitSo = NULL; +#define SO_INTERFACE_LIB_MPI_PATH "/system/lib/libhdi_audio_interface_lib_mpi.z.so" +#endif /**************************public************************/ int32_t HdiServiceGetFuncs() { - HDF_LOGE("%{public}s", "enter to HdiServiceGetFuncs "); + HDF_LOGE("%{public}s: enter to", __func__); if (g_serverManager != NULL) { return HDF_SUCCESS; } g_serverManager = GetAudioManagerFuncs(); if (g_serverManager == NULL) { - HDF_LOGE("%{public}s", "GetAudioManagerFuncs FAIL!\n"); + HDF_LOGE("%{public}s: GetAudioManagerFuncs FAIL!", __func__); return HDF_FAILURE; } return HDF_SUCCESS; @@ -37,28 +43,40 @@ int32_t HdiServiceGetFuncs() static int32_t HdiServiceGetAllAdapter(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { - HDF_LOGE("%{public}s", "enter to HdiServiceGetAllAdapter "); + HDF_LOGE("%{public}s: enter to", __func__); if (client == NULL || data == NULL || reply == NULL) { return HDF_FAILURE; } + static bool getAdaptersFlag = true; struct AudioAdapterDescriptor *descs = NULL; struct AudioManager *manager = g_serverManager; int32_t size = 0; + if (manager == NULL) { - HDF_LOGE("%{public}s", "Manager is NULL"); + HDF_LOGE("%{public}s: Manager is NULL", __func__); return HDF_FAILURE; } int32_t ret = manager->GetAllAdapters(manager, &descs, &size); if (ret < 0) { - HDF_LOGE("%{public}s", "g_manager->GetAllAdapters error"); + HDF_LOGE("%{public}s: g_manager->GetAllAdapters error", __func__); return HDF_FAILURE; } if (size > MAX_AUDIO_ADAPTER_NUM_SERVER || size == 0 || descs == NULL || ret < 0) { - HDF_LOGE("%{public}s", "size or g_descs is error"); + HDF_LOGE("%{public}s: size or g_descs is error", __func__); return HDF_ERR_NOT_SUPPORT; } g_descs = descs; - HDF_LOGE("%{public}s", "GetAllAdapters out"); + if (getAdaptersFlag == true) { // Initialize only once + ret = AdaptersServerManageInit(descs, size); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: AdapterServerManageInit fail", __func__); + + return ret; + } + getAdaptersFlag = false; + } + HDF_LOGE("%{public}s: out", __func__); + return HDF_SUCCESS; } @@ -70,18 +88,24 @@ int SwitchAdapter(struct AudioAdapterDescriptor *descs, const char *adapterNameC } for (int index = 0; index < size; index++) { struct AudioAdapterDescriptor *desc = &descs[index]; + if (desc == NULL) { + continue; + } + if (desc->adapterName == NULL) { + return HDF_FAILURE; + } if (strcmp(desc->adapterName, adapterNameCase)) { continue; } - for (uint32_t port = 0; ((desc != NULL) && (port < desc->portNum)); port++) { + for (uint32_t port = 0; port < desc->portNum; port++) { if (desc->ports[port].dir == portFlag) { *renderPort = desc->ports[port]; - HDF_LOGE("%{public}s,%{public}d", "SwitchAdapter success!", portFlag); + HDF_LOGE("%{public}s: success!,%{public}d", __func__, portFlag); return index; } } } - HDF_LOGE("%{public}s", "SwitchAdapter out!"); + HDF_LOGE("%{public}s: out!", __func__); return HDF_FAILURE; } @@ -95,9 +119,9 @@ static int32_t HdiServiceLoadAdapter(struct HdfDeviceIoClient *client, struct Hd struct AudioAdapter *adapter = NULL; struct AudioPort renderPort; const char *adapterName = NULL; - uint32_t tempDir; + uint32_t tempDir = 0; if ((adapterName = HdfSbufReadString(data)) == NULL) { - HDF_LOGE("%{public}s", "adapterNameCase Is NULL"); + HDF_LOGE("%{public}s: adapterNameCase Is NULL", __func__); return HDF_FAILURE; } int32_t ret = AudioAdapterCheckListExist(adapterName); @@ -105,20 +129,21 @@ static int32_t HdiServiceLoadAdapter(struct HdfDeviceIoClient *client, struct Hd return HDF_FAILURE; } if (ret == HDF_SUCCESS) { - HDF_LOGE("%{public}s", "HdiServiceLoadAdapter: adapte already exist !"); + HDF_LOGE("%{public}s: adapte already exist !", __func__); return HDF_SUCCESS; } if (!HdfSbufReadUint32(data, &tempDir)) { - HDF_LOGE("%{public}s", "HdiServiceLoadAdapter: adapter need Load!"); + HDF_LOGE("%{public}s: adapter need Load!", __func__); return HDF_FAILURE; } enum AudioPortDirection port = (enum AudioPortDirection)tempDir; struct AudioManager *manager = g_serverManager; if (adapterName == NULL || manager == NULL || g_descs == NULL) { - HDF_LOGE("%{public}s", "Point is NULL!"); + HDF_LOGE("%{public}s: Point is NULL!", __func__); return HDF_FAILURE; } - int index = SwitchAdapter(g_descs, adapterName, port, &renderPort, MAX_AUDIO_ADAPTER_NUM_SERVER); + int index = SwitchAdapter(g_descs, adapterName, port, + &renderPort, ServerManageGetAdapterNum()); if (index < 0) { return HDF_ERR_NOT_SUPPORT; } @@ -128,11 +153,11 @@ static int32_t HdiServiceLoadAdapter(struct HdfDeviceIoClient *client, struct Hd return HDF_ERR_NOT_SUPPORT; } if (adapter == NULL) { - HDF_LOGE("%{public}s", "load audio device failed"); + HDF_LOGE("%{public}s: load audio device failed", __func__); return HDF_FAILURE; } if (AudioAdapterListAdd(adapterName, adapter)) { - HDF_LOGE("%{public}s", "AudioAdapterListAdd error!"); + HDF_LOGE("%{public}s: AudioAdapterListAdd error!", __func__); manager->UnloadAdapter(manager, adapter); return HDF_FAILURE; } @@ -141,22 +166,22 @@ static int32_t HdiServiceLoadAdapter(struct HdfDeviceIoClient *client, struct Hd static int32_t HdiServiceInitAllPorts(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { - HDF_LOGE("%{public}s", "HdiServiceInitAllPorts"); + HDF_LOGE("%{public}s: HdiServiceInitAllPorts", __func__); if (client == NULL || data == NULL || reply == NULL) { return HDF_FAILURE; } const char *adapterName = NULL; struct AudioAdapter *adapter = NULL; if ((adapterName = HdfSbufReadString(data)) == NULL) { - HDF_LOGE("%{public}s", "adapterNameCase Is NULL"); + HDF_LOGE("%{public}s: adapterNameCase Is NULL", __func__); return HDF_FAILURE; } if (AudioAdapterListGetAdapter(adapterName, &adapter)) { - HDF_LOGE("%{public}s", "AudioAdapterListGetAdapter fail"); + HDF_LOGE("%{public}s: AudioAdapterListGetAdapter fail", __func__); return HDF_FAILURE; } if (adapter->InitAllPorts(adapter)) { - HDF_LOGE("%{public}s", "InitAllPorts fail"); + HDF_LOGE("%{public}s: InitAllPorts fail", __func__); return HDF_FAILURE; } return HDF_SUCCESS; @@ -172,22 +197,22 @@ static int32_t HdiServiceUnloadAdapter(struct HdfDeviceIoClient *client, struct int ret; struct AudioManager *manager = g_serverManager; if (manager == NULL) { - HDF_LOGE("%{public}s", "Point is NULL!"); + HDF_LOGE("%{public}s: Point is NULL!", __func__); return HDF_FAILURE; } if ((adapterName = HdfSbufReadString(data)) == NULL) { - HDF_LOGE("%{public}s", "adapterNameCase Is NULL"); + HDF_LOGE("%{public}s: adapterNameCase Is NULL", __func__); return HDF_FAILURE; } ret = AudioAdapterListDestory(adapterName, &adapter); if (ret == HDF_FAILURE) { - HDF_LOGE("%{public}s", "Other dev Use the adapter"); + HDF_LOGE("%{public}s: Other dev Use the adapter", __func__); return HDF_SUCCESS; } else if (ret == HDF_ERR_INVALID_PARAM) { - HDF_LOGE("%{public}s", "HdiServiceUnloadAdapter: param invalid!"); + HDF_LOGE("%{public}s: param invalid!", __func__); return HDF_FAILURE; } else { - HDF_LOGE("%{public}s", "HdiServiceUnloadAdapter: Unload the adapter!"); + HDF_LOGE("%{public}s: Unload the adapter!", __func__); } if (adapter == NULL) { return HDF_FAILURE; @@ -199,7 +224,7 @@ static int32_t HdiServiceUnloadAdapter(struct HdfDeviceIoClient *client, struct static int32_t HdiServiceGetPortCapability(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { - HDF_LOGE("%{public}s", "HdiServiceGetPortCapability in!"); + HDF_LOGE("%{public}s: enter", __func__); if (client == NULL || data == NULL || reply == NULL) { return HDF_FAILURE; } @@ -209,7 +234,7 @@ static int32_t HdiServiceGetPortCapability(struct HdfDeviceIoClient *client, const char *adapterName = NULL; uint32_t tempDir; if ((adapterName = HdfSbufReadString(data)) == NULL) { - HDF_LOGE("%{public}s", "adapterNameCase Is NULL"); + HDF_LOGE("%{public}s: adapterNameCase Is NULL", __func__); return HDF_FAILURE; } if (!HdfSbufReadUint32(data, &tempDir)) { @@ -224,16 +249,16 @@ static int32_t HdiServiceGetPortCapability(struct HdfDeviceIoClient *client, } HDF_LOGE("port.portName = %{public}s", port.portName); if (AudioAdapterListGetAdapter(adapterName, &adapter)) { - HDF_LOGE("%{public}s", "AudioAdapterListGetAdapter fail"); + HDF_LOGE("%{public}s: AudioAdapterListGetAdapter fail", __func__); return HDF_FAILURE; } if (adapter == NULL) { - HDF_LOGE("%{public}s", "HdiServiceCreatRender adapter is NULL!"); + HDF_LOGE("%{public}s: HdiServiceCreatRender adapter is NULL!", __func__); return HDF_FAILURE; } int32_t ret = adapter->GetPortCapability(adapter, &port, &capability); if (ret < 0) { - HDF_LOGE("%{public}s", "HdiServiceGetPortCapability ret failed"); + HDF_LOGE("%{public}s: ret failed", __func__); return HDF_FAILURE; } return HDF_SUCCESS; @@ -242,7 +267,7 @@ static int32_t HdiServiceGetPortCapability(struct HdfDeviceIoClient *client, static int32_t HdiServiceSetPassthroughMode(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { - HDF_LOGE("%{public}s", "HdiServiceSetPassthroughMode in"); + HDF_LOGE("%{public}s: enter", __func__); if (client == NULL || data == NULL || reply == NULL) { return HDF_FAILURE; } @@ -251,7 +276,7 @@ static int32_t HdiServiceSetPassthroughMode(struct HdfDeviceIoClient *client, struct AudioAdapter *adapter = NULL; const char *adapterName = NULL; if ((adapterName = HdfSbufReadString(data)) == NULL) { - HDF_LOGE("%{public}s", "adapterNameCase Is NULL"); + HDF_LOGE("%{public}s: adapterNameCase Is NULL", __func__); return HDF_FAILURE; } uint32_t tempDir; @@ -273,13 +298,13 @@ static int32_t HdiServiceSetPassthroughMode(struct HdfDeviceIoClient *client, return HDF_FAILURE; } mode = (enum AudioPortPassthroughMode)tempMode; - HDF_LOGE("%{public}s mode = %{public}d", "SetPassthroughMode ready in", mode); + HDF_LOGE("%{public}s: ready in,mode = %{public}d", __func__, mode); if (AudioAdapterListGetAdapter(adapterName, &adapter)) { - HDF_LOGE("%{public}s", "AudioAdapterListGetAdapter fail"); + HDF_LOGE("%{public}s: AudioAdapterListGetAdapter fail", __func__); return HDF_FAILURE; } if (adapter == NULL) { - HDF_LOGE("%{public}s", "HdiServiceCreatRender adapter is NULL!"); + HDF_LOGE("%{public}s: HdiServiceCreatRender adapter is NULL!", __func__); return HDF_FAILURE; } int ret = adapter->SetPassthroughMode(adapter, &port, mode); @@ -291,12 +316,12 @@ static int32_t HdiServiceGetPassthroughMode(struct HdfDeviceIoClient *client, if (client == NULL || data == NULL || reply == NULL) { return HDF_FAILURE; } - struct AudioPort port; - enum AudioPortPassthroughMode mode; + enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_AUTO; struct AudioAdapter *adapter = NULL; const char *adapterName = NULL; + struct AudioPort port; if ((adapterName = HdfSbufReadString(data)) == NULL) { - HDF_LOGE("%{public}s", "adapterNameCase Is NULL"); + HDF_LOGE("%{public}s: adapterNameCase Is NULL", __func__); return HDF_FAILURE; } uint32_t tempDir = port.dir; @@ -312,16 +337,16 @@ static int32_t HdiServiceGetPassthroughMode(struct HdfDeviceIoClient *client, return HDF_FAILURE; } if (AudioAdapterListGetAdapter(adapterName, &adapter)) { - HDF_LOGE("%{public}s", "AudioAdapterListGetAdapter fail"); + HDF_LOGE("%{public}s: AudioAdapterListGetAdapter fail", __func__); return HDF_FAILURE; } if (adapter == NULL) { - HDF_LOGE("%{public}s", "adapter is NULL!"); + HDF_LOGE("%{public}s: adapter is NULL!", __func__); return HDF_FAILURE; } int ret = adapter->GetPassthroughMode(adapter, &port, &mode); if (ret < 0) { - HDF_LOGE("%{public}s", "GetPassthroughMode ret failed"); + HDF_LOGE("%{public}s: GetPassthroughMode ret failed", __func__); return HDF_FAILURE; } uint32_t tempMode = (uint32_t)mode; @@ -369,6 +394,14 @@ struct HdiServiceDispatchCmdHandleList g_hdiServiceDispatchCmdHandleList[] = { {AUDIO_HDI_RENDER_SET_SPEED, HdiServiceRenderSetSpeed}, {AUDIO_HDI_RENDER_SET_CHANNEL_MODE, HdiServiceRenderSetChannelMode}, {AUDIO_HDI_RENDER_GET_CHANNEL_MODE, HdiServiceRenderGetChannelMode}, + {AUDIO_HDI_RENDER_SET_EXTRA_PARAMS, HdiServiceRenderSetExtraParams}, + {AUDIO_HDI_RENDER_GET_EXTRA_PARAMS, HdiServiceRenderGetExtraParams}, + {AUDIO_HDI_RENDER_REQ_MMAP_BUFFER, HdiServiceRenderReqMmapBuffer}, + {AUDIO_HDI_RENDER_GET_MMAP_POSITION, HdiServiceRenderGetMmapPosition}, + {AUDIO_HDI_RENDER_TURN_STAND_BY_MODE, HdiServiceRenderTurnStandbyMode}, + {AUDIO_HDI_RENDER_DEV_DUMP, HdiServiceRenderDevDump}, + {AUDIO_HDI_RENDER_REG_CALLBACK, HdiServiceRenderRegCallback}, + {AUDIO_HDI_RENDER_DRAIN_BUFFER, HdiServiceRenderDrainBuffer}, }; static struct HdiServiceDispatchCmdHandleList g_hdiServiceDispatchCmdHandleCapList[] = { @@ -395,6 +428,12 @@ static struct HdiServiceDispatchCmdHandleList g_hdiServiceDispatchCmdHandleCapLi {AUDIO_HDI_CAPTURE_SET_GAIN, HdiServiceCaptureSetGain}, {AUDIO_HDI_CAPTURE_CAPTURE_FRAME, HdiServiceCaptureCaptureFrame}, {AUDIO_HDI_CAPTURE_GET_CAPTURE_POSITION, HdiServiceCaptureGetCapturePosition}, + {AUDIO_HDI_CAPTURE_SET_EXTRA_PARAMS, HdiServiceCaptureSetExtraParams}, + {AUDIO_HDI_CAPTURE_GET_EXTRA_PARAMS, HdiServiceCaptureGetExtraParams}, + {AUDIO_HDI_CAPTURE_REQ_MMAP_BUFFER, HdiServiceCaptureReqMmapBuffer}, + {AUDIO_HDI_CAPTURE_GET_MMAP_POSITION, HdiServiceCaptureGetMmapPosition}, + {AUDIO_HDI_CAPTURE_TURN_STAND_BY_MODE, HdiServiceCaptureTurnStandbyMode}, + {AUDIO_HDI_CAPTURE_DEV_DUMP, HdiServiceCaptureDevDump}, }; static int32_t HdiServiceDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, @@ -402,15 +441,15 @@ static int32_t HdiServiceDispatch(struct HdfDeviceIoClient *client, int cmdId, s { unsigned int i; if (client == NULL || data == NULL || reply == NULL) { - HDF_LOGE("%{public}s", "ControlDispatch: input para is NULL."); + HDF_LOGE("%{public}s: ControlDispatch: input para is NULL.", __func__); return HDF_FAILURE; } HDF_LOGE("ControlDispatch: valid cmdId = %{public}d", cmdId); - if (cmdId > AUDIO_HDI_CAPTURE_GET_CAPTURE_POSITION || cmdId < 0) { + if (cmdId > AUDIO_HDI_CAPTURE_DEV_DUMP || cmdId < 0) { HDF_LOGE("ControlDispatch: invalid cmdId = %{public}d", cmdId); return HDF_FAILURE; - } else if (cmdId <= AUDIO_HDI_RENDER_GET_CHANNEL_MODE) { + } else if (cmdId <= AUDIO_HDI_RENDER_DRAIN_BUFFER) { for (i = 0; i < sizeof(g_hdiServiceDispatchCmdHandleList) / sizeof(g_hdiServiceDispatchCmdHandleList[0]); ++i) { if ((cmdId == (int)(g_hdiServiceDispatchCmdHandleList[i].cmd)) && @@ -433,8 +472,11 @@ static int32_t HdiServiceDispatch(struct HdfDeviceIoClient *client, int cmdId, s void AudioHdiServerRelease(struct HdfDeviceObject *deviceObject) { LOG_FUN_INFO(); + /* g_renderAndCaptureManage release */ + AdaptersServerManageInfomationRecycle(); + if (deviceObject == NULL) { - HDF_LOGE("deviceObject is null!"); + HDF_LOGE("%{public}s: deviceObject is null!", __func__); return; } deviceObject->service = NULL; @@ -445,7 +487,7 @@ int AudioHdiServerBind(struct HdfDeviceObject *deviceObject) { LOG_FUN_INFO(); if (deviceObject == NULL) { - HDF_LOGE("deviceObject is null!"); + HDF_LOGE("%{public}s: deviceObject is null!", __func__); return HDF_FAILURE; } static struct IDeviceIoService hdiService = { @@ -464,7 +506,7 @@ int AudioHdiServerInit(struct HdfDeviceObject *deviceObject) { LOG_FUN_INFO(); if (deviceObject == NULL) { - HDF_LOGE("deviceObject is null!"); + HDF_LOGE("%{public}s: deviceObject is null!", __func__); return HDF_FAILURE; } return HDF_SUCCESS; diff --git a/audio/hal/hdi_binder/server/src/hdf_audio_server_capture.c b/audio/hal/hdi_binder/server/src/hdf_audio_server_capture.c index 8b24ebeba2..5279e806ca 100755 --- a/audio/hal/hdi_binder/server/src/hdf_audio_server_capture.c +++ b/audio/hal/hdi_binder/server/src/hdf_audio_server_capture.c @@ -14,6 +14,7 @@ */ #include "hdf_audio_server_capture.h" +#include "hdf_audio_server_common.h" int32_t GetInitCaptureParaAttrs(struct HdfSBuf *data, struct AudioSampleAttributes *attrs) { @@ -22,37 +23,37 @@ int32_t GetInitCaptureParaAttrs(struct HdfSBuf *data, struct AudioSampleAttribut } uint32_t tempCapturePara = 0; if (!HdfSbufReadUint32(data, &tempCapturePara)) { - HDF_LOGE("%{public}s", "Capture read buf fail"); + HDF_LOGE("%{public}s: Capture read tempCapturePara fail", __func__); return HDF_FAILURE; } attrs->type = (enum AudioCategory)tempCapturePara; if (!HdfSbufReadUint32(data, &attrs->period)) { - HDF_LOGE("%{public}s", "Capture read buf fail"); + HDF_LOGE("%{public}s: Capture read period fail", __func__); return HDF_FAILURE; } if (!HdfSbufReadUint32(data, &attrs->frameSize)) { - HDF_LOGE("%{public}s", "Capture read buf fail"); + HDF_LOGE("%{public}s: Capture read frameSize fail", __func__); return HDF_FAILURE; } if (!HdfSbufReadUint32(data, &attrs->startThreshold)) { - HDF_LOGE("%{public}s", "Capture read buf fail"); + HDF_LOGE("%{public}s: Capture read startThreshold fail", __func__); return HDF_FAILURE; } if (!HdfSbufReadUint32(data, &attrs->stopThreshold)) { - HDF_LOGE("%{public}s", "Capture read buf fail"); + HDF_LOGE("%{public}s: Capture read stopThreshold fail", __func__); return HDF_FAILURE; } if (!HdfSbufReadUint32(data, &attrs->silenceThreshold)) { - HDF_LOGE("%{public}s", "Capture read buf fail"); + HDF_LOGE("%{public}s: Capture read silenceThreshold fail", __func__); return HDF_FAILURE; } if (!HdfSbufReadUint32(data, &tempCapturePara)) { - HDF_LOGE("%{public}s", "Failed to Get Speed sBuf!"); + HDF_LOGE("%{public}s: Failed to Get Speed sBuf!", __func__); return HDF_FAILURE; } attrs->isBigEndian = (bool)tempCapturePara; if (!HdfSbufReadUint32(data, &tempCapturePara)) { - HDF_LOGE("%{public}s", "Failed to Get Speed sBuf!"); + HDF_LOGE("%{public}s: Failed to Get Speed sBuf!", __func__); return HDF_FAILURE; } attrs->isSignedData = (bool)tempCapturePara; @@ -67,20 +68,20 @@ int32_t GetInitCapturePara(struct HdfSBuf *data, struct AudioDeviceDescriptor *d } uint32_t tempCapturePara = 0; if (!HdfSbufReadUint32(data, &tempCapturePara)) { - HDF_LOGE("%{public}s", "Failed to Get Speed sBuf!"); + HDF_LOGE("%{public}s: Failed to Get Speed sBuf!", __func__); return HDF_FAILURE; } attrs->format = (enum AudioFormat)tempCapturePara; if (!HdfSbufReadUint32(data, &attrs->channelCount)) { - HDF_LOGE("%{public}s", " read buf fail"); + HDF_LOGE("%{public}s: read channelCount fail", __func__); return HDF_FAILURE; } if (!HdfSbufReadUint32(data, &attrs->sampleRate)) { - HDF_LOGE("%{public}s", " read buf fail"); + HDF_LOGE("%{public}s: read sampleRate fail", __func__); return HDF_FAILURE; } if (!HdfSbufReadUint32(data, &tempCapturePara)) { - HDF_LOGE("%{public}s", "Failed to Get Speed sBuf!"); + HDF_LOGE("%{public}s: Failed to Get Speed sBuf!", __func__); return HDF_FAILURE; } attrs->interleaved = (bool)tempCapturePara; @@ -88,11 +89,11 @@ int32_t GetInitCapturePara(struct HdfSBuf *data, struct AudioDeviceDescriptor *d return HDF_FAILURE; } if (!HdfSbufReadUint32(data, &devDesc->portId)) { - HDF_LOGE("%{public}s", " read buf fail"); + HDF_LOGE("%{public}s: read portId fail", __func__); return HDF_FAILURE; } if (!HdfSbufReadUint32(data, &tempCapturePara)) { - HDF_LOGE("%{public}s", " read buf fail"); + HDF_LOGE("%{public}s: read tempCapturePara fail", __func__); return HDF_FAILURE; } devDesc->pins = (enum AudioPortPin)tempCapturePara; @@ -110,42 +111,42 @@ int32_t HdiServiceCreatCapture(struct HdfDeviceIoClient *client, struct HdfSBuf struct AudioSampleAttributes attrs; struct AudioCapture *capture = NULL; const char *adapterName = NULL; - uint32_t capturePid; + uint32_t capturePid = 0; if ((adapterName = HdfSbufReadString(data)) == NULL) { - HDF_LOGE("%{public}s", "adapterNameCase Is NULL"); + HDF_LOGE("%{public}s: adapterNameCase Is NULL", __func__); return HDF_FAILURE; } if (!HdfSbufReadUint32(data, &capturePid)) { - HDF_LOGE("%{public}s", " read buf fail"); + HDF_LOGE("%{public}s: read capturePid fail", __func__); return HDF_FAILURE; } - HDF_LOGE("%{public}s, capturePid = %{public}u", "HdiServiceCreatCapture:", capturePid); + HDF_LOGE("%{public}s, capturePid = %{public}u", __func__, capturePid); int32_t ret = GetInitCapturePara(data, &devDesc, &attrs); if (ret < 0) { - HDF_LOGE("%{public}s", "read Render param failure!"); + HDF_LOGE("%{public}s: read Render param failure!", __func__); return HDF_FAILURE; } if (AudioAdapterListGetAdapter(adapterName, &adapter)) { - HDF_LOGE("%{public}s", "AudioAdapterListGetAdapter fail"); + HDF_LOGE("%{public}s: AudioAdapterListGetAdapter fail", __func__); return HDF_FAILURE; } if (adapter == NULL) { - HDF_LOGE("%{public}s", "HdiServiceCreatCapture adapter is NULL!"); + HDF_LOGE("%{public}s: adapter is NULL!", __func__); return HDF_FAILURE; } const int32_t priority = attrs.type; ret = AudioCreatCaptureCheck(adapterName, priority); if (ret < 0) { - HDF_LOGE("%{public}s", "AudioCreatRenderCheck: Capture is working can not replace!"); + HDF_LOGE("%{public}s: AudioCreatRenderCheck: Capture is working can not replace!", __func__); return ret; } ret = adapter->CreateCapture(adapter, &devDesc, &attrs, &capture); if (capture == NULL || ret < 0) { - HDF_LOGE("%{public}s", "Failed to CreateCapture "); + HDF_LOGE("%{public}s: Failed to CreateCapture", __func__); return HDF_FAILURE; } if (AudioAddCaptureInfoInAdapter(adapterName, capture, adapter, priority, capturePid)) { - HDF_LOGE("%{public}s", "AudioAddRenderInfoInAdapter"); + HDF_LOGE("%{public}s: AudioAddRenderInfoInAdapter", __func__); adapter->DestroyCapture(adapter, capture); return HDF_FAILURE; } @@ -160,23 +161,23 @@ int32_t HdiServiceCaptureDestory(struct HdfDeviceIoClient *client, struct HdfSBu struct AudioAdapter *adapter = NULL; struct AudioCapture *capture = NULL; const char *adapterName = NULL; - uint32_t pid; + uint32_t pid = 0; if (HdiServiceRenderCaptureReadData(data, &adapterName, &pid) < 0) { return HDF_FAILURE; } int32_t ret = AudioAdapterListGetCapture(adapterName, &capture, pid); if (ret < 0) { - HDF_LOGE("%{public}s", "AudioAdapterListGetAdapter fail"); + HDF_LOGE("%{public}s: AudioAdapterListGetAdapter fail", __func__); return ret; } ret = AudioAdapterListGetAdapterCapture(adapterName, &adapter, &capture); if (ret < 0) { - HDF_LOGE("%{public}s", "AudioAdapterListGetAdapter fail"); + HDF_LOGE("%{public}s: AudioAdapterListGetAdapter fail", __func__); return ret; } ret = adapter->DestroyCapture(adapter, capture); if (ret < 0) { - HDF_LOGE("%{public}s", "DestroyCapture failed!"); + HDF_LOGE("%{public}s: DestroyCapture failed!", __func__); return ret; } if (AudioDestroyCaptureInfoInAdapter(adapterName)) { @@ -296,6 +297,7 @@ int32_t HdiServiceCaptureSetSampleAttr(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { if (client == NULL || data == NULL || reply == NULL) { + HDF_LOGE("%{public}s: The pointer is null!", __func__); return HDF_FAILURE; } int ret; @@ -364,7 +366,6 @@ int32_t HdiServiceCaptureCheckSceneCapability(struct HdfDeviceIoClient *client, struct AudioSceneDescriptor scene; bool supported = false; struct AudioCapture *capture = NULL; - uint32_t tempPins = 0; int ret = AudioAdapterListCheckAndGetCapture(&capture, data); if (ret < 0) { return ret; @@ -372,10 +373,11 @@ int32_t HdiServiceCaptureCheckSceneCapability(struct HdfDeviceIoClient *client, if (!HdfSbufReadUint32(data, &scene.scene.id)) { return HDF_FAILURE; } - if (!HdfSbufReadUint32(data, &tempPins)) { + uint32_t interimPins = 0; + if (!HdfSbufReadUint32(data, &interimPins)) { return HDF_FAILURE; } - scene.desc.pins = (enum AudioPortPin) tempPins; + scene.desc.pins = (enum AudioPortPin) interimPins; ret = capture->scene.CheckSceneCapability((AudioHandle)capture, &scene, &supported); if (ret < 0) { return ret; @@ -395,6 +397,7 @@ int32_t HdiServiceCaptureSelectScene(struct HdfDeviceIoClient *client, } struct AudioSceneDescriptor scene; struct AudioCapture *capture = NULL; + uint32_t tempPins = 0; int ret = AudioAdapterListCheckAndGetCapture(&capture, data); if (ret < 0) { return ret; @@ -402,7 +405,6 @@ int32_t HdiServiceCaptureSelectScene(struct HdfDeviceIoClient *client, if (!HdfSbufReadUint32(data, &scene.scene.id)) { return HDF_FAILURE; } - uint32_t tempPins = 0; if (!HdfSbufReadUint32(data, &tempPins)) { return HDF_FAILURE; } @@ -416,7 +418,7 @@ int32_t HdiServiceCaptureGetMute(struct HdfDeviceIoClient *client, if (client == NULL || data == NULL || reply == NULL) { return HDF_FAILURE; } - int ret; + int32_t ret; bool mute = false; struct AudioCapture *capture = NULL; ret = AudioAdapterListCheckAndGetCapture(&capture, data); @@ -460,7 +462,7 @@ int32_t HdiServiceCaptureSetVolume(struct HdfDeviceIoClient *client, if (client == NULL || data == NULL || reply == NULL) { return HDF_FAILURE; } - uint32_t volume; + uint32_t volume = 0; struct AudioCapture *capture = NULL; int ret = AudioAdapterListCheckAndGetCapture(&capture, data); if (ret < 0) { @@ -554,7 +556,7 @@ int32_t HdiServiceCaptureSetGain(struct HdfDeviceIoClient *client, if (client == NULL || data == NULL || reply == NULL) { return HDF_FAILURE; } - uint32_t gain; + uint32_t gain = 0; struct AudioCapture *capture = NULL; int ret = AudioAdapterListCheckAndGetCapture(&capture, data); if (ret < 0) { @@ -572,24 +574,24 @@ int32_t HdiServiceCaptureCaptureFrame(struct HdfDeviceIoClient *client, if (client == NULL || data == NULL || reply == NULL) { return HDF_FAILURE; } - HDF_LOGI("%{public}s", "HdiServiceCaptureCaptureFrame entry!"); + HDF_LOGI("%{public}s: enter", __func__); char *frame = NULL; uint64_t requestBytes, replyBytes; struct AudioCapture *capture = NULL; const char *adapterName = NULL; uint32_t pid; if (HdiServiceRenderCaptureReadData(data, &adapterName, &pid) < 0) { - HDF_LOGE("%{public}s", "HdiServiceRenderRenderFrame:HdiServiceRenderCaptureReadData fail!"); + HDF_LOGE("%{public}s: HdiServiceRenderRenderFrame:HdiServiceRenderCaptureReadData fail!", __func__); return HDF_FAILURE; } int32_t ret = AudioAdapterListGetCapture(adapterName, &capture, pid); if (ret < 0) { - HDF_LOGE("%{public}s", "HdiServiceCaptureCaptureFrame:AudioAdapterListGetRender fail"); + HDF_LOGE("%{public}s: AudioAdapterListGetRender fail", __func__); return ret; } ret = AudioGetCaptureStatus(adapterName); if (ret < 0) { - HDF_LOGE("%{public}s", "HdiServiceCaptureCaptureFrame:AudioGetCaptureStatus fail"); + HDF_LOGE("%{public}s: AudioGetCaptureStatus fail", __func__); return ret; } if (!HdfSbufReadUint64(data, &requestBytes)) { @@ -624,25 +626,180 @@ int32_t HdiServiceCaptureGetCapturePosition(struct HdfDeviceIoClient *client, if (client == NULL || data == NULL || reply == NULL) { return HDF_FAILURE; } - uint64_t frames; struct AudioTimeStamp time; + uint64_t frames; struct AudioCapture *capture = NULL; - int ret = AudioAdapterListCheckAndGetCapture(&capture, data); + int32_t ret = AudioAdapterListCheckAndGetCapture(&capture, data); if (ret < 0) { return ret; } ret = capture->GetCapturePosition((AudioHandle)capture, &frames, &time); if (ret < 0) { + HDF_LOGE("%{public}s: GetCapturePosition fail", __func__); return ret; } - if (!HdfSbufWriteUint64(reply, frames)) { + if (HdiServicePositionWrite(reply, frames, time) < 0) { return HDF_FAILURE; } - if (!HdfSbufWriteUint64(reply, time.tvSec)) { + return HDF_SUCCESS; +} + +int32_t HdiServiceCaptureSetExtraParams(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + HDF_LOGE("%{public}s: enter", __func__); + if (client == NULL || data == NULL || reply == NULL) { return HDF_FAILURE; } - if (!HdfSbufWriteUint64(reply, time.tvNSec)) { + struct AudioCapture *capture = NULL; + int ret = AudioAdapterListCheckAndGetCapture(&capture, data); + if (ret < 0) { + return ret; + } + const char *keyValueList = NULL; + if ((keyValueList = HdfSbufReadString(data)) == NULL) { + HDF_LOGE("%{public}s: keyValueList Is NULL", __func__); return HDF_FAILURE; } + return capture->attr.SetExtraParams((AudioHandle)capture, keyValueList); +} + +int32_t HdiServiceCaptureGetExtraParams(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + HDF_LOGE("%{public}s: enter", __func__); + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + struct AudioCapture *capture = NULL; + int ret = AudioAdapterListCheckAndGetCapture(&capture, data); + if (ret < 0) { + return ret; + } + int32_t listLenth; + if (!HdfSbufReadInt32(data, &listLenth)) { + return HDF_FAILURE; + } + if (listLenth <= 0 || listLenth > STR_MAX - 1) { + return HDF_FAILURE; + } + char keyValueList[STR_MAX] = { 0 }; + ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueList, listLenth); + if (ret < 0) { + return ret; + } + char *keyList = keyValueList; + if (!HdfSbufWriteString(reply, keyList)) { + return HDF_FAILURE; + } + HDF_LOGE("%{public}s: out", __func__); return HDF_SUCCESS; } + +int32_t HdiServiceCaptureReqMmapBuffer(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + HDF_LOGE("%{public}s: enter", __func__); + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + struct AudioCapture *capture = NULL; + int ret = AudioAdapterListCheckAndGetCapture(&capture, data); + if (ret < 0) { + return ret; + } + + struct AudioMmapBufferDescripter desc; + int32_t reqSize = 0; + if (!HdfSbufReadInt32(data, &reqSize)) { + return HDF_FAILURE; + } + uint64_t memAddr = 0; + if (!HdfSbufReadUint64(data, &memAddr)) { + HDF_LOGE("%{public}s: memAddr Is NULL", __func__); + return HDF_FAILURE; + } + desc.memoryAddress = (void *)memAddr; + if (!HdfSbufReadInt32(data, &desc.memoryFd)) { + return HDF_FAILURE; + } + if (!HdfSbufReadInt32(data, &desc.totalBufferFrames)) { + return HDF_FAILURE; + } + if (!HdfSbufReadInt32(data, &desc.transferFrameSize)) { + return HDF_FAILURE; + } + if (!HdfSbufReadInt32(data, &desc.isShareable)) { + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &desc.offset)) { + return HDF_FAILURE; + } + return capture->attr.ReqMmapBuffer((AudioHandle)capture, reqSize, &desc); +} + +int32_t HdiServiceCaptureGetMmapPosition(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + HDF_LOGE("%{public}s: enter", __func__); + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + uint64_t frames; + struct AudioTimeStamp time; + struct AudioCapture *capture = NULL; + int32_t ret = AudioAdapterListCheckAndGetCapture(&capture, data); + if (ret < 0) { + return ret; + } + + ret = capture->GetCapturePosition((AudioHandle)capture, &frames, &time); + if (ret < 0) { + return ret; + } + if (HdiServicePositionWrite(reply, frames, time) < 0) { + return HDF_FAILURE; + } + HDF_LOGE("%{public}s: out", __func__); + return HDF_SUCCESS; +} + +int32_t HdiServiceCaptureTurnStandbyMode(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + HDF_LOGE("%{public}s: The pointer is null", __func__); + return HDF_FAILURE; + } + struct AudioCapture *capture = NULL; + int ret = AudioAdapterListCheckAndGetCapture(&capture, data); + if (ret < 0) { + return ret; + } + return capture->control.Stop((AudioHandle)capture); +} + +int32_t HdiServiceCaptureDevDump(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + HDF_LOGE("%{public}s: parameter Is NULL", __func__); + return HDF_FAILURE; + } + struct AudioCapture *capture = NULL; + int ret = AudioAdapterListCheckAndGetCapture(&capture, data); + if (ret < 0) { + return ret; + } + + int32_t range = 0; + int32_t fd = 0; + if (!HdfSbufReadInt32(data, &range)) { + return HDF_FAILURE; + } + if (!HdfSbufReadInt32(data, &fd)) { + return HDF_FAILURE; + } + return capture->control.AudioDevDump((AudioHandle)capture, range, fd); +} + diff --git a/audio/hal/hdi_binder/server/src/hdf_audio_server_common.c b/audio/hal/hdi_binder/server/src/hdf_audio_server_common.c index 105157508c..bcc0053719 100755 --- a/audio/hal/hdi_binder/server/src/hdf_audio_server_common.c +++ b/audio/hal/hdi_binder/server/src/hdf_audio_server_common.c @@ -15,59 +15,127 @@ #include "hdf_audio_server_common.h" -static struct AudioInfoInAdapter g_renderAndCaptureManage[MAX_AUDIO_ADAPTER_NUM_SERVER] = { - { - .adapterName = "internal", - .adapter = NULL, - .adapterUserNum = 0, - .renderStatus = 0, - .renderPriority = -1, - .render = NULL, - .renderBusy = false, - .renderDestory = false, - .renderPid = 0, - .captureStatus = 0, - .capturePriority = -1, - .capture = NULL, - .captureBusy = false, - .captureDestory = false, - .capturePid = 0 - }, - { - .adapterName = "usb", - .adapter = NULL, - .adapterUserNum = 0, - .renderStatus = 0, - .renderPriority = -1, - .render = NULL, - .renderBusy = false, - .renderDestory = false, - .renderPid = 0, - .captureStatus = 0, - .capturePriority = -1, - .capture = NULL, - .captureBusy = false, - .captureDestory = false, - .capturePid = 0 - }, - { - .adapterName = "hdmi", - .adapter = NULL, - .adapterUserNum = 0, - .renderStatus = 0, - .renderPriority = -1, - .render = NULL, - .renderBusy = false, - .renderDestory = false, - .renderPid = 0, - .captureStatus = 0, - .capturePriority = -1, - .capture = NULL, - .captureBusy = false, - .captureDestory = false, - .capturePid = 0 - } -}; + +#define MANAGER_ADAPTER_NAME_LEN 32 + +int32_t g_serverAdapterNum = 0; +struct AudioInfoInAdapter *g_renderAndCaptureManage = NULL; + +static int32_t AdapterManageInit(struct AudioInfoInAdapter *adapterManage, + const char *adapterName) +{ + int32_t ret; + + if (adapterManage == NULL || adapterName == NULL) { + HDF_LOGE("%{public}s: Parameter error! ", __func__); + + return HDF_FAILURE; + } + + adapterManage->adapterName = (char *)calloc(1, MANAGER_ADAPTER_NAME_LEN); + if (adapterManage->adapterName == NULL) { + HDF_LOGE("%{public}s: calloc adapter name failed!", __func__); + + return HDF_FAILURE; + } + + ret = memcpy_s((void *)adapterManage->adapterName, MANAGER_ADAPTER_NAME_LEN, + adapterName, MANAGER_ADAPTER_NAME_LEN); + if (ret != EOK) { + HDF_LOGE("%{public}s: memcpy adapter name fail!", __func__); + AudioMemFree((void **)&adapterManage->adapterName); + + return HDF_FAILURE; + } + + adapterManage->adapter = NULL; + adapterManage->adapterUserNum = 0; + adapterManage->renderStatus = 0; + adapterManage->renderPriority = -1; + adapterManage->render = NULL; + adapterManage->renderBusy = false; + adapterManage->renderDestory = false; + adapterManage->renderPid = 0; + adapterManage->captureStatus = 0; + adapterManage->capturePriority = -1; + adapterManage->capture = NULL; + adapterManage->captureBusy = false; + adapterManage->captureDestory = false; + adapterManage->capturePid = 0; + + return HDF_SUCCESS; +} + +int32_t ServerManageGetAdapterNum(void) +{ + return ((g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum); +} + +struct AudioInfoInAdapter *ServerManageGetAdapters(void) +{ + return g_renderAndCaptureManage; +} + + +void AdaptersServerManageRelease( + struct AudioInfoInAdapter *adaptersManage, int32_t num) +{ + int32_t i; + + if (adaptersManage == NULL || num <= 0) { + HDF_LOGE("%{public}s: Parameter error! ", __func__); + + return; + } + + num = (num > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : num; + for (i = 0; i < num; i++) { + if (adaptersManage[i].adapterName != NULL) { + AudioMemFree((void **)&adaptersManage[i].adapterName); + } + } + AudioMemFree((void **)&adaptersManage); +} + +void AdaptersServerManageInfomationRecycle(void) +{ + AdaptersServerManageRelease(g_renderAndCaptureManage, g_serverAdapterNum); + g_renderAndCaptureManage = NULL; + g_serverAdapterNum = 0; +} + +int32_t AdaptersServerManageInit(struct AudioAdapterDescriptor *descs, int32_t num) +{ + int32_t i, ret; + struct AudioInfoInAdapter *adaptersManage = NULL; + + if (descs == NULL || num <= 0) { + HDF_LOGE("%{public}s: Parameter error! ", __func__); + + return HDF_FAILURE; + } + + num = (num > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : num; + adaptersManage = (struct AudioInfoInAdapter *)calloc(1, + num * sizeof(struct AudioInfoInAdapter)); + if (adaptersManage == NULL) { + HDF_LOGE("%{public}s: calloc adaptersManage failed! ", __func__); + + return HDF_FAILURE; + } + for (i = 0; i < num; i++) { + ret = AdapterManageInit(&adaptersManage[i], descs[i].adapterName); + if (ret != HDF_SUCCESS) { + AdaptersServerManageRelease(adaptersManage, num); + + return ret; + } + } + g_serverAdapterNum = num; + g_renderAndCaptureManage = adaptersManage; + + return HDF_SUCCESS; +} int32_t HdiServiceRenderCaptureReadData(struct HdfSBuf *data, const char **adapterName, uint32_t *pid) { @@ -75,11 +143,11 @@ int32_t HdiServiceRenderCaptureReadData(struct HdfSBuf *data, const char **adapt return HDF_FAILURE; } if ((*adapterName = HdfSbufReadString(data)) == NULL) { - HDF_LOGE("%{public}s", "adapterName Is NULL"); + HDF_LOGE("%{public}s: adapterName Is NULL ", __func__); return HDF_FAILURE; } if (!HdfSbufReadUint32(data, pid)) { - HDF_LOGE("%{public}s", " read buf fail"); + HDF_LOGE("%{public}s: read buf fail ", __func__); return HDF_FAILURE; } return HDF_SUCCESS; @@ -88,13 +156,22 @@ int32_t HdiServiceRenderCaptureReadData(struct HdfSBuf *data, const char **adapt int32_t AudioAdapterListGetAdapterCapture(const char *adapterName, struct AudioAdapter **adapter, struct AudioCapture **capture) { + int32_t i, num; + LOG_FUN_INFO(); if (adapterName == NULL || adapter == NULL || capture == NULL) { - HDF_LOGE("%{public}s", "The pointer is null"); + HDF_LOGE("%{public}s: The pointer is null ", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (g_renderAndCaptureManage == NULL) { return HDF_ERR_INVALID_PARAM; } - int i; - for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum; + for (i = 0; i < num; i++) { + if (g_renderAndCaptureManage[i].adapterName == NULL) { + HDF_LOGE("%{public}s: The pointer is null ", __func__); + return HDF_ERR_INVALID_PARAM; + } if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { *adapter = g_renderAndCaptureManage[i].adapter; *capture = g_renderAndCaptureManage[i].capture; @@ -106,12 +183,23 @@ int32_t AudioAdapterListGetAdapterCapture(const char *adapterName, int32_t AudioDestroyCaptureInfoInAdapter(const char *adapterName) { + int32_t i; + LOG_FUN_INFO(); if (adapterName == NULL) { + HDF_LOGE("%{public}s: Param Is NULL ", __func__); + return HDF_FAILURE; + } + + int32_t num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? + MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum; + if (g_renderAndCaptureManage == NULL) { return HDF_FAILURE; } - int i; - for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + for (i = 0; i < num; i++) { + if (g_renderAndCaptureManage[i].adapterName == NULL) { + return HDF_FAILURE; + } if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { g_renderAndCaptureManage[i].captureStatus = 0; g_renderAndCaptureManage[i].capturePriority = -1; @@ -120,7 +208,7 @@ int32_t AudioDestroyCaptureInfoInAdapter(const char *adapterName) return HDF_SUCCESS; } } - HDF_LOGE("%{public}s", "AudioDestroycaptureInfoInAdapter: Can not find Adapter!"); + HDF_LOGE("%{public}s: Can not find Adapter! ", __func__); return HDF_FAILURE; } @@ -128,14 +216,14 @@ int32_t AudioDestroyFormerCapture(struct AudioInfoInAdapter *captureManage) { LOG_FUN_INFO(); if (captureManage == NULL || captureManage->adapter == NULL || captureManage->capture == NULL) { - HDF_LOGE("%{public}s", "DestroyFormercapture: input para is NULL."); + HDF_LOGE("%{public}s: input para is NULL ", __func__); return HDF_FAILURE; } int count = 0; captureManage->captureDestory = true; while (captureManage->captureBusy) { if (count > 1000) { // Less than 1000 - HDF_LOGE("%{public}s, count = %{public}d", "AudioDestroyFormerRender", count); + HDF_LOGE("%{public}s: , count = %{public}d", __func__, count); captureManage->captureDestory = false; return HDF_ERR_DEVICE_BUSY; } @@ -157,35 +245,49 @@ int32_t AudioDestroyFormerCapture(struct AudioInfoInAdapter *captureManage) int32_t AudioJudgeCapturePriority(const int32_t priority, int which) { - if (which < 0 || which >= MAX_AUDIO_ADAPTER_NUM_SERVER) { - HDF_LOGE("%{public}s", "AudioJudgeCapturePriority invalid value!"); + int num; + if (g_renderAndCaptureManage == NULL) { + return HDF_FAILURE; + } + num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum; + if (which < 0 || which >= num) { + HDF_LOGE("%{public}s: invalid value! ", __func__); return HDF_FAILURE; } if (!(g_renderAndCaptureManage[which].captureStatus)) { return HDF_SUCCESS; - } else { + } else { if (g_renderAndCaptureManage[which].capturePriority <= priority) { return AudioDestroyFormerCapture(&g_renderAndCaptureManage[which]); - } else { + } else { return HDF_ERR_DEVICE_BUSY; - } } + } return HDF_FAILURE; } int32_t AudioCreatCaptureCheck(const char *adapterName, const int32_t priority) { + int32_t i, num; + LOG_FUN_INFO(); if (adapterName == NULL) { return HDF_FAILURE; } - int i; - for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + if (g_renderAndCaptureManage == NULL) { + return HDF_FAILURE; + } + num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? + MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum; + for (i = 0; i < num; i++) { + if (g_renderAndCaptureManage[i].adapterName == NULL) { + return HDF_FAILURE; + } if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { return AudioJudgeCapturePriority(priority, i); } } - HDF_LOGE("%{public}s", "AudioCreatCaptureCheck:Can not find Adapter!"); + HDF_LOGE("%{public}s: Can not find Adapter! ", __func__); return HDF_FAILURE; } @@ -195,23 +297,31 @@ int32_t AudioAddCaptureInfoInAdapter(const char *adapterName, const int32_t priority, uint32_t capturePid) { + int32_t i, num; + if (adapterName == NULL || adapter == NULL || capture == NULL) { - HDF_LOGE("%{public}s", "AudioAddcaptureInfoInAdapter: input para is NULL."); + HDF_LOGE("%{public}s: input para is NULL. ", __func__); return HDF_FAILURE; } - int i; - for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + if (g_renderAndCaptureManage == NULL) { + return HDF_FAILURE; + } + num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum; + for (i = 0; i < num; i++) { + if (g_renderAndCaptureManage[i].adapterName == NULL) { + return HDF_FAILURE; + } if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { g_renderAndCaptureManage[i].captureStatus = 1; g_renderAndCaptureManage[i].capturePriority = priority; g_renderAndCaptureManage[i].capture = capture; g_renderAndCaptureManage[i].capturePid = capturePid; - HDF_LOGE("%{public}s, (uint64_t)g_renderAndCaptureManage[i].capture = %{public}p", - "AudioAddcaptureInfoInAdapter: ", g_renderAndCaptureManage[i].capture); + HDF_LOGE("%{public}s: , (uint64_t)g_renderAndCaptureManage[i].capture = %{public}p", + __func__, g_renderAndCaptureManage[i].capture); return HDF_SUCCESS; } } - HDF_LOGE("%{public}s", "AudioAddcaptureInfoInAdapter: Can not find Adapter!"); + HDF_LOGE("%{public}s: Can not find Adapter! ", __func__); return HDF_FAILURE; } @@ -316,13 +426,23 @@ int32_t ReadAudioSapmleAttrbutes(struct HdfSBuf *data, struct AudioSampleAttribu int32_t AudioAdapterListGetAdapter(const char *adapterName, struct AudioAdapter **adapter) { + int32_t i, num; + LOG_FUN_INFO(); + if (g_renderAndCaptureManage == NULL) { + return HDF_ERR_INVALID_PARAM; + } if (adapterName == NULL || adapter == NULL) { - HDF_LOGE("%{public}s", "The pointer is null"); + HDF_LOGE("%{public}s: The pointer is null ", __func__); return HDF_ERR_INVALID_PARAM; } - int i; - for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + + num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? + MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum; + for (i = 0; i < num; i++) { + if (g_renderAndCaptureManage[i].adapterName == NULL) { + return HDF_ERR_INVALID_PARAM; + } if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { *adapter = g_renderAndCaptureManage[i].adapter; return HDF_SUCCESS; @@ -335,14 +455,14 @@ int32_t AudioDestroyFormerRender(struct AudioInfoInAdapter *renderManage) { LOG_FUN_INFO(); if (renderManage == NULL || renderManage->adapter == NULL || renderManage->render == NULL) { - HDF_LOGE("%{public}s", "DestroyFormerRender: input para is NULL."); + HDF_LOGE("%{public}s: input para is NULL. ", __func__); return HDF_FAILURE; } int count = 0; renderManage->renderDestory = true; while (renderManage->renderBusy) { if (count > 1000) { // Less than 1000 - HDF_LOGE("%{public}s, count = %{public}d", "AudioDestroyFormerRender", count); + HDF_LOGE("%{public}s: , count = %{public}d", __func__, count); renderManage->renderDestory = false; return HDF_FAILURE; } @@ -364,13 +484,19 @@ int32_t AudioDestroyFormerRender(struct AudioInfoInAdapter *renderManage) int32_t AudioJudgeRenderPriority(const int32_t priority, int which) { - if (which < 0 || which >= MAX_AUDIO_ADAPTER_NUM_SERVER) { - HDF_LOGE("%{public}s", "AudioJudgeRenderPriority invalid value!"); + int32_t num; + + num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum; + if (which < 0 || which >= num) { + HDF_LOGE("%{public}s: invalid value! ", __func__); + return HDF_FAILURE; + } + if (g_renderAndCaptureManage == NULL) { return HDF_FAILURE; } if (g_renderAndCaptureManage[which].renderPriority <= priority) { if (AudioDestroyFormerRender(&g_renderAndCaptureManage[which])) { - HDF_LOGE("%{public}s", "AudioDestroyFormerRender: Fail."); + HDF_LOGE("%{public}s: AudioDestroyFormerRender: Fail. ", __func__); return HDF_FAILURE; } return HDF_SUCCESS; @@ -382,12 +508,19 @@ int32_t AudioJudgeRenderPriority(const int32_t priority, int which) int32_t AudioCreatRenderCheck(const char *adapterName, const int32_t priority) { + int32_t i; + LOG_FUN_INFO(); - if (adapterName == NULL) { + if (adapterName == NULL || g_renderAndCaptureManage == NULL) { return HDF_FAILURE; } - int i; - for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + + int32_t num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? + MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum; + for (i = 0; i < num; i++) { + if (g_renderAndCaptureManage[i].adapterName == NULL) { + return HDF_FAILURE; + } if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { if (!(g_renderAndCaptureManage[i].renderStatus)) { return HDF_SUCCESS; @@ -396,7 +529,7 @@ int32_t AudioCreatRenderCheck(const char *adapterName, const int32_t priority) } } } - HDF_LOGE("%{public}s", "AudioCreatRenderCheck:Can not find Adapter!"); + HDF_LOGE("%{public}s: Can not find Adapter! ", __func__); return HDF_FAILURE; } @@ -406,12 +539,20 @@ int32_t AudioAddRenderInfoInAdapter(const char *adapterName, const int32_t priority, uint32_t renderPid) { + int32_t i, num; + if (adapterName == NULL || adapter == NULL || render == NULL) { - HDF_LOGE("%{public}s", "AudioAddRenderInfoInAdapter: input para is NULL."); + HDF_LOGE("%{public}s: input para is NULL. ", __func__); return HDF_FAILURE; } - int i; - for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + if (g_renderAndCaptureManage == NULL) { + return HDF_FAILURE; + } + num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum; + for (i = 0; i < num; i++) { + if (g_renderAndCaptureManage[i].adapterName == NULL) { + return HDF_FAILURE; + } if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { g_renderAndCaptureManage[i].renderStatus = 1; g_renderAndCaptureManage[i].renderPriority = priority; @@ -420,35 +561,51 @@ int32_t AudioAddRenderInfoInAdapter(const char *adapterName, return HDF_SUCCESS; } } - HDF_LOGE("%{public}s", "AudioAddRenderInfoInAdapter: Can not find Adapter!"); + HDF_LOGE("%{public}s: Can not find Adapter! ", __func__); return HDF_FAILURE; } void AudioSetRenderStatus(const char *adapterName, bool renderStatus) { + int32_t i, num; + if (g_renderAndCaptureManage == NULL) { + return; + } LOG_FUN_INFO(); if (adapterName == NULL) { + HDF_LOGE("%{public}s: adapterName is null ", __func__); return; } - int i; - for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + + num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum; + for (i = 0; i < num; i++) { + if (g_renderAndCaptureManage[i].adapterName == NULL) { + return; + } if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { g_renderAndCaptureManage[i].renderBusy = renderStatus; return; } } - HDF_LOGE("%{public}s", "AudioDestroyRenderInfoInAdapter: Can not find Adapter!"); + HDF_LOGE("%{public}s: AudioDestroyRenderInfoInAdapter: Can not find Adapter! ", __func__); return; } int32_t AudioGetRenderStatus(const char *adapterName) { + int32_t i; + int32_t num; LOG_FUN_INFO(); - if (adapterName == NULL) { + if (adapterName == NULL || g_renderAndCaptureManage == NULL) { return HDF_FAILURE; } - int i; - for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + + num = (g_serverAdapterNum > + MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum; + for (i = 0; i < num; i++) { + if (g_renderAndCaptureManage[i].adapterName == NULL) { + return HDF_FAILURE; + } if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { if (!g_renderAndCaptureManage[i].renderDestory) { return HDF_SUCCESS; @@ -458,18 +615,28 @@ int32_t AudioGetRenderStatus(const char *adapterName) } } } - HDF_LOGE("%{public}s", "AudioDestroyRenderInfoInAdapter: Can not find Adapter!"); + HDF_LOGE("%{public}s: AudioDestroyRenderInfoInAdapter: Can not find Adapter! ", __func__); return HDF_FAILURE; } int32_t AudioDestroyRenderInfoInAdapter(const char *adapterName) { + int32_t i, num; + LOG_FUN_INFO(); if (adapterName == NULL) { + HDF_LOGE("%{public}s: adapterName is null ", __func__); return HDF_FAILURE; } - int i; - for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + + num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum; + if (g_renderAndCaptureManage == NULL) { + return HDF_FAILURE; + } + for (i = 0; i < num; i++) { + if (g_renderAndCaptureManage[i].adapterName == NULL) { + return HDF_FAILURE; + } if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { g_renderAndCaptureManage[i].renderStatus = 0; g_renderAndCaptureManage[i].renderPriority = -1; @@ -478,23 +645,31 @@ int32_t AudioDestroyRenderInfoInAdapter(const char *adapterName) return HDF_SUCCESS; } } - HDF_LOGE("%{public}s", "AudioDestroyRenderInfoInAdapter: Can not find Adapter!"); + HDF_LOGE("%{public}s: Can not find Adapter! ", __func__); return HDF_FAILURE; } int32_t AudioAdapterListGetPid(const char *adapterName, uint32_t *pid) { + int32_t i, num; + LOG_FUN_INFO(); if (adapterName == NULL || pid == NULL) { - HDF_LOGE("%{public}s", "The pointer is null"); + HDF_LOGE("%{public}s: The pointer is null ", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (g_renderAndCaptureManage == NULL) { return HDF_ERR_INVALID_PARAM; } - int i; - for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum; + for (i = 0; i < num; i++) { + if (g_renderAndCaptureManage[i].adapterName == NULL) { + return HDF_ERR_INVALID_PARAM; + } if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { - HDF_LOGE("%{public}s i = %{public}d", "AudioAdapterListGetPid:", i); + HDF_LOGE("%{public}s: i = %{public}d", __func__, i); *pid = g_renderAndCaptureManage[i].renderPid; - HDF_LOGE("%{public}s pid = %{public}u", "AudioAdapterListGetPid:", *pid); + HDF_LOGE("%{public}s: pid = %{public}u", __func__, *pid); return HDF_SUCCESS; } } @@ -504,13 +679,22 @@ int32_t AudioAdapterListGetPid(const char *adapterName, uint32_t *pid) int32_t AudioAdapterListGetAdapterRender(const char *adapterName, struct AudioAdapter **adapter, struct AudioRender **render) { + int32_t i, num; + LOG_FUN_INFO(); + if (g_renderAndCaptureManage == NULL) { + return HDF_ERR_INVALID_PARAM; + } if (adapterName == NULL || adapter == NULL || render == NULL) { - HDF_LOGE("%{public}s", "The pointer is null"); + HDF_LOGE("%{public}s: The pointer is null ", __func__); return HDF_ERR_INVALID_PARAM; } - int i; - for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + + num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum; + for (i = 0; i < num; i++) { + if (g_renderAndCaptureManage[i].adapterName == NULL) { + return HDF_ERR_INVALID_PARAM; + } if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { *adapter = g_renderAndCaptureManage[i].adapter; *render = g_renderAndCaptureManage[i].render; @@ -522,18 +706,26 @@ int32_t AudioAdapterListGetAdapterRender(const char *adapterName, int32_t AudioAdapterListGetRender(const char *adapterName, struct AudioRender **render, uint32_t pid) { - HDF_LOGE("%{public}s", "AudioAdapterListGetRender in"); + int32_t i, num; + + HDF_LOGE("%{public}s: enter ", __func__); if (adapterName == NULL || render == NULL) { - HDF_LOGE("%{public}s", "The pointer is null"); + HDF_LOGE("%{public}s: The pointer is null ", __func__); return HDF_ERR_INVALID_PARAM; } - int i; - for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + if (g_renderAndCaptureManage == NULL) { + return HDF_ERR_INVALID_PARAM; + } + num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum; + for (i = 0; i < num; i++) { + if (g_renderAndCaptureManage[i].adapterName == NULL) { + return HDF_ERR_INVALID_PARAM; + } if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { - HDF_LOGE("%{public}s renderPid = %{public}u, pid = %{public}u", "AudioAdapterListGetRender", + HDF_LOGE("%{public}s: renderPid = %{public}u, pid = %{public}u", __func__, g_renderAndCaptureManage[i].renderPid, pid); if (g_renderAndCaptureManage[i].renderPid != pid) { - HDF_LOGE("%{public}s", "AudioAdapterListGetRender renderPid != pid"); + HDF_LOGE("%{public}s: renderPid != pid ", __func__); return HDF_ERR_INVALID_OBJECT; } *render = g_renderAndCaptureManage[i].render; @@ -545,18 +737,26 @@ int32_t AudioAdapterListGetRender(const char *adapterName, struct AudioRender ** int32_t AudioAdapterListGetCapture(const char *adapterName, struct AudioCapture **capture, uint32_t pid) { - HDF_LOGE("%{public}s", "AudioAdapterListGetCapture in"); + int32_t i, num; + + HDF_LOGE("%{public}s: enter ", __func__); if (adapterName == NULL || capture == NULL) { - HDF_LOGE("%{public}s", "The pointer is null"); + HDF_LOGE("%{public}s: The pointer is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (g_renderAndCaptureManage == NULL) { return HDF_ERR_INVALID_PARAM; } - int i; - for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { - HDF_LOGE("%{public}s capturePid = %{public}u, pid = %{public}u", "AudioAdapterListGetcapture", + num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum; + for (i = 0; i < num; i++) { + if (g_renderAndCaptureManage[i].adapterName == NULL) { + return HDF_ERR_INVALID_PARAM; + } + HDF_LOGE("%{public}s: capturePid = %{public}u, pid = %{public}u", __func__, g_renderAndCaptureManage[i].capturePid, pid); if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { if (g_renderAndCaptureManage[i].capturePid != pid) { - HDF_LOGE("%{public}s", "AudioAdapterListGetcapture capturePid != pid"); + HDF_LOGE("%{public}s: capturePid != pid ", __func__); return HDF_ERR_INVALID_OBJECT; } *capture = g_renderAndCaptureManage[i].capture; @@ -575,7 +775,7 @@ int32_t AudioAdapterListCheckAndGetRender(struct AudioRender **render, struct Hd const char *adapterName = NULL; uint32_t pid; if (HdiServiceRenderCaptureReadData(data, &adapterName, &pid) < 0) { - HDF_LOGE("%{public}s", "HdiServiceRenderStart: HdiServiceRenderCaptureReadData fail"); + HDF_LOGE("%{public}s: HdiServiceRenderStart: HdiServiceRenderCaptureReadData fail ", __func__); return HDF_FAILURE; } int ret = AudioAdapterListGetRender(adapterName, &renderTemp, pid); @@ -598,7 +798,7 @@ int32_t AudioAdapterListCheckAndGetCapture(struct AudioCapture **capture, struct const char *adapterName = NULL; uint32_t pid; if (HdiServiceRenderCaptureReadData(data, &adapterName, &pid) < 0) { - HDF_LOGE("%{public}s", "HdiServiceCaptureStart: HdiServiceRenderCaptureReadData fail"); + HDF_LOGE("%{public}s: HdiServiceCaptureStart: HdiServiceRenderCaptureReadData fail ", __func__); return HDF_FAILURE; } int ret = AudioAdapterListGetCapture(adapterName, &captureTemp, pid); @@ -614,13 +814,22 @@ int32_t AudioAdapterListCheckAndGetCapture(struct AudioCapture **capture, struct int32_t AudioAdapterCheckListExist(const char *adapterName) { + int32_t i, num; + LOG_FUN_INFO(); + if (g_renderAndCaptureManage == NULL) { + return HDF_ERR_INVALID_PARAM; + } if (adapterName == NULL) { - HDF_LOGE("%{public}s", "adapterName is NULL."); + HDF_LOGE("%{public}s: The pointer is null. ", __func__); return HDF_ERR_INVALID_PARAM; } - int i; - for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + + num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum; + for (i = 0; i < num; i++) { + if (g_renderAndCaptureManage[i].adapterName == NULL) { + return HDF_ERR_INVALID_PARAM; + } if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { if (g_renderAndCaptureManage[i].adapterUserNum == 0) { return HDF_FAILURE; @@ -635,13 +844,21 @@ int32_t AudioAdapterCheckListExist(const char *adapterName) int32_t AudioAdapterListDestory(const char *adapterName, struct AudioAdapter **adapter) { + int32_t i, num; + LOG_FUN_INFO(); if (adapterName == NULL) { - HDF_LOGE("%{public}s", "adapterName is NULL."); + HDF_LOGE("%{public}s: adapterName is NULL. ", __func__); return HDF_ERR_INVALID_PARAM; } - int i; - for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + if (g_renderAndCaptureManage == NULL) { + return HDF_ERR_INVALID_PARAM; + } + num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum; + for (i = 0; i < num; i++) { + if (g_renderAndCaptureManage[i].adapterName == NULL) { + return HDF_ERR_INVALID_PARAM; + } if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { if (g_renderAndCaptureManage[i].adapterUserNum == 1) { g_renderAndCaptureManage[i].adapterUserNum--; @@ -659,13 +876,21 @@ int32_t AudioAdapterListDestory(const char *adapterName, struct AudioAdapter **a int32_t AudioAdapterListAdd(const char *adapterName, struct AudioAdapter *adapter) { + int32_t i, num; + LOG_FUN_INFO(); if (adapterName == NULL || adapter == NULL) { - HDF_LOGE("%{public}s", "adapterName is NULL."); + HDF_LOGE("%{public}s: adapterName is NULL. ", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (g_renderAndCaptureManage == NULL) { return HDF_ERR_INVALID_PARAM; } - int i; - for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum; + for (i = 0; i < num; i++) { + if (g_renderAndCaptureManage[i].adapterName == NULL) { + return HDF_ERR_INVALID_PARAM; + } if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { g_renderAndCaptureManage[i].adapter = adapter; g_renderAndCaptureManage[i].adapterUserNum = 1; @@ -677,29 +902,41 @@ int32_t AudioAdapterListAdd(const char *adapterName, struct AudioAdapter *adapte void AudioSetCaptureStatus(const char *adapterName, bool captureStatus) { + int32_t i, num; + LOG_FUN_INFO(); - if (adapterName == NULL) { + if (adapterName == NULL || g_renderAndCaptureManage == NULL) { return; } - int i; - for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + + num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum; + for (i = 0; i < num; i++) { + if (g_renderAndCaptureManage[i].adapterName == NULL) { + return; + } if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { g_renderAndCaptureManage[i].captureBusy = captureStatus; return; } } - HDF_LOGE("%{public}s", "AudioSetCaptureStatus: Can not find Adapter!"); + HDF_LOGE("%{public}s: Can not find Adapter! ", __func__); return; } int32_t AudioGetCaptureStatus(const char *adapterName) { + int32_t i, num; + LOG_FUN_INFO(); - if (adapterName == NULL) { + if (adapterName == NULL || g_renderAndCaptureManage == NULL) { return HDF_FAILURE; } - int i; - for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + + num = (g_serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : g_serverAdapterNum; + for (i = 0; i < num; i++) { + if (g_renderAndCaptureManage[i].adapterName == NULL) { + return HDF_FAILURE; + } if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { if (!g_renderAndCaptureManage[i].captureDestory) { return HDF_SUCCESS; @@ -709,7 +946,25 @@ int32_t AudioGetCaptureStatus(const char *adapterName) } } } - HDF_LOGE("%{public}s", "AudioGetCaptureStatus: Can not find Adapter!"); + HDF_LOGE("%{public}s: Can not find Adapter! ", __func__); return HDF_FAILURE; } +int32_t HdiServicePositionWrite(struct HdfSBuf *reply, + uint64_t frames, struct AudioTimeStamp time) +{ + if (reply == NULL) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint64(reply, frames)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteInt64(reply, time.tvSec)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteInt64(reply, time.tvNSec)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + diff --git a/audio/hal/hdi_binder/server/src/hdf_audio_server_render.c b/audio/hal/hdi_binder/server/src/hdf_audio_server_render.c index f4666a4570..2781a23c5e 100755 --- a/audio/hal/hdi_binder/server/src/hdf_audio_server_render.c +++ b/audio/hal/hdi_binder/server/src/hdf_audio_server_render.c @@ -13,6 +13,7 @@ * limitations under the License. */ #include "hdf_audio_server_render.h" +#include "hdf_audio_server_common.h" int32_t GetInitRenderParaAttrs(struct HdfSBuf *data, struct AudioSampleAttributes *attrs) { @@ -21,32 +22,32 @@ int32_t GetInitRenderParaAttrs(struct HdfSBuf *data, struct AudioSampleAttribute } uint32_t tempRenderPara = 0; if (!HdfSbufReadUint32(data, &tempRenderPara)) { - HDF_LOGE("%{public}s", " read buf fail"); + HDF_LOGE("%{public}s: read tempRenderPara fail", __func__); return HDF_FAILURE; } attrs->type = (enum AudioCategory)tempRenderPara; if (!HdfSbufReadUint32(data, &attrs->period)) { - HDF_LOGE("%{public}s", " read buf fail"); + HDF_LOGE("%{public}s: read period fail", __func__); return HDF_FAILURE; } if (!HdfSbufReadUint32(data, &attrs->frameSize)) { - HDF_LOGE("%{public}s", " read buf fail"); + HDF_LOGE("%{public}s: read frameSize fail", __func__); return HDF_FAILURE; } if (!HdfSbufReadUint32(data, &attrs->startThreshold)) { - HDF_LOGE("%{public}s", " read buf fail"); + HDF_LOGE("%{public}s: read startThreshold fail", __func__); return HDF_FAILURE; } if (!HdfSbufReadUint32(data, &attrs->stopThreshold)) { - HDF_LOGE("%{public}s", " read buf fail"); + HDF_LOGE("%{public}s: read stopThreshold fail", __func__); return HDF_FAILURE; } if (!HdfSbufReadUint32(data, &attrs->silenceThreshold)) { - HDF_LOGE("%{public}s", " read buf fail"); + HDF_LOGE("%{public}s: read silenceThreshold fail", __func__); return HDF_FAILURE; } if (!HdfSbufReadUint32(data, &tempRenderPara)) { - LOG_FUN_ERR("Failed to Get Speed sBuf!"); + HDF_LOGE("%{public}s: read bool isBigEndian fail", __func__); return HDF_FAILURE; } attrs->isBigEndian = (bool)tempRenderPara; @@ -61,20 +62,20 @@ int32_t GetInitRenderPara(struct HdfSBuf *data, struct AudioDeviceDescriptor *de } uint32_t tempRenderPara = 0; if (!HdfSbufReadUint32(data, &tempRenderPara)) { - LOG_FUN_ERR("Failed to Get Speed sBuf!"); + HDF_LOGE("%{public}s: read attrs format fail", __func__); return HDF_FAILURE; } attrs->format = (enum AudioFormat)tempRenderPara; if (!HdfSbufReadUint32(data, &attrs->channelCount)) { - HDF_LOGE("%{public}s", " read buf fail"); + HDF_LOGE("%{public}s: read channelCount fail", __func__); return HDF_FAILURE; } if (!HdfSbufReadUint32(data, &attrs->sampleRate)) { - HDF_LOGE("%{public}s", " read buf fail"); + HDF_LOGE("%{public}s: read sampleRate fail", __func__); return HDF_FAILURE; } if (!HdfSbufReadUint32(data, &tempRenderPara)) { - LOG_FUN_ERR("Failed to Get Speed sBuf!"); + HDF_LOGE("%{public}s: read attrs interleaved fail", __func__); return HDF_FAILURE; } attrs->interleaved = (bool)tempRenderPara; @@ -82,16 +83,16 @@ int32_t GetInitRenderPara(struct HdfSBuf *data, struct AudioDeviceDescriptor *de return HDF_FAILURE; } if (!HdfSbufReadUint32(data, &tempRenderPara)) { - LOG_FUN_ERR("Failed to Get Speed sBuf!"); + HDF_LOGE("%{public}s: read attrs isSignedData fail", __func__); return HDF_FAILURE; } attrs->isSignedData = (bool)tempRenderPara; if (!HdfSbufReadUint32(data, &devDesc->portId)) { - HDF_LOGE("%{public}s", " read buf fail"); + HDF_LOGE("%{public}s: read portId fail", __func__); return HDF_FAILURE; } if (!HdfSbufReadUint32(data, &tempRenderPara)) { - HDF_LOGE("%{public}s", " read buf fail"); + HDF_LOGE("%{public}s: read tempRenderPara fail", __func__); return HDF_FAILURE; } devDesc->pins = (enum AudioPortPin)tempRenderPara; @@ -110,41 +111,41 @@ int32_t HdiServiceCreatRender(struct HdfDeviceIoClient *client, struct AudioSampleAttributes attrs; struct AudioRender *render = NULL; const char *adapterName = NULL; - uint32_t renderPid; + uint32_t renderPid = 0; if ((adapterName = HdfSbufReadString(data)) == NULL) { - HDF_LOGE("%{public}s", "adapterNameCase Is NULL"); + HDF_LOGE("%{public}s: adapterNameCase Is NULL", __func__); return HDF_FAILURE; } if (!HdfSbufReadUint32(data, &renderPid)) { return HDF_FAILURE; } - HDF_LOGE("%{public}s, renderPid = %{public}u", "HdiServiceCreatRender:", renderPid); + HDF_LOGE("HdiServiceCreatRender: renderPid = %{public}u", renderPid); int32_t ret = GetInitRenderPara(data, &devDesc, &attrs); if (ret < 0) { - HDF_LOGE("%{public}s", " GetInitRenderPara fail"); + HDF_LOGE("%{public}s: GetInitRenderPara fail", __func__); return HDF_FAILURE; } if (AudioAdapterListGetAdapter(adapterName, &adapter)) { - HDF_LOGE("%{public}s", "AudioAdapterListGetAdapter fail"); + HDF_LOGE("%{public}s: fail", __func__); return HDF_FAILURE; } if (adapter == NULL) { - HDF_LOGE("%{public}s", "HdiServiceCreatRender adapter is NULL!"); + HDF_LOGE("%{public}s: adapter is NULL!", __func__); return HDF_FAILURE; } const int32_t priority = attrs.type; ret = AudioCreatRenderCheck(adapterName, priority); if (ret < 0) { - HDF_LOGE("%{public}s", "AudioCreatRenderCheck: Render is working can not replace!"); + HDF_LOGE("%{public}s: AudioCreatRenderCheck: Render is working can not replace!", __func__); return ret; } ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render); if (render == NULL || ret < 0) { - HDF_LOGE("%{public}s", "Failed to CreateRender"); + HDF_LOGE("%{public}s: Failed to CreateRender", __func__); return HDF_FAILURE; } if (AudioAddRenderInfoInAdapter(adapterName, render, adapter, priority, renderPid)) { - HDF_LOGE("%{public}s", "AudioAddRenderInfoInAdapter"); + HDF_LOGE("%{public}s: AudioAddRenderInfoInAdapter", __func__); adapter->DestroyRender(adapter, render); return HDF_FAILURE; } @@ -160,7 +161,7 @@ int32_t HdiServiceRenderDestory(struct HdfDeviceIoClient *client, struct AudioAdapter *adapter = NULL; struct AudioRender *render = NULL; const char *adapterName = NULL; - uint32_t pid; + uint32_t pid = 0; if (HdiServiceRenderCaptureReadData(data, &adapterName, &pid) < 0) { return HDF_FAILURE; } @@ -177,7 +178,7 @@ int32_t HdiServiceRenderDestory(struct HdfDeviceIoClient *client, } ret = adapter->DestroyRender(adapter, render); if (ret < 0) { - HDF_LOGE("%{public}s", "DestroyRender failed!"); + HDF_LOGE("%{public}s: DestroyRender failed!", __func__); return ret; } if (AudioDestroyRenderInfoInAdapter(adapterName)) { @@ -199,8 +200,7 @@ int32_t HdiServiceRenderStart(struct HdfDeviceIoClient *client, struct HdfSBuf * return render->control.Start((AudioHandle)render); } -int32_t HdiServiceRenderStop(struct HdfDeviceIoClient *client, - struct HdfSBuf *data, struct HdfSBuf *reply) +int32_t HdiServiceRenderStop(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { if (client == NULL || data == NULL || reply == NULL) { return HDF_FAILURE; @@ -219,7 +219,7 @@ int32_t HdiServiceRenderPause(struct HdfDeviceIoClient *client, if (client == NULL || data == NULL || reply == NULL) { return HDF_FAILURE; } - HDF_LOGE("%{public}s", "enter to HdiServiceRenderPause "); + HDF_LOGE("%{public}s: enter", __func__); struct AudioRender *render = NULL; int ret = AudioAdapterListCheckAndGetRender(&render, data); if (ret < 0) { @@ -241,11 +241,10 @@ int32_t HdiServiceRenderResume(struct HdfDeviceIoClient *client, struct HdfSBuf return render->control.Resume((AudioHandle)render); } -int32_t HdiServiceRenderFlush(struct HdfDeviceIoClient *client, - struct HdfSBuf *data, struct HdfSBuf *reply) +int32_t HdiServiceRenderFlush(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { if (client == NULL || data == NULL || reply == NULL) { - HDF_LOGI("%{public}s", "The parameter is empty"); + HDF_LOGI("%{public}s: The parameter is empty", __func__); return HDF_FAILURE; } struct AudioRender *render = NULL; @@ -325,7 +324,7 @@ int32_t HdiServiceRenderGetSampleAttr(struct HdfDeviceIoClient *client, } struct AudioSampleAttributes attrs; struct AudioRender *render = NULL; - int ret = AudioAdapterListCheckAndGetRender(&render, data); + int32_t ret = AudioAdapterListCheckAndGetRender(&render, data); if (ret < 0) { return ret; } @@ -407,11 +406,11 @@ int32_t HdiServiceRenderSelectScene(struct HdfDeviceIoClient *client, return ret; } if (!HdfSbufReadUint32(data, &scene.scene.id)) { - HDF_LOGI("%{public}s", "Read Buf Fail"); + HDF_LOGI("%{public}s: Read id Fail", __func__); return HDF_FAILURE; } if (!HdfSbufReadUint32(data, &tempPins)) { - HDF_LOGI("%{public}s", "Read Buf Fail"); + HDF_LOGI("%{public}s: Read tempPins Fail", __func__); return HDF_FAILURE; } scene.desc.pins = (enum AudioPortPin)tempPins; @@ -422,7 +421,7 @@ int32_t HdiServiceRenderGetMute(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { if (client == NULL || data == NULL || reply == NULL) { - HDF_LOGI("%{public}s", "parameter is empty"); + HDF_LOGI("%{public}s: parameter is empty", __func__); return HDF_FAILURE; } bool mute = false; @@ -468,7 +467,7 @@ int32_t HdiServiceRenderSetVolume(struct HdfDeviceIoClient *client, if (client == NULL || data == NULL || reply == NULL) { return HDF_FAILURE; } - uint32_t volume; + uint32_t volume = 0; struct AudioRender *render = NULL; int ret = AudioAdapterListCheckAndGetRender(&render, data); if (ret < 0) { @@ -520,12 +519,12 @@ int32_t HdiServiceRenderGetGainThreshold(struct HdfDeviceIoClient *client, if (ret < 0) { return ret; } - uint32_t tempMin = (uint32_t)min; - if (!HdfSbufWriteUint32(reply, tempMin)) { + uint32_t temporaryMin = (uint32_t)min; + if (!HdfSbufWriteUint32(reply, temporaryMin)) { return HDF_FAILURE; } - uint32_t tempMax = (uint32_t)max; - if (!HdfSbufWriteUint32(reply, tempMax)) { + uint32_t temporaryMax = (uint32_t)max; + if (!HdfSbufWriteUint32(reply, temporaryMax)) { return HDF_FAILURE; } return HDF_SUCCESS; @@ -560,7 +559,7 @@ int32_t HdiServiceRenderSetGain(struct HdfDeviceIoClient *client, if (client == NULL || data == NULL || reply == NULL) { return HDF_FAILURE; } - uint32_t tempGain; + uint32_t tempGain = 0; struct AudioRender *render = NULL; int ret = AudioAdapterListCheckAndGetRender(&render, data); if (ret < 0) { @@ -600,7 +599,7 @@ int32_t HdiServiceRenderRenderFrame(struct HdfDeviceIoClient *client, if (client == NULL || data == NULL || reply == NULL) { return HDF_FAILURE; } - HDF_LOGI("%{public}s", "HdiServiceRenderRenderFrame entry!"); + HDF_LOGI("%{public}s: enter", __func__); char *frame = NULL; uint32_t requestBytes; uint64_t replyBytes; @@ -608,29 +607,29 @@ int32_t HdiServiceRenderRenderFrame(struct HdfDeviceIoClient *client, const char *adapterName = NULL; uint32_t pid; if (HdiServiceRenderCaptureReadData(data, &adapterName, &pid) < 0) { - HDF_LOGE("%{public}s", "HdiServiceRenderRenderFrame:HdiServiceRenderCaptureReadData fail!"); + HDF_LOGE("%{public}s: HdiServiceRenderCaptureReadData fail!", __func__); return HDF_FAILURE; } int32_t ret = AudioAdapterListGetRender(adapterName, &render, pid); if (ret < 0) { - HDF_LOGE("%{public}s", "HdiServiceRenderRenderFrame:AudioAdapterListGetRender fail"); + HDF_LOGE("%{public}s: AudioAdapterListGetRender fail", __func__); return ret; } ret = AudioGetRenderStatus(adapterName); if (ret < 0) { - HDF_LOGE("%{public}s", "HdiServiceRenderRenderFrame:AudioGetRenderStatus fail"); + HDF_LOGE("%{public}s: AudioGetRenderStatus fail", __func__); return ret; } if (!HdfSbufReadBuffer(data, (const void **)&frame, &requestBytes)) { - HDF_LOGE("%{public}s", "AudioAdapterListGetRender:HdfSbufReadBuffer fail"); + HDF_LOGE("%{public}s: AudioAdapterListGetRender:HdfSbufReadBuffer fail", __func__); return HDF_FAILURE; } AudioSetRenderStatus(adapterName, true); ret = render->RenderFrame((AudioHandle)render, (const void *)frame, (uint64_t)requestBytes, &replyBytes); AudioSetRenderStatus(adapterName, false); - HDF_LOGE("%{public}s,%{public}u,%{public}llu", "HdiServiceRenderRenderFrame", requestBytes, replyBytes); + HDF_LOGE("%{public}s,%{public}u,%{public}llu", __func__, requestBytes, replyBytes); if (ret < 0) { - HDF_LOGE("%{public}s ", "HdiServiceRenderRenderFrame:HdiServiceRenderRenderFrame"); + HDF_LOGE("%{public}s: HdiServiceRenderRenderFrame ", __func__); return ret; } return HDF_SUCCESS; @@ -642,9 +641,9 @@ int32_t HdiServiceRenderGetRenderPosition(struct HdfDeviceIoClient *client, if (client == NULL || data == NULL || reply == NULL) { return HDF_FAILURE; } - uint64_t frames; struct AudioTimeStamp time; struct AudioRender *render = NULL; + uint64_t frames; int ret = AudioAdapterListCheckAndGetRender(&render, data); if (ret < 0) { return ret; @@ -653,13 +652,8 @@ int32_t HdiServiceRenderGetRenderPosition(struct HdfDeviceIoClient *client, if (ret < 0) { return ret; } - if (!HdfSbufWriteUint64(reply, frames)) { - return HDF_FAILURE; - } - if (!HdfSbufWriteInt64(reply, time.tvSec)) { - return HDF_FAILURE; - } - if (!HdfSbufWriteInt64(reply, time.tvNSec)) { + ret = HdiServicePositionWrite(reply, frames, time); + if (ret < 0) { return HDF_FAILURE; } return HDF_SUCCESS; @@ -694,7 +688,7 @@ int32_t HdiServiceRenderSetSpeed(struct HdfDeviceIoClient *client, if (client == NULL || data == NULL || reply == NULL) { return HDF_FAILURE; } - uint64_t speed; + uint64_t speed = 0; struct AudioRender *render = NULL; int ret = AudioAdapterListCheckAndGetRender(&render, data); if (ret < 0) { @@ -729,7 +723,7 @@ int32_t HdiServiceRenderSetChannelMode(struct HdfDeviceIoClient *client, int32_t HdiServiceRenderGetChannelMode(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { - HDF_LOGE("%{public}s", "HdiServiceRenderGetChannelMode in"); + HDF_LOGE("%{public}s: enter", __func__); if (client == NULL || data == NULL || reply == NULL) { return HDF_FAILURE; } @@ -747,7 +741,206 @@ int32_t HdiServiceRenderGetChannelMode(struct HdfDeviceIoClient *client, if (!HdfSbufWriteUint32(reply, tempMode)) { return HDF_FAILURE; } - HDF_LOGE("%{public}s", "HdiServiceRenderGetChannelMode out"); + HDF_LOGE("%{public}s: out", __func__); + return HDF_SUCCESS; +} + +int32_t HdiServiceRenderSetExtraParams(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + HDF_LOGE("%{public}s: enter", __func__); + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + const char *keyValueList = NULL; + if ((keyValueList = HdfSbufReadString(data)) == NULL) { + HDF_LOGE("%{public}s: keyValueList Is NULL", __func__); + return HDF_FAILURE; + } + return render->attr.SetExtraParams((AudioHandle)render, keyValueList); +} + +int32_t HdiServiceRenderGetExtraParams(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + HDF_LOGE("%{public}s: enter", __func__); + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + int32_t listLenth; + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + if (!HdfSbufReadInt32(data, &listLenth)) { + return HDF_FAILURE; + } + if (listLenth <= 0 || listLenth > STR_MAX - 1) { + return HDF_FAILURE; + } + char keyValueList[STR_MAX] = { 0 }; + ret = render->attr.GetExtraParams((AudioHandle)render, keyValueList, listLenth); + if (ret < 0) { + return ret; + } + if (!HdfSbufWriteString(reply, keyValueList)) { + return HDF_FAILURE; + } + HDF_LOGE("%{public}s: out", __func__); return HDF_SUCCESS; } +int32_t HdiServiceRenderReqMmapBuffer(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + HDF_LOGE("%{public}s: enter", __func__); + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + struct AudioMmapBufferDescripter desc; + int32_t reqSize = 0; + if (!HdfSbufReadInt32(data, &reqSize)) { + return HDF_FAILURE; + } + uint64_t memAddr = 0; + if (!HdfSbufReadUint64(data, &memAddr)) { + HDF_LOGE("%{public}s: memAddr Is NULL", __func__); + return HDF_FAILURE; + } + desc.memoryAddress = (void *)memAddr; + if (!HdfSbufReadInt32(data, &desc.memoryFd)) { + return HDF_FAILURE; + } + if (!HdfSbufReadInt32(data, &desc.totalBufferFrames)) { + return HDF_FAILURE; + } + if (!HdfSbufReadInt32(data, &desc.transferFrameSize)) { + return HDF_FAILURE; + } + if (!HdfSbufReadInt32(data, &desc.isShareable)) { + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &desc.offset)) { + return HDF_FAILURE; + } + return render->attr.ReqMmapBuffer((AudioHandle)render, reqSize, &desc); +} + +int32_t HdiServiceRenderGetMmapPosition(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + HDF_LOGE("%{public}s: enter", __func__); + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + uint64_t frames; + struct AudioTimeStamp time; + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + ret = render->GetRenderPosition((AudioHandle)render, &frames, &time); + if (ret < 0) { + return ret; + } + if (HdiServicePositionWrite(reply, frames, time) < 0) { + return HDF_FAILURE; + } + HDF_LOGE("%{public}s: out", __func__); + return HDF_SUCCESS; +} + +int32_t HdiServiceRenderTurnStandbyMode(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + HDF_LOGE("%{public}s: The pointer is null", __func__); + return HDF_FAILURE; + } + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + return render->control.Stop((AudioHandle)render); +} + +int32_t HdiServiceRenderDevDump(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + int32_t range = 0; + int32_t fd = 0; + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + if (!HdfSbufReadInt32(data, &range)) { + return HDF_FAILURE; + } + if (!HdfSbufReadInt32(data, &fd)) { + return HDF_FAILURE; + } + return render->control.AudioDevDump((AudioHandle)render, range, fd); +} + +int32_t HdiServiceRenderRegCallback(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + void *cookie; + RenderCallback pCallback; + uint64_t tempAddr = 0; + if (!HdfSbufReadUint64(data, &tempAddr)) { + HDF_LOGE("%{public}s: read cookie Is NULL", __func__); + return HDF_FAILURE; + } + cookie = (void *)tempAddr; + if (!HdfSbufReadUint64(data, &tempAddr)) { + HDF_LOGE("%{public}s: read callback pointer Is NULL", __func__); + return HDF_FAILURE; + } + pCallback = (RenderCallback)tempAddr; + return render->RegCallback((AudioHandle)render, pCallback, cookie); +} + +int32_t HdiServiceRenderDrainBuffer(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + enum AudioDrainNotifyType type; + uint32_t tempType = 0; + if (!HdfSbufReadUint32(data, &tempType)) { + return HDF_FAILURE; + } + type = (enum AudioDrainNotifyType)tempType; + return render->DrainBuffer((AudioHandle)render, type); +} + diff --git a/audio/hal/hdi_passthrough/BUILD.gn b/audio/hal/hdi_passthrough/BUILD.gn new file mode 100755 index 0000000000..0ff957b523 --- /dev/null +++ b/audio/hal/hdi_passthrough/BUILD.gn @@ -0,0 +1,157 @@ +# 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. + +if (defined(ohos_lite)) { + import("//build/lite/config/component/lite_component.gni") +} else { + import("//build/ohos.gni") +} +import("//drivers/adapter/uhdf2/uhdf.gni") +import("//drivers/peripheral/audio/audio.gni") + +config("hdi_audio_config") { + visibility = [ ":*" ] + + cflags = [ + "-fPIC", + "-Wall", + "-Wextra", + "-Werror", + "-DGST_DISABLE_DEPRECATED", + "-DHAVE_CONFIG_H", + "-fno-strict-aliasing", + "-Wno-sign-compare", + "-Wno-builtin-requires-header", + "-Wno-implicit-function-declaration", + "-Wno-format", + "-Wno-int-conversion", + "-Wno-unused-function", + "-Wno-unused-parameter", + "-Wno-thread-safety-attributes", + "-Wno-inconsistent-missing-override", + "-fno-rtti", + "-fno-exceptions", + "-ffunction-sections", + "-fdata-sections", + ] + + ldflags = [ "-Wl" ] +} + +if (defined(ohos_lite)) { + + shared_library("hdi_audio") { + sources = [ + "//third_party/cJSON/cJSON.c", + "src/audio_manager.c", + "src/audio_common.c", + "src/audio_adapter.c", + "src/audio_capture.c", + "src/audio_render.c", + "src/audio_adapter_info_common.c", + "$hdf_framework_path/support/posix/src/osal_time.c" + ] + + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/supportlibs/adm_adapter/include", + "//third_party/cJSON", + "//drivers/peripheral/audio/interfaces/include", + "$hdf_framework_path/include/core", + "$hdf_framework_path/include/utils", + "$hdf_framework_path/include/osal", + "$hdf_framework_path/ability/sbuf/include", + "//drivers//adapter/khdf/liteos/osal/include", + "//third_party/bounds_checking_function/include" + ] + deps = [ + "//third_party/bounds_checking_function:libsec_shared" + ] + + if (enable_audio_hal_notsupport_pathselect) { + defines += [ "AUDIO_HAL_NOTSUPPORT_PATHSELECT" ] + } + + ldflags = [ + "-L$ohos_root_path/sysroot/usr/lib", + "-Wl,-rpath-link=$ohos_root_path/sysroot/usr/lib", + "-lstdc++", + "-ldl", + "-lm" + ] + + public_configs = [ ":hdi_audio_config" ] + } +} else { + ohos_shared_library("hdi_audio") { + sources = [ + "//third_party/cJSON/cJSON.c", + "src/audio_manager.c", + "src/audio_common.c", + "src/audio_adapter.c", + "src/audio_capture.c", + "src/audio_render.c", + "src/audio_adapter_info_common.c", + ] + + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/supportlibs/adm_adapter/include", + "//third_party/cJSON", + "//drivers/peripheral/audio/interfaces/include", + "$hdf_framework_path/include/core", + "$hdf_framework_path/include/utils", + "$hdf_framework_path/include/osal", + "$hdf_framework_path/include", + "//third_party/bounds_checking_function/include", + "$hdf_framework_path/ability/sbuf/include", + "$hdf_framework_path/utils/include", + "$hdf_framework_path/ability/sbuf/include", + "$hdf_uhdf_path/osal/include", + "$hdf_uhdf_path/common/include/core", + ] + + deps = [ + "$hdf_uhdf_path/osal:libhdf_utils", + "$hdf_uhdf_path/manager:hdf_devmgr", + "$hdf_uhdf_path/manager:hdf_devmgr.rc", + "//utils/native/base:utils", + "$hdf_uhdf_path/hdi:libhdi", + "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", + "$hdf_uhdf_path/host:hdf_devhost", + "$hdf_uhdf_path/host:libhdf_host", + "$hdf_uhdf_path/config:libhdf_hcs", + "$hdf_uhdf_path/hcs:hdf_default.hcb", + ] + + defines = [] + if (enable_audio_device_mpi) { + defines += [ "AUDIO_HAL_USER" ] + } + + if (enable_audio_hal_notsupport_pathselect) { + defines += [ "AUDIO_HAL_NOTSUPPORT_PATHSELECT" ] + } + + if (is_standard_system) { + external_deps = [ "hiviewdfx_hilog_native:libhilog" ] + } else { + external_deps = [ "hilog:libhilog" ] + } + + public_configs = [ ":hdi_audio_config" ] + + subsystem_name = "hdf" + } +} + diff --git a/audio/hal/hdi_passthrough/include/audio_adapter_info_common.h b/audio/hal/hdi_passthrough/include/audio_adapter_info_common.h index 2d1e15c0db..fb3adb629b 100755 --- a/audio/hal/hdi_passthrough/include/audio_adapter_info_common.h +++ b/audio/hal/hdi_passthrough/include/audio_adapter_info_common.h @@ -16,8 +16,6 @@ #ifndef AUDIO_ADAPTER_INFO_COMMON_H #define AUDIO_ADAPTER_INFO_COMMON_H -#include -#include #include #include #include @@ -26,8 +24,10 @@ #include #include #include +#include #include "securec.h" #include "audio_types.h" +#include "audio_internal.h" struct AudioAdapterDescriptor *AudioAdapterGetConfigOut(void); struct AudioAdapterDescriptor *AudioAdapterGetConfigDescs(void); @@ -35,4 +35,18 @@ int32_t AudioAdapterGetAdapterNum(void); int32_t AudioAdaptersForUser(struct AudioAdapterDescriptor **descs, int *size); int32_t AudioAdapterExist(const char *adapterName); int32_t HdmiPortInit(struct AudioPort portIndex, struct AudioPortCapability *capabilityIndex); +int32_t KeyValueListToMap(const char *keyValueList, struct ParamValMap mParamValMap[], int32_t *count); +int32_t AddElementToList(char *keyValueList, int32_t listLenth, const char *key, void *value); +int32_t GetErrorReason(int reason, char* reasonDesc); +int32_t GetCurrentTime(char *time); +int32_t CheckAttrRoute(int32_t param); +int32_t CheckAttrChannel(uint32_t param); +int32_t TransferRoute(char *value, int32_t *route); +int32_t TransferFormat(char *value, int32_t *format); +int32_t TransferChannels(char *value, uint32_t *channels); +int32_t TransferFrames(char *value, uint64_t *frames); +int32_t TransferSampleRate(char *value, uint32_t *sampleRate); +int32_t FormatToBits(enum AudioFormat format, uint32_t *formatBits); +int32_t BitsToFormat(enum AudioFormat *format, int32_t formatBits); +int32_t SetExtParam(const char *key, char *value, struct ExtraParams *mExtraParams); #endif diff --git a/audio/hal/hdi_passthrough/include/audio_common.h b/audio/hal/hdi_passthrough/include/audio_common.h index 727f119d75..0273d0d9f1 100755 --- a/audio/hal/hdi_passthrough/include/audio_common.h +++ b/audio/hal/hdi_passthrough/include/audio_common.h @@ -26,11 +26,20 @@ #include #include #include +#include #include "securec.h" +enum {INFO}; +#define FILE_NAME_LEN 256 +#define TIME_LEN 32 + void AudioDlClose(void **ppHandleSo); void AudioMemFree(void **ppMem); int32_t AudioGetSysTime(char *s, int32_t len); +int32_t CheckAttrFormat(enum AudioFormat param); +int32_t CheckAttrSamplingRate(uint32_t param); int32_t AudioCheckParaAttr(const struct AudioSampleAttributes *attrs); +int32_t TimeToAudioTimeStamp(uint64_t bufferFrameSize, struct AudioTimeStamp *time, uint32_t sampleRate); +void AudioLogRecord(int errorLevel, const char *format, ...); #endif diff --git a/audio/hal/hdi_passthrough/include/audio_internal.h b/audio/hal/hdi_passthrough/include/audio_internal.h index faa456b701..aaf31ec1b6 100755 --- a/audio/hal/hdi_passthrough/include/audio_internal.h +++ b/audio/hal/hdi_passthrough/include/audio_internal.h @@ -21,6 +21,9 @@ #include "audio_common.h" #include "hdf_base.h" #include +#include +#include +#include #ifdef __cplusplus extern "C" { @@ -42,6 +45,14 @@ extern "C" { #define VOLUME_CHANGE 100 #define SEC_TO_NSEC 1000000000 #define HDMI_PORT_ID 12 +#define MAP_MAX 100 +#define FORMAT_ONE "%-5d %-10d %-20llu %-15s %s\n" +#define FORMAT_TWO "%-5d %-10d %s\n" +#define ERROR_LOG_MAX_NUM 8 +#define ERROR_REASON_DESC_LEN 128 +#define RANGE_MAX 5 +#define RANGE_MIN 4 +#define EXTPARAM_LEN 32 #ifndef LOGE #define LOGE(fmt, arg...) printf("[Audio:E]" fmt "\n", ##arg) @@ -78,22 +89,48 @@ extern "C" { #define STATIC_T #endif +#ifdef __LITEOS__ +#define SO_INTERFACE_LIB_RENDER_PATH "/usr/lib/libhdi_audio_interface_lib_render.so" +#define SO_INTERFACE_LIB_CAPTURE_PATH "/usr/lib/libhdi_audio_interface_lib_capture.so" +#else #define SO_INTERFACE_LIB_RENDER_PATH "/system/lib/libhdi_audio_interface_lib_render.z.so" #define SO_INTERFACE_LIB_CAPTURE_PATH "/system/lib/libhdi_audio_interface_lib_capture.z.so" +#endif #ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT +#ifdef __LITEOS__ +#define SO_CJSON_LIB_PATHSELECT_PATH "/usr/lib/libhdi_audio_path_select.so" +#else #define SO_CJSON_LIB_PATHSELECT_PATH "/system/lib/libhdi_audio_path_select.z.so" #endif +#endif #define USECASE_AUDIO_RENDER_DEEP_BUFFER "deep-buffer-render" #define USECASE_AUDIO_RENDER_LOW_LATENCY "low-latency-render" +#define AUDIO_ATTR_PARAM_ROUTE "attr-route" +#define ROUTE_SAMPLE "attr-route=x;" +#define AUDIO_ATTR_PARAM_FORMAT "attr-format" +#define FORMAT_SAMPLE "attr-format=xx;" +#define AUDIO_ATTR_PARAM_CHANNELS "attr-channels" +#define CHANNELS_SAMPLE "attr-channels=x;" +#define AUDIO_ATTR_PARAM_FRAME_COUNT "attr-frame-count" +#define FRAME_COUNT_SAMPLE "attr-frame-count=xxxxxxxxxxxxxxxxxxxx;" +#define AUDIO_ATTR_PARAM_SAMPLING_RATE "attr-sampling-rate" +#define SAMPLING_RATE_SAMPLE "attr-sampling-rate=xxxxx" +#define AUDIO_ATTR_PARAM_CONNECT "usb-connect" +#define AUDIO_ATTR_PARAM_DISCONNECT "usb-disconnect" #define TELHPONE_RATE 8000 #define BROADCAST_AM_RATE 11025 #define BROADCAST_FM_RATE 22050 #define MINI_CAM_DV_RATE 32000 #define MUSIC_RATE 44100 #define HIGHT_MUSIC_RATE 48000 +#define AUDIO_SAMPLE_RATE_12000 12000 +#define AUDIO_SAMPLE_RATE_16000 16000 +#define AUDIO_SAMPLE_RATE_24000 24000 +#define AUDIO_SAMPLE_RATE_64000 64000 +#define AUDIO_SAMPLE_RATE_96000 96000 #define OPEN_AUDIO_LOG_WITH_TIME 1 #define MAX_TIME_INFO_LEN 64 @@ -141,6 +178,9 @@ struct AudioHwAdapter { struct AudioAdapter common; struct AudioAdapterDescriptor adapterDescriptor; struct AudioPortAndCapability *portCapabilitys; + struct HdfRemoteService *proxyRemoteHandle; // proxyRemoteHandle + int32_t adapterMgrRenderFlag; + int32_t adapterMgrCaptureFlag; }; struct AudioFrameRenderMode { @@ -158,6 +198,9 @@ struct AudioFrameRenderMode { char *buffer; uint64_t bufferFrameSize; uint64_t bufferSize; + RenderCallback callback; + void* cookie; + struct AudioMmapBufferDescripter mmapBufDesc; }; struct AudioGain { @@ -176,6 +219,10 @@ struct AudioCtlParam { float volume; float speed; bool pause; + bool stop; + pthread_mutex_t mutex; + bool mutexFlag; + pthread_cond_t functionCond; struct AudioVol volThreshold; struct AudioGain audioGain; }; @@ -231,11 +278,27 @@ struct AudioHwRenderParam { struct AudioFrameRenderMode frameRenderMode; }; +struct ErrorDump { + int32_t errorCode; + int32_t count; + uint64_t frames; + char* reason; // Specific reasons for failure + char* currentTime; +}; + +struct ErrorLog { + uint32_t totalErrors; + uint32_t iter; + struct ErrorDump errorDump[ERROR_LOG_MAX_NUM]; +}; + struct AudioHwRender { struct AudioRender common; struct AudioHwRenderParam renderParam; struct DevHandle *devDataHandle; // Bind Data handle struct DevHandle *devCtlHandle; // Bind Ctl handle + struct HdfRemoteService *proxyRemoteHandle; // proxyRemoteHandle + struct ErrorLog errorLog; }; struct AudioHwCaptureMode { @@ -258,6 +321,7 @@ struct AudioFrameCaptureMode { char *buffer; uint64_t bufferFrameSize; uint64_t bufferSize; + struct AudioMmapBufferDescripter mmapBufDesc; }; struct AudioHwCaptureParam { @@ -270,6 +334,26 @@ struct AudioHwCapture { struct AudioHwCaptureParam captureParam; struct DevHandleCapture *devDataHandle; // Bind Data handle struct DevHandleCapture *devCtlHandle; // Bind Ctl handle + struct HdfRemoteService *proxyRemoteHandle; // proxyRemoteHandle + struct ErrorLog errorLog; +}; + +struct ParamValMap { + char key[EXTPARAM_LEN]; + char value[EXTPARAM_LEN]; +}; + +struct ExtraParams { + int32_t route; + int32_t format; + uint32_t channels; + uint64_t frames; + uint32_t sampleRate; + bool flag; +}; + +enum ErrorDumpCode { + WRITE_FRAME_ERROR_CODE = -5, }; enum AudioAdaptType { @@ -301,6 +385,10 @@ enum AudioInterfaceLibParaCmdList { AUDIO_DRV_PCM_IOCTRL_PAUSE_CAPTURE, AUDIO_DRV_PCM_IOCTRL_RESUME, AUDIO_DRV_PCM_IOCTRL_RESUME_CAPTURE, + AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER, + AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER_CAPTURE, + AUDIO_DRV_PCM_IOCTL_MMAP_POSITION, + AUDIO_DRV_PCM_IOCTL_MMAP_POSITION_CAPTURE, AUDIO_DRV_PCM_IOCTL_BUTT, }; @@ -374,7 +462,14 @@ int32_t AudioRenderSetRenderSpeed(struct AudioRender *render, float speed); int32_t AudioRenderGetRenderSpeed(struct AudioRender *render, float *speed); int32_t AudioRenderSetChannelMode(struct AudioRender *render, enum AudioChannelMode mode); int32_t AudioRenderGetChannelMode(struct AudioRender *render, enum AudioChannelMode *mode); - +int32_t AudioRenderSetExtraParams(AudioHandle handle, const char *keyValueList); +int32_t AudioRenderGetExtraParams(AudioHandle handle, char *keyValueList, int32_t listLenth); +int32_t AudioRenderReqMmapBuffer(AudioHandle handle, int32_t reqSize, struct AudioMmapBufferDescripter *desc); +int32_t AudioRenderGetMmapPosition(AudioHandle handle, uint64_t *frames, struct AudioTimeStamp *time); +int32_t AudioRenderTurnStandbyMode(AudioHandle handle); +int32_t AudioRenderAudioDevDump(AudioHandle handle, int32_t range, int32_t fd); +int32_t AudioRenderRegCallback(struct AudioRender *render, RenderCallback callback, void* cookie); +int32_t AudioRenderDrainBuffer(struct AudioRender *render, enum AudioDrainNotifyType *type); int32_t AudioCaptureStart(AudioHandle handle); int32_t AudioCaptureStop(AudioHandle handle); int32_t AudioCapturePause(AudioHandle handle); @@ -398,6 +493,12 @@ int32_t AudioCaptureSetGain(AudioHandle handle, float gain); int32_t AudioCaptureCaptureFrame(struct AudioCapture *capture, void *frame, uint64_t requestBytes, uint64_t *replyBytes); int32_t AudioCaptureGetCapturePosition(struct AudioCapture *capture, uint64_t *frames, struct AudioTimeStamp *time); +int32_t AudioCaptureSetExtraParams(AudioHandle handle, const char *keyValueList); +int32_t AudioCaptureGetExtraParams(AudioHandle handle, char *keyValueList, int32_t listLenth); +int32_t AudioCaptureReqMmapBuffer(AudioHandle handle, int32_t reqSize, struct AudioMmapBufferDescripter *desc); +int32_t AudioCaptureGetMmapPosition(AudioHandle handle, uint64_t *frames, struct AudioTimeStamp *time); +int32_t AudioCaptureTurnStandbyMode(AudioHandle handle); +int32_t AudioCaptureAudioDevDump(AudioHandle handle, int32_t range, int32_t fd); #ifdef __cplusplus } diff --git a/audio/hal/hdi_passthrough/src/audio_adapter.c b/audio/hal/hdi_passthrough/src/audio_adapter.c index 843ae18630..412531746c 100755 --- a/audio/hal/hdi_passthrough/src/audio_adapter.c +++ b/audio/hal/hdi_passthrough/src/audio_adapter.c @@ -39,11 +39,17 @@ int32_t GetAudioRenderFunc(struct AudioHwRender *hwRender) hwRender->common.control.Pause = AudioRenderPause; hwRender->common.control.Resume = AudioRenderResume; hwRender->common.control.Flush = AudioRenderFlush; + hwRender->common.control.TurnStandbyMode = AudioRenderTurnStandbyMode; + hwRender->common.control.AudioDevDump = AudioRenderAudioDevDump; hwRender->common.attr.GetFrameSize = AudioRenderGetFrameSize; hwRender->common.attr.GetFrameCount = AudioRenderGetFrameCount; hwRender->common.attr.SetSampleAttributes = AudioRenderSetSampleAttributes; hwRender->common.attr.GetSampleAttributes = AudioRenderGetSampleAttributes; hwRender->common.attr.GetCurrentChannelId = AudioRenderGetCurrentChannelId; + hwRender->common.attr.SetExtraParams = AudioRenderSetExtraParams; + hwRender->common.attr.GetExtraParams = AudioRenderGetExtraParams; + hwRender->common.attr.ReqMmapBuffer = AudioRenderReqMmapBuffer; + hwRender->common.attr.GetMmapPosition = AudioRenderGetMmapPosition; hwRender->common.scene.CheckSceneCapability = AudioRenderCheckSceneCapability; hwRender->common.scene.SelectScene = AudioRenderSelectScene; hwRender->common.volume.SetMute = AudioRenderSetMute; @@ -60,6 +66,8 @@ int32_t GetAudioRenderFunc(struct AudioHwRender *hwRender) hwRender->common.GetRenderSpeed = AudioRenderGetRenderSpeed; hwRender->common.SetChannelMode = AudioRenderSetChannelMode; hwRender->common.GetChannelMode = AudioRenderGetChannelMode; + hwRender->common.RegCallback = AudioRenderRegCallback; + hwRender->common.DrainBuffer = AudioRenderDrainBuffer; return HDF_SUCCESS; } @@ -155,6 +163,7 @@ int32_t InitHwRenderParam(struct AudioHwRender *hwRender, const struct AudioDevi } int32_t ret = CheckParaDesc(desc, TYPE_RENDER); if (ret != HDF_SUCCESS) { + LOG_FUN_ERR("CheckParaDesc Fail"); return ret; } ret = CheckParaAttr(attrs); @@ -270,12 +279,15 @@ int32_t AudioAdapterInitAllPorts(struct AudioAdapter *adapter) LOG_PARA_INFO("portCapabilitys already Init!"); return HDF_SUCCESS; } - int32_t portNum = hwAdapter->adapterDescriptor.portNum; + uint32_t portNum = hwAdapter->adapterDescriptor.portNum; struct AudioPort *ports = hwAdapter->adapterDescriptor.ports; if (ports == NULL) { LOG_FUN_ERR("ports is NULL!"); return HDF_FAILURE; } + if (portNum == 0) { + return HDF_FAILURE; + } struct AudioPortAndCapability *portCapability = (struct AudioPortAndCapability *)calloc(portNum, sizeof(struct AudioPortAndCapability)); if (portCapability == NULL) { @@ -336,10 +348,11 @@ int32_t AudioSetAcodeModeRender(struct AudioHwRender *hwRender, } int32_t AudioAdapterCreateRenderPre(struct AudioHwRender *hwRender, const struct AudioDeviceDescriptor *desc, - const struct AudioSampleAttributes *attrs, struct AudioAdapter *adapter) + const struct AudioSampleAttributes *attrs, struct AudioHwAdapter *hwAdapter) { LOG_FUN_INFO(); - if (adapter == NULL || hwRender == NULL || desc == NULL || attrs == NULL) { + if (hwAdapter == NULL || hwRender == NULL || desc == NULL || attrs == NULL) { + LOG_FUN_ERR("Pointer is null!"); return HDF_FAILURE; } @@ -364,8 +377,6 @@ int32_t AudioAdapterCreateRenderPre(struct AudioHwRender *hwRender, const struct return HDF_FAILURE; } #endif - struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; - LOG_PARA_INFO("CreateRender success"); if (hwAdapter->adapterDescriptor.adapterName == NULL) { LOG_FUN_ERR("pointer is null!"); return HDF_FAILURE; @@ -389,7 +400,7 @@ int32_t AudioAdapterBindServiceRender(struct AudioHwRender *hwRender) { LOG_FUN_INFO(); int32_t ret; - if (hwRender == NULL) { + if (hwRender == NULL || hwRender->devDataHandle == NULL || hwRender->devCtlHandle == NULL) { return HDF_FAILURE; } InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender(); @@ -445,8 +456,12 @@ int32_t AudioAdapterBindServiceRender(struct AudioHwRender *hwRender) int32_t AudioAdapterCreateRender(struct AudioAdapter *adapter, const struct AudioDeviceDescriptor *desc, const struct AudioSampleAttributes *attrs, struct AudioRender **render) { - LOG_FUN_INFO(); - if (adapter == NULL || desc == NULL || attrs == NULL || render == NULL) { + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + if (hwAdapter == NULL || desc == NULL || attrs == NULL || render == NULL) { + return HDF_FAILURE; + } + if (hwAdapter->adapterMgrRenderFlag > 0) { + LOG_FUN_ERR("Create render repeatedly!"); return HDF_FAILURE; } BindServiceRenderSo *pBindServiceRender = AudioSoGetBindServiceRender(); @@ -459,7 +474,7 @@ int32_t AudioAdapterCreateRender(struct AudioAdapter *adapter, const struct Audi LOG_FUN_ERR("hwRender is NULL!"); return HDF_FAILURE; } - int32_t ret = AudioAdapterCreateRenderPre(hwRender, desc, attrs, adapter); + int32_t ret = AudioAdapterCreateRenderPre(hwRender, desc, attrs, hwAdapter); if (ret != 0) { LOG_FUN_ERR("AudioAdapterCreateRenderPre fail"); AudioMemFree((void **)&hwRender); @@ -486,15 +501,20 @@ int32_t AudioAdapterCreateRender(struct AudioAdapter *adapter, const struct Audi AudioMemFree((void **)&hwRender); return HDF_FAILURE; } + hwAdapter->adapterMgrRenderFlag++; *render = &hwRender->common; return HDF_SUCCESS; } int32_t AudioAdapterDestroyRender(struct AudioAdapter *adapter, struct AudioRender *render) { - if (adapter == NULL || render == NULL) { + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + if (hwAdapter == NULL || render == NULL) { return HDF_FAILURE; } + if (hwAdapter->adapterMgrRenderFlag > 0) { + hwAdapter->adapterMgrRenderFlag--; + } struct AudioHwRender *hwRender = (struct AudioHwRender *)render; if (hwRender == NULL) { return HDF_FAILURE; @@ -519,11 +539,17 @@ int32_t GetAudioCaptureFunc(struct AudioHwCapture *hwCapture) hwCapture->common.control.Pause = AudioCapturePause; hwCapture->common.control.Resume = AudioCaptureResume; hwCapture->common.control.Flush = AudioCaptureFlush; + hwCapture->common.control.TurnStandbyMode = AudioCaptureTurnStandbyMode; + hwCapture->common.control.AudioDevDump = AudioCaptureAudioDevDump; hwCapture->common.attr.GetFrameSize = AudioCaptureGetFrameSize; hwCapture->common.attr.GetFrameCount = AudioCaptureGetFrameCount; hwCapture->common.attr.SetSampleAttributes = AudioCaptureSetSampleAttributes; hwCapture->common.attr.GetSampleAttributes = AudioCaptureGetSampleAttributes; hwCapture->common.attr.GetCurrentChannelId = AudioCaptureGetCurrentChannelId; + hwCapture->common.attr.SetExtraParams = AudioCaptureSetExtraParams; + hwCapture->common.attr.GetExtraParams = AudioCaptureGetExtraParams; + hwCapture->common.attr.ReqMmapBuffer = AudioCaptureReqMmapBuffer; + hwCapture->common.attr.GetMmapPosition = AudioCaptureGetMmapPosition; hwCapture->common.scene.CheckSceneCapability = AudioCaptureCheckSceneCapability; hwCapture->common.scene.SelectScene = AudioCaptureSelectScene; hwCapture->common.volume.SetMute = AudioCaptureSetMute; @@ -578,6 +604,12 @@ int32_t InitHwCaptureParam(struct AudioHwCapture *hwCapture, const struct AudioD hwCapture->captureParam.frameCaptureMode.attrs.silenceThreshold = attrs->silenceThreshold; hwCapture->captureParam.frameCaptureMode.attrs.isBigEndian = attrs->isBigEndian; hwCapture->captureParam.frameCaptureMode.attrs.isSignedData = attrs->isSignedData; + /* Select Codec Mode */ + if (hwCapture->captureParam.captureMode.hwInfo.deviceDescript.portId < AUDIO_SERVICE_PORTID_FLAG) { + hwCapture->captureParam.captureMode.hwInfo.card = AUDIO_SERVICE_IN; + } else { + hwCapture->captureParam.captureMode.hwInfo.card = AUDIO_SERVICE_OUT; + } return HDF_SUCCESS; } @@ -603,10 +635,10 @@ void AudioReleaseCaptureHandle(struct AudioHwCapture *hwCapture) } int32_t AudioAdapterCreateCapturePre(struct AudioHwCapture *hwCapture, const struct AudioDeviceDescriptor *desc, - const struct AudioSampleAttributes *attrs, struct AudioAdapter *adapter) + const struct AudioSampleAttributes *attrs, struct AudioHwAdapter *hwAdapter) { - LOG_FUN_INFO(); - if (hwCapture == NULL || desc == NULL || attrs == NULL) { + if (hwCapture == NULL || desc == NULL || attrs == NULL || hwAdapter == NULL) { + LOG_FUN_ERR("Pointer Is Empty!"); return HDF_FAILURE; } #ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT @@ -631,7 +663,6 @@ int32_t AudioAdapterCreateCapturePre(struct AudioHwCapture *hwCapture, const str return HDF_FAILURE; } #endif - struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; if (hwAdapter->adapterDescriptor.adapterName == NULL) { LOG_FUN_ERR("adapterName is NULL!"); return HDF_FAILURE; @@ -654,7 +685,7 @@ int32_t AudioAdapterCreateCapturePre(struct AudioHwCapture *hwCapture, const str int32_t AudioAdapterInterfaceLibModeCapture(struct AudioHwCapture *hwCapture) { LOG_FUN_INFO(); - if (hwCapture == NULL) { + if (hwCapture == NULL || hwCapture->devCtlHandle == NULL || hwCapture->devDataHandle == NULL) { return HDF_FAILURE; } int32_t ret; @@ -700,8 +731,12 @@ int32_t AudioAdapterInterfaceLibModeCapture(struct AudioHwCapture *hwCapture) int32_t AudioAdapterCreateCapture(struct AudioAdapter *adapter, const struct AudioDeviceDescriptor *desc, const struct AudioSampleAttributes *attrs, struct AudioCapture **capture) { - LOG_FUN_INFO(); - if (adapter == NULL || desc == NULL || attrs == NULL || capture == NULL) { + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + if (hwAdapter == NULL || desc == NULL || attrs == NULL || capture == NULL) { + return HDF_FAILURE; + } + if (hwAdapter->adapterMgrCaptureFlag > 0) { + LOG_FUN_ERR("Create capture repeatedly!"); return HDF_FAILURE; } BindServiceCaptureSo *pBindServiceCapture = AudioSoGetBindServiceCapture(); @@ -714,26 +749,19 @@ int32_t AudioAdapterCreateCapture(struct AudioAdapter *adapter, const struct Aud LOG_FUN_ERR("calloc AudioHwCapture failed!"); return HDF_FAILURE; } - int32_t ret = AudioAdapterCreateCapturePre(hwCapture, desc, attrs, adapter); + int32_t ret = AudioAdapterCreateCapturePre(hwCapture, desc, attrs, hwAdapter); if (ret != 0) { LOG_FUN_ERR("AudioAdapterCreateCapturePre fail"); AudioMemFree((void **)&hwCapture); return HDF_FAILURE; } - /* Select Codec Mode */ - if (hwCapture->captureParam.captureMode.hwInfo.deviceDescript.portId < AUDIO_SERVICE_PORTID_FLAG) { - hwCapture->captureParam.captureMode.hwInfo.card = AUDIO_SERVICE_IN; - } else { - hwCapture->captureParam.captureMode.hwInfo.card = AUDIO_SERVICE_OUT; - } - hwCapture->devDataHandle = (*pBindServiceCapture)(CAPTURE_CMD); if (hwCapture->devDataHandle == NULL) { LOG_FUN_ERR("Capture bind service failed"); AudioMemFree((void **)&hwCapture); return HDF_FAILURE; } - hwCapture->devCtlHandle = (*pBindServiceCapture)(CTRL_CMD_CAPTURE); + hwCapture->devCtlHandle = (*pBindServiceCapture)(CTRL_CMD); if (hwCapture->devCtlHandle == NULL) { LOG_FUN_ERR("Capture bind service failed"); AudioReleaseCaptureHandle(hwCapture); @@ -747,15 +775,20 @@ int32_t AudioAdapterCreateCapture(struct AudioAdapter *adapter, const struct Aud AudioMemFree((void **)&hwCapture); return HDF_FAILURE; } + hwAdapter->adapterMgrCaptureFlag++; *capture = &hwCapture->common; return HDF_SUCCESS; } int32_t AudioAdapterDestroyCapture(struct AudioAdapter *adapter, struct AudioCapture *capture) { - if (adapter == NULL || capture == NULL) { + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + if (hwAdapter == NULL || capture == NULL) { return HDF_FAILURE; } + if (hwAdapter->adapterMgrCaptureFlag > 0) { + hwAdapter->adapterMgrCaptureFlag--; + } struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; if (hwCapture == NULL) { return HDF_FAILURE; @@ -797,8 +830,8 @@ int32_t AudioAdapterGetPortCapability(struct AudioAdapter *adapter, const struct return HDF_FAILURE; } -int32_t AudioAdapterSetPassthroughMode(struct AudioAdapter *adapter, const struct AudioPort *port, - enum AudioPortPassthroughMode mode) +int32_t AudioAdapterSetPassthroughMode(struct AudioAdapter *adapter, + const struct AudioPort *port, enum AudioPortPassthroughMode mode) { if (adapter == NULL || port == NULL || port->portName == NULL) { return HDF_FAILURE; @@ -808,7 +841,7 @@ int32_t AudioAdapterSetPassthroughMode(struct AudioAdapter *adapter, const struc } struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; if (hwAdapter->portCapabilitys == NULL) { - LOG_FUN_ERR("hwAdapter portCapabilitys is NULL!"); + LOG_FUN_ERR("The pointer is null!"); return HDF_FAILURE; } struct AudioPortAndCapability *portCapabilityTemp = hwAdapter->portCapabilitys; @@ -831,7 +864,6 @@ int32_t AudioAdapterSetPassthroughMode(struct AudioAdapter *adapter, const struc LOG_FUN_ERR("portCapability->subPorts is NULL!"); return HDF_FAILURE; } - int32_t subPortNum = portCapability->subPortsNum; while (subPortCapability != NULL && subPortNum > 0) { if (subPortCapability->mask == mode) { diff --git a/audio/hal/hdi_passthrough/src/audio_adapter_info_common.c b/audio/hal/hdi_passthrough/src/audio_adapter_info_common.c index 9b3ce3d07a..27bec6ccc8 100755 --- a/audio/hal/hdi_passthrough/src/audio_adapter_info_common.c +++ b/audio/hal/hdi_passthrough/src/audio_adapter_info_common.c @@ -14,19 +14,43 @@ */ #include "audio_internal.h" +#include +#include #include "audio_adapter_info_common.h" #include "cJSON.h" +#ifdef __LITEOS__ +#define AUDIO_ADAPTER_CONFIG "/etc/adapter_config.json" +#else #define AUDIO_ADAPTER_CONFIG "/system/etc/hdfconfig/adapter_config.json" +#endif #define ADAPTER_NAME_LEN 32 -#define PORT_NAME_LEN 32 -#define CONFIG_SIEZ_MAX 4096 -#define CONFIG_CHANNEL_COUNT 2 // two channels - +#define PORT_NAME_LEN ADAPTER_NAME_LEN +#define SUPPORT_ADAPTER_NUM_MAX 8 +#define SUPPORT_PORT_NUM_MAX 3 +#define SUPPORT_PORT_ID_MAX 18 +#define CONFIG_FILE_SIZE_MAX (SUPPORT_ADAPTER_NUM_MAX * 1024) // 8KB +#define CONFIG_CHANNEL_COUNT 2 // two channels +#define TIME_BASE_YEAR_1900 1900 +#define DECIMAL_SYSTEM 10 +int32_t g_adapterNum = 0; struct AudioAdapterDescriptor *g_audioAdapterOut = NULL; struct AudioAdapterDescriptor *g_audioAdapterDescs = NULL; -int32_t g_adapterNum = 0; +static const char *g_adaptersName[SUPPORT_ADAPTER_NUM_MAX] = {NULL}; +static const char *g_portsName[SUPPORT_ADAPTER_NUM_MAX][SUPPORT_PORT_NUM_MAX] = {{NULL}}; + +static void ClearAdaptersAllName(void) +{ + int i, j; + + for (i = 0; i < SUPPORT_ADAPTER_NUM_MAX; i++) { + g_adaptersName[i] = NULL; + for (j = 0; j < SUPPORT_PORT_NUM_MAX; j++) { + g_portsName[i][j] = NULL; + } + } +} struct AudioAdapterDescriptor *AudioAdapterGetConfigOut(void) { @@ -43,13 +67,93 @@ int32_t AudioAdapterGetAdapterNum(void) return g_adapterNum; } +static int32_t AudioAdapterCheckPortFlow(const char *name) +{ + uint32_t len; + + if (name == NULL) { + LOG_FUN_ERR("Invalid parameter!\n"); + + return HDF_ERR_INVALID_PARAM; + } + + len = strlen(name); + if (len == 0) { + LOG_FUN_ERR("port name is null!\n"); + + return HDF_FAILURE; + } else if (len >= PORT_NAME_LEN) { + LOG_FUN_ERR("port name is too long!\n"); + + return HDF_FAILURE; + } else { + /* Nothing to do */ + } + + if (strcmp(name, "AIP") && strcmp(name, "AOP") && strcmp(name, "AIOP")) { + LOG_FUN_ERR("Incorrect port name: [ %s ]!\n", name); + + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t AudioAdapterCheckName(const char *name) +{ + uint32_t len; + + if (name == NULL) { + LOG_FUN_ERR("Invalid parameter!\n"); + + return HDF_ERR_INVALID_PARAM; + } + + len = strlen(name); + if (len == 0) { + LOG_FUN_ERR("adapter name is null!\n"); + + return HDF_FAILURE; + } else if (len >= ADAPTER_NAME_LEN) { + LOG_FUN_ERR("adapter name is too long!\n"); + + return HDF_FAILURE; + } else { + /* Nothing to do */ + } + + if (!isalpha(*name++)) { // Names must begin with a letter + LOG_FUN_ERR("The adapter name of the illegal!\n"); + + return HDF_FAILURE; + } + + while (*name != '\0') { + if (*name == '_') { + name++; + continue; + } + + if (!isalnum(*name++)) { + LOG_FUN_ERR("The adapter name of the illegal!\n"); + + return HDF_FAILURE; + } + } + + return HDF_SUCCESS; +} + int32_t AudioAdapterExist(const char *adapterName) { if (adapterName == NULL) { - return HDF_FAILURE; + LOG_FUN_ERR("Invalid parameter!\n"); + + return HDF_ERR_INVALID_PARAM; } - if (g_audioAdapterDescs == NULL || g_adapterNum <= 0) { + if (g_audioAdapterDescs == NULL || g_adapterNum <= 0 || g_adapterNum > SUPPORT_ADAPTER_NUM_MAX) { LOG_FUN_ERR("no adapter info"); + return HDF_FAILURE; } for (int i = 0; i < g_adapterNum; i++) { @@ -57,20 +161,96 @@ int32_t AudioAdapterExist(const char *adapterName) return HDF_SUCCESS; } } + return HDF_FAILURE; } +static int32_t AudioAdapterPortSync(struct AudioPort *outPorts, + struct AudioPort *desPorts, uint32_t portNum) +{ + uint32_t index; + int32_t ret; + + if (outPorts == NULL || desPorts == NULL || + portNum == 0 || portNum > SUPPORT_PORT_NUM_MAX) { + LOG_FUN_ERR("Invalid parameter!\n"); + + return HDF_ERR_INVALID_PARAM; + } + + for (index = 0; index < portNum; index++) { + if (outPorts[index].portName && desPorts[index].portName) { + ret = memcpy_s((void *)outPorts[index].portName, PORT_NAME_LEN, + desPorts[index].portName, strlen(desPorts[index].portName)); + if (ret != EOK) { + LOG_FUN_ERR("memcpy_s port name fail!\n"); + + return HDF_FAILURE; + } + outPorts[index].dir = desPorts[index].dir; + outPorts[index].portId = desPorts[index].portId; + } + } + + return HDF_SUCCESS; +} + +static int32_t AudioAdaptersSync(void) +{ + int32_t i, ret; + + if (g_audioAdapterDescs == NULL || g_audioAdapterOut == NULL || + g_adapterNum <= 0 || g_adapterNum > SUPPORT_ADAPTER_NUM_MAX) { + return HDF_FAILURE; + } + + for (i = 0; i < g_adapterNum; i++) { + if (g_audioAdapterDescs[i].adapterName && + g_audioAdapterOut[i].adapterName) { + ret = memcpy_s((void *)g_audioAdapterOut[i].adapterName, ADAPTER_NAME_LEN, + g_audioAdapterDescs[i].adapterName, + strlen(g_audioAdapterDescs[i].adapterName)); + if (ret != EOK) { + LOG_FUN_ERR("memcpy_s adapter name fail!\n"); + + return HDF_FAILURE; + } + + g_audioAdapterOut[i].portNum = g_audioAdapterDescs[i].portNum; + ret = AudioAdapterPortSync(g_audioAdapterOut[i].ports, + g_audioAdapterDescs[i].ports, g_audioAdapterOut[i].portNum); + if (ret != HDF_SUCCESS) { + LOG_FUN_ERR("port sync fail!\n"); + + return HDF_FAILURE; + } + } + } + + return HDF_SUCCESS; +} + static void AudioAdapterJudegReleaseDescs(const struct AudioAdapterDescriptor *desc) { + uint32_t portIdx; + if (desc == NULL) { return; } - uint32_t portIdx; + if (desc->adapterName != NULL) { AudioMemFree((void **)&desc->adapterName); } + if (desc->ports != NULL) { portIdx = 0; + if (desc->portNum <= 0 || desc->portNum > SUPPORT_PORT_NUM_MAX) { + LOG_FUN_ERR("desc->portNum error!\n"); + AudioMemFree((void **)&desc->ports); + + return; + } + while (portIdx < desc->portNum) { if (desc->ports[portIdx].portName != NULL) { AudioMemFree((void **)&desc->ports[portIdx].portName); @@ -84,24 +264,28 @@ static void AudioAdapterJudegReleaseDescs(const struct AudioAdapterDescriptor *d static void AudioAdapterReleaseDescs(struct AudioAdapterDescriptor *descs, int32_t adapterNum) { int32_t adapterIdx = 0; - if (descs == NULL) { + + if (descs == NULL || adapterNum <= 0 || adapterNum > SUPPORT_ADAPTER_NUM_MAX) { return; } + if (adapterNum > g_adapterNum) { adapterNum = g_adapterNum; } - if (adapterNum < 0) { - return; - } + while (adapterIdx < adapterNum) { AudioAdapterJudegReleaseDescs(&descs[adapterIdx]); adapterIdx++; } + AudioMemFree((void **)&descs); } static int32_t AudioAdapterGetDir(char *dir) { + if (dir == NULL) { + return HDF_FAILURE; + } if (strcmp(dir, "PORT_OUT") == 0) { return PORT_OUT; } else if (strcmp(dir, "PORT_IN") == 0) { @@ -109,96 +293,200 @@ static int32_t AudioAdapterGetDir(char *dir) } else if (strcmp(dir, "PORT_OUT_IN") == 0) { return PORT_OUT_IN; } else { - return -1; + return HDF_FAILURE; } } +static int32_t AudioAdaptersGetArraySize(cJSON *cJsonObj, int *size) +{ + int adapterArraySize; + + if (cJsonObj == NULL || size == NULL) { + LOG_FUN_ERR("Invalid parameter!\n"); + + return HDF_ERR_INVALID_PARAM; + } + + /* Follow the new adapterNum by the number of actual parses */ + adapterArraySize = cJSON_GetArraySize(cJsonObj); + if (adapterArraySize <= 0) { + LOG_FUN_ERR("Failed to get JSON array size!\n"); + + return HDF_FAILURE; + } + *size = adapterArraySize; + + return HDF_SUCCESS; +} + static int32_t AudioAdapterParsePort(struct AudioPort *info, cJSON *port) { int32_t ret; + uint32_t tmpId; cJSON *portDir = NULL; cJSON *portID = NULL; cJSON *portName = NULL; + + if (info == NULL || port == NULL) { + LOG_FUN_ERR("Invalid parameter!\n"); + + return HDF_ERR_INVALID_PARAM; + } + portDir = cJSON_GetObjectItem(port, "dir"); if (portDir == NULL) { return HDF_FAILURE; } - info->dir = AudioAdapterGetDir(portDir->valuestring); + ret = AudioAdapterGetDir(portDir->valuestring); + if (ret == HDF_FAILURE) { + LOG_FUN_ERR("port dir error!\n"); + + return ret; + } + info->dir = ret; + portID = cJSON_GetObjectItem(port, "id"); if (portID == NULL) { return HDF_FAILURE; } - info->portId = cJSON_GetNumberValue(portID); + tmpId = portID->valueint; + if (tmpId < 0 || tmpId > SUPPORT_PORT_ID_MAX) { + LOG_FUN_ERR("portID error!\n"); + + return HDF_FAILURE; + } + info->portId = (uint32_t)tmpId; + portName = cJSON_GetObjectItem(port, "name"); - if (portName == NULL) { + if (portName == NULL || portName->valuestring == NULL) { return HDF_FAILURE; } + ret = AudioAdapterCheckPortFlow(portName->valuestring); + if (ret != HDF_SUCCESS) { + LOG_FUN_ERR("Port name error!\n"); + + return ret; + } info->portName = (char *)calloc(1, PORT_NAME_LEN); if (info->portName == NULL) { - return -ENOMEM; + LOG_FUN_ERR("Out of memory\n"); + + return HDF_ERR_MALLOC_FAIL; } ret = memcpy_s((void *)info->portName, PORT_NAME_LEN, portName->valuestring, strlen(portName->valuestring)); if (ret != EOK) { LOG_FUN_ERR("memcpy_s port name fail"); + return HDF_FAILURE; } + return HDF_SUCCESS; } -static int32_t AudioAdapterParseAdapter(struct AudioAdapterDescriptor *desc, cJSON *adapter) +static int32_t AudioAdapterParsePorts(struct AudioAdapterDescriptor *desc, cJSON *adapter) { uint32_t i; - int32_t ret; + int32_t ret, tmpNum; cJSON *adapterPort = NULL; - cJSON *adapterName = cJSON_GetObjectItem(adapter, "name"); - if (adapterName == NULL) { - return HDF_FAILURE; - } - desc->adapterName = (char *)calloc(1, ADAPTER_NAME_LEN); - if (desc->adapterName == NULL) { - return -ENOMEM; - } - ret = memcpy_s((void *)desc->adapterName, ADAPTER_NAME_LEN, - adapterName->valuestring, strlen(adapterName->valuestring)); - if (ret != EOK) { - LOG_FUN_ERR("memcpy_s adapter name fail"); - return HDF_FAILURE; + int32_t realSize = 0; + if (desc == NULL || adapter == NULL) { + LOG_FUN_ERR("Invalid parameter!\n"); + + return HDF_ERR_INVALID_PARAM; } cJSON *adapterPortNum = cJSON_GetObjectItem(adapter, "portnum"); if (adapterPortNum == NULL) { return HDF_FAILURE; } - desc->portNum = cJSON_GetNumberValue(adapterPortNum); - if (desc->portNum == 0) { - LOG_FUN_ERR("no port info"); + tmpNum = cJSON_GetNumberValue(adapterPortNum); + if (tmpNum <= 0 || tmpNum > SUPPORT_PORT_NUM_MAX) { + LOG_FUN_ERR("portnum error!\n"); + return HDF_FAILURE; } + desc->portNum = (uint32_t)tmpNum; + cJSON *adapterPorts = cJSON_GetObjectItem(adapter, "port"); if (adapterPorts == NULL) { return HDF_FAILURE; } + ret = AudioAdaptersGetArraySize(adapterPorts, &realSize); + if (ret != HDF_SUCCESS || realSize != desc->portNum) { + LOG_FUN_ERR("realSize = %d, portNum = %d.\n", realSize, desc->portNum); + LOG_FUN_ERR("The defined portnum does not match the actual portnum!\n"); + + return HDF_FAILURE; + } + desc->ports = (struct AudioPort *)calloc(1, desc->portNum * sizeof(struct AudioPort)); if (desc->ports == NULL) { - LOG_FUN_ERR("calloc adapterPorts failed"); - return -ENOMEM; + LOG_FUN_ERR("Out of memory!\n"); + + return HDF_ERR_MALLOC_FAIL; } for (i = 0; i < desc->portNum; i++) { adapterPort = cJSON_GetArrayItem(adapterPorts, i); if (adapterPort) { ret = AudioAdapterParsePort(&desc->ports[i], adapterPort); if (ret != HDF_SUCCESS) { - return HDF_FAILURE; + return ret; } } } return HDF_SUCCESS; } -cJSON *AudioAdaptersGetConfigToJsonObj(const char *fpath) +static int32_t AudioAdapterParseAdapter(struct AudioAdapterDescriptor *desc, + cJSON *adapter) +{ + int32_t ret; + + if (desc == NULL || adapter == NULL) { + LOG_FUN_ERR("Invalid parameter!\n"); + + return HDF_ERR_INVALID_PARAM; + } + + cJSON *adapterName = cJSON_GetObjectItem(adapter, "name"); + if (adapterName == NULL || adapterName->valuestring == NULL) { + return HDF_FAILURE; + } + ret = AudioAdapterCheckName(adapterName->valuestring); + if (ret != HDF_SUCCESS) { + LOG_FUN_ERR("The Adapter name is incorrect!\n"); + + return ret; + } + + desc->adapterName = (char *)calloc(1, ADAPTER_NAME_LEN); + if (desc->adapterName == NULL) { + LOG_FUN_ERR("Out of memory!\n"); + + return HDF_ERR_MALLOC_FAIL; + } + ret = memcpy_s((void *)desc->adapterName, ADAPTER_NAME_LEN, + adapterName->valuestring, strlen(adapterName->valuestring)); + if (ret != EOK) { + LOG_FUN_ERR("memcpy_s adapter name fail!\n"); + + return HDF_FAILURE; + } + + ret = AudioAdapterParsePorts(desc, adapter); + if (ret != HDF_SUCCESS) { + return ret; + } + + return HDF_SUCCESS; +} + +static char *AudioAdaptersGetConfig(const char *fpath) { char *pJsonStr = NULL; - if (fpath == NULL) { + + if (fpath == NULL || access(fpath, F_OK | R_OK)) { + /* The file path is bad or unreadable */ return NULL; } FILE *fp = fopen(fpath, "r"); @@ -207,14 +495,18 @@ cJSON *AudioAdaptersGetConfigToJsonObj(const char *fpath) return NULL; } fseek(fp, 0, SEEK_END); - uint32_t jsonStrSize = ftell(fp); + int32_t jsonStrSize = ftell(fp); + if (jsonStrSize <= 0) { + fclose(fp); + return NULL; + } rewind(fp); - if (jsonStrSize > CONFIG_SIEZ_MAX) { + if (jsonStrSize > CONFIG_FILE_SIZE_MAX) { LOG_FUN_ERR("The configuration file is too large to load!\n"); fclose(fp); return NULL; } - pJsonStr = (char *)calloc(1, jsonStrSize); + pJsonStr = (char *)calloc(1, (uint32_t)jsonStrSize); if (NULL == pJsonStr) { fclose(fp); return NULL; @@ -222,11 +514,19 @@ cJSON *AudioAdaptersGetConfigToJsonObj(const char *fpath) if (fread(pJsonStr, jsonStrSize, 1, fp) != 1) { LOG_FUN_ERR("read to file fail!"); fclose(fp); - fp = NULL; AudioMemFree((void **)&pJsonStr); return NULL; } fclose(fp); + return pJsonStr; +} + +cJSON *AudioAdaptersGetConfigToJsonObj(const char *fpath) +{ + char *pJsonStr = AudioAdaptersGetConfig(fpath); + if (pJsonStr == NULL) { + return NULL; + } cJSON *cJsonObj = cJSON_Parse(pJsonStr); if (cJsonObj == NULL) { AudioMemFree((void **)&pJsonStr); @@ -238,9 +538,9 @@ cJSON *AudioAdaptersGetConfigToJsonObj(const char *fpath) cJSON_Delete(cJsonObj); return NULL; } - g_adapterNum = cJSON_GetNumberValue(adapterNum); - if (g_adapterNum == 0) { - LOG_FUN_ERR("no adapter info"); + g_adapterNum = adapterNum->valueint; + if (g_adapterNum <= 0 || g_adapterNum > SUPPORT_ADAPTER_NUM_MAX) { + LOG_FUN_ERR("Adapter number error!\n"); cJSON_Delete(cJsonObj); return NULL; } @@ -252,73 +552,181 @@ static int32_t AudioAdaptersSetAdapter(struct AudioAdapterDescriptor **descs, { int32_t i, ret; cJSON *adapterObj = NULL; - if (adaptersObj == NULL || adapterNum <= 0) { - return HDF_FAILURE; + + if (descs == NULL || adaptersObj == NULL || + adapterNum <= 0 || adapterNum > SUPPORT_ADAPTER_NUM_MAX) { + LOG_FUN_ERR("Invalid parameter!\n"); + + return HDF_ERR_INVALID_PARAM; } if (*descs != NULL) { /* Existing content is no longer assigned twice */ return HDF_SUCCESS; } + *descs = (struct AudioAdapterDescriptor *)calloc(1, adapterNum * sizeof(struct AudioAdapterDescriptor)); if (*descs == NULL) { LOG_FUN_ERR("calloc g_audioAdapterDescs failed"); - return -ENOMEM; + + return HDF_ERR_MALLOC_FAIL; } + for (i = 0; i < adapterNum; i++) { adapterObj = cJSON_GetArrayItem(adaptersObj, i); if (adapterObj) { ret = AudioAdapterParseAdapter(&(*descs)[i], adapterObj); if (ret != HDF_SUCCESS) { AudioAdapterReleaseDescs(*descs, adapterNum); + *descs = NULL; + return HDF_FAILURE; } } } + return HDF_SUCCESS; } +static void AudioAdaptersNamesRepair(void) +{ + int i, realNum; + + if (g_audioAdapterOut == NULL || + g_audioAdapterDescs == NULL || g_adapterNum <= 0) { + return; + } + + realNum = (g_adapterNum < SUPPORT_ADAPTER_NUM_MAX) ? g_adapterNum : SUPPORT_ADAPTER_NUM_MAX; + for (i = 0; i < realNum; i++) { + if (g_adaptersName[i] == NULL) { + return; + } + + if (strcmp(g_audioAdapterOut[i].adapterName, g_audioAdapterDescs[i].adapterName)) { + /* Retrieve the location of the port name */ + g_audioAdapterOut[i].adapterName = g_adaptersName[i]; + } + } +} + +static void AudioPortsNamesRepair(void) +{ + int i, j, adapterNum, portNum; + + if (g_audioAdapterOut == NULL || + g_audioAdapterDescs == NULL || g_adapterNum <= 0) { + return; + } + + adapterNum = (g_adapterNum < SUPPORT_ADAPTER_NUM_MAX) ? g_adapterNum : SUPPORT_ADAPTER_NUM_MAX; + for (i = 0; i < adapterNum; i++) { + portNum = (g_audioAdapterOut[i].portNum < SUPPORT_PORT_NUM_MAX) ? + g_audioAdapterOut[i].portNum : SUPPORT_PORT_NUM_MAX; + for (j = 0; j < portNum; j++) { + if (g_portsName[i][j] == NULL) { + return; + } + if (strcmp(g_audioAdapterOut[i].ports[j].portName, g_audioAdapterDescs[i].ports[j].portName)) { + /* Retrieve the location of the sound card name */ + g_audioAdapterOut[i].ports[j].portName = g_portsName[i][j]; + } + } + } +} + +static void AudioAdaptersNamesRecord(void) +{ + int i, currentNum; + + if (g_audioAdapterOut == NULL || + g_audioAdapterDescs == NULL || g_adapterNum <= 0) { + return; + } + + currentNum = (g_adapterNum < SUPPORT_ADAPTER_NUM_MAX) ? g_adapterNum : SUPPORT_ADAPTER_NUM_MAX; + for (i = 0; i < currentNum; i++) { + /* Record the location of the sound card name */ + g_adaptersName[i] = g_audioAdapterOut[i].adapterName; + } +} + +static void AudioPortsNamesRecord(void) +{ + int i, j, adapterCurNum, portCurNum; + + if (g_audioAdapterOut == NULL || g_audioAdapterDescs == NULL || g_adapterNum <= 0) { + return; + } + + adapterCurNum = (g_adapterNum < SUPPORT_ADAPTER_NUM_MAX) ? g_adapterNum : SUPPORT_ADAPTER_NUM_MAX; + for (i = 0; i < adapterCurNum; i++) { + portCurNum = (g_audioAdapterOut[i].portNum < SUPPORT_PORT_NUM_MAX) ? + g_audioAdapterOut[i].portNum : SUPPORT_PORT_NUM_MAX; + for (j = 0; j < portCurNum; j++) { + /* Record the location of the port name */ + g_portsName[i][j] = g_audioAdapterOut[i].ports[j].portName; + } + } +} + int32_t AudioAdaptersForUser(struct AudioAdapterDescriptor **descs, int *size) { - int ret; + int32_t realSize; if (descs == NULL || size == NULL) { - return HDF_FAILURE; + return HDF_ERR_INVALID_PARAM; } if (g_audioAdapterDescs != NULL && g_audioAdapterOut != NULL && - g_adapterNum > 0) { + g_adapterNum > 0 && g_adapterNum <= SUPPORT_ADAPTER_NUM_MAX) { + AudioAdaptersNamesRepair(); + AudioPortsNamesRepair(); /* Existing content is no longer assigned twice */ *descs = g_audioAdapterOut; *size = g_adapterNum; + return HDF_SUCCESS; } cJSON *cJsonObj = AudioAdaptersGetConfigToJsonObj(AUDIO_ADAPTER_CONFIG); if (cJsonObj == NULL) { - LOG_FUN_ERR("cJsonObj is NULL!"); return HDF_FAILURE; } cJSON *adaptersObj = cJSON_GetObjectItem(cJsonObj, "adapters"); if (adaptersObj == NULL) { cJSON_Delete(cJsonObj); + return HDF_FAILURE; } - ret = AudioAdaptersSetAdapter(&g_audioAdapterDescs, g_adapterNum, adaptersObj); - if (ret != HDF_SUCCESS) { + if (AudioAdaptersGetArraySize(adaptersObj, &realSize) != HDF_SUCCESS || realSize != g_adapterNum) { + LOG_FUN_ERR("realSize = %d, adaptersNum = %d.\n", realSize, g_adapterNum); + LOG_FUN_ERR("The defined adaptersnum does not match the actual adapters!\n"); g_adapterNum = 0; cJSON_Delete(cJsonObj); + return HDF_FAILURE; } - ret = AudioAdaptersSetAdapter(&g_audioAdapterOut, g_adapterNum, adaptersObj); - if (ret != HDF_SUCCESS) { + if (AudioAdaptersSetAdapter(&g_audioAdapterDescs, g_adapterNum, adaptersObj) != HDF_SUCCESS) { + g_adapterNum = 0; + cJSON_Delete(cJsonObj); + + return HDF_FAILURE; + } + if (AudioAdaptersSetAdapter(&g_audioAdapterOut, g_adapterNum, adaptersObj) != HDF_SUCCESS) { /* g_audioAdapterOut failure also releases g_audioAdapterDescs */ AudioAdapterReleaseDescs(g_audioAdapterDescs, g_adapterNum); + ClearAdaptersAllName(); + g_audioAdapterDescs = NULL; g_adapterNum = 0; cJSON_Delete(cJsonObj); + return HDF_FAILURE; } + AudioAdaptersNamesRecord(); + AudioPortsNamesRecord(); *descs = g_audioAdapterOut; *size = g_adapterNum; cJSON_Delete(cJsonObj); + return HDF_SUCCESS; } @@ -341,7 +749,7 @@ int32_t HdmiPortInit(struct AudioPort portIndex, struct AudioPortCapability *cap capabilityIndex->subPorts = (struct AudioSubPortCapability *)calloc(capabilityIndex->subPortsNum, sizeof(struct AudioSubPortCapability)); if (capabilityIndex->subPorts == NULL) { - LOG_FUN_ERR("capabilityIndex->subPorts is NULL!"); + LOG_FUN_ERR("The pointer is null!"); return HDF_FAILURE; } capabilityIndex->subPorts->portId = portIndex.portId; @@ -350,3 +758,327 @@ int32_t HdmiPortInit(struct AudioPort portIndex, struct AudioPortCapability *cap return HDF_SUCCESS; } +int32_t FormatToBits(enum AudioFormat format, uint32_t *formatBits) +{ + if (formatBits == NULL) { + return HDF_FAILURE; + } + switch (format) { + case AUDIO_FORMAT_PCM_32_BIT: + *formatBits = BIT_NUM_32; + return HDF_SUCCESS; + case AUDIO_FORMAT_PCM_24_BIT: + *formatBits = BIT_NUM_24; + return HDF_SUCCESS; + case AUDIO_FORMAT_PCM_16_BIT: + *formatBits = BIT_NUM_16; + return HDF_SUCCESS; + case AUDIO_FORMAT_PCM_8_BIT: + *formatBits = BIT_NUM_8; + return HDF_SUCCESS; + default: + return HDF_ERR_NOT_SUPPORT; + } +} + +int32_t BitsToFormat(enum AudioFormat *format, int32_t formatBits) +{ + if (format == NULL) { + return HDF_FAILURE; + } + switch (formatBits) { + case BIT_NUM_32: + *format = AUDIO_FORMAT_PCM_32_BIT; + return HDF_SUCCESS; + case BIT_NUM_24: + *format = AUDIO_FORMAT_PCM_24_BIT; + return HDF_SUCCESS; + case BIT_NUM_16: + *format = AUDIO_FORMAT_PCM_16_BIT; + return HDF_SUCCESS; + case BIT_NUM_8: + *format = AUDIO_FORMAT_PCM_8_BIT; + return HDF_SUCCESS; + default: + return HDF_ERR_NOT_SUPPORT; + } +} + +int32_t CheckAttrRoute(int32_t param) +{ + if (param < DEEP_BUFF || param > LOW_LATRNCY) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t CheckAttrChannel(uint32_t param) +{ + if (param != 1 && param != 2) { // channel 1 and 2 + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t TransferRoute(char *value, int32_t *route) +{ + if (value == NULL || route == NULL) { + return HDF_FAILURE; + } + char *endptr = NULL; + errno = 0; + int32_t tempRoute = strtol(value, &endptr, DECIMAL_SYSTEM); + if ((errno == ERANGE && (tempRoute == LONG_MAX || tempRoute == LONG_MIN)) || (errno != 0 && tempRoute == 0)) { + return HDF_FAILURE; + } + int32_t ret = CheckAttrRoute(tempRoute); + if (ret == 0) { + *route = tempRoute; + } + return ret; +} + +int32_t TransferFormat(char *value, int32_t *format) +{ + if (value == NULL || format == NULL) { + return HDF_FAILURE; + } + char *endptr = NULL; + errno = 0; + int32_t tempFormat = strtol(value, &endptr, DECIMAL_SYSTEM); + if ((errno == ERANGE && (tempFormat == LONG_MAX || tempFormat == LONG_MIN)) || (errno != 0 && tempFormat == 0)) { + return HDF_FAILURE; + } + enum AudioFormat audioFormat; + int32_t ret = BitsToFormat(&audioFormat, tempFormat); + if (ret == HDF_SUCCESS) { + ret = CheckAttrFormat(audioFormat); + if (ret == 0) { + *format = audioFormat; + } + } + return ret; +} + +int32_t TransferChannels(char *value, uint32_t *channels) +{ + if (value == NULL || channels == NULL) { + return HDF_FAILURE; + } + char *endptr = NULL; + errno = 0; + int32_t tempChannels = strtoul(value, &endptr, DECIMAL_SYSTEM); + if ((errno == ERANGE && (tempChannels == ULONG_MAX)) || (errno != 0 && tempChannels == 0)) { + return HDF_FAILURE; + } + int32_t ret = CheckAttrChannel(tempChannels); + if (ret == 0) { + *channels = tempChannels; + } + return ret; +} + +int32_t TransferFrames(char *value, uint64_t *frames) +{ + if (value == NULL || frames == NULL) { + return HDF_FAILURE; + } + char *endptr = NULL; + errno = 0; + uint64_t tempFrames = strtoull(value, &endptr, 10); + if ((errno == ERANGE && (tempFrames == ULLONG_MAX)) || (errno != 0 && tempFrames == 0)) { + return HDF_FAILURE; + } else { + *frames = tempFrames; + return HDF_SUCCESS; + } +} + +int32_t TransferSampleRate(char *value, uint32_t *sampleRate) +{ + if (value == NULL || sampleRate == NULL) { + return HDF_FAILURE; + } + char *endptr = NULL; + errno = 0; + uint32_t tempSampleRate = strtoul(value, &endptr, DECIMAL_SYSTEM); + if ((errno == ERANGE && (tempSampleRate == ULONG_MAX)) || (errno != 0 && tempSampleRate == 0)) { + return HDF_FAILURE; + } + int32_t ret = CheckAttrSamplingRate(tempSampleRate); + if (ret == 0) { + *sampleRate = tempSampleRate; + } + return ret; +} + +int32_t KeyValueListToMap(const char *keyValueList, struct ParamValMap mParamValMap[], int32_t *count) +{ + if (NULL == keyValueList || mParamValMap == NULL || NULL == count) { + return HDF_FAILURE; + } + int i = 0; + char *mParaMap[MAP_MAX]; + char buffer[ERROR_REASON_DESC_LEN] = {0}; + int32_t ret = sprintf_s(buffer, ERROR_REASON_DESC_LEN - 1, "%s", keyValueList); + if (ret < 0) { + LOG_FUN_ERR("sprintf_s failed!"); + return HDF_FAILURE; + } + char *tempBuf = buffer; + char *outPtr = NULL; + char *inPtr = NULL; + while (((mParaMap[i] = strtok_r(tempBuf, ";", &outPtr)) != NULL) && i < MAP_MAX) { + tempBuf = mParaMap[i]; + if ((mParaMap[i] = strtok_r(tempBuf, "=", &inPtr)) != NULL) { + ret = strncpy_s(mParamValMap[i].key, EXTPARAM_LEN - 1, mParaMap[i], strlen(mParaMap[i]) + 1); + if (ret != 0) { + return HDF_FAILURE; + } + tempBuf = NULL; + } + if ((mParaMap[i] = strtok_r(tempBuf, "=", &inPtr)) != NULL) { + ret = strncpy_s(mParamValMap[i].value, EXTPARAM_LEN - 1, mParaMap[i], strlen(mParaMap[i]) + 1); + if (ret != 0) { + return HDF_FAILURE; + } + tempBuf = NULL; + } + tempBuf = NULL; + i++; + } + *count = i; + return HDF_SUCCESS; +} + +int32_t AddElementToList(char *keyValueList, int32_t listLenth, const char *key, void *value) +{ + if (NULL == keyValueList || NULL == key || NULL == value) { + return HDF_FAILURE; + } + int32_t ret = HDF_FAILURE; + char strValue[MAP_MAX] = { 0 }; + if (strcmp(key, AUDIO_ATTR_PARAM_ROUTE) == 0) { + ret = sprintf_s(strValue, sizeof(strValue), "%s=%d;", key, *((int32_t *)value)); + } else if (strcmp(key, AUDIO_ATTR_PARAM_FORMAT) == 0) { + uint32_t formatBits = 0; + ret = FormatToBits((enum AudioFormat)(*((int32_t *)value)), &formatBits); + if (ret == 0) { + ret = sprintf_s(strValue, sizeof(strValue), "%s=%u;", key, formatBits); + } + } else if (strcmp(key, AUDIO_ATTR_PARAM_CHANNELS) == 0) { + ret = sprintf_s(strValue, sizeof(strValue), "%s=%u;", key, *((uint32_t *)value)); + } else if (strcmp(key, AUDIO_ATTR_PARAM_FRAME_COUNT) == 0) { + ret = sprintf_s(strValue, sizeof(strValue), "%s=%llu;", key, *((uint64_t *)value)); + } else if (strcmp(key, AUDIO_ATTR_PARAM_SAMPLING_RATE) == 0) { + ret = sprintf_s(strValue, sizeof(strValue), "%s=%u", key, *((uint32_t *)value)); + } else { + LOG_FUN_ERR("NO this key correspond value!"); + return HDF_FAILURE; + } + if (ret < 0) { + LOG_FUN_ERR("sprintf_s failed!"); + return HDF_FAILURE; + } + ret = strncat_s(keyValueList, listLenth - 1, strValue, strlen(strValue)); + if (ret < 0) { + LOG_FUN_ERR("strcat_s failed!"); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t SetExtParam(const char *key, char *value, struct ExtraParams *mExtraParams) +{ + if (key == NULL || value == NULL || mExtraParams == NULL) { + return HDF_FAILURE; + } + int ret = HDF_FAILURE; + if (strcmp(key, AUDIO_ATTR_PARAM_ROUTE) == 0) { + int32_t route; + ret = TransferRoute(value, &route); + if (ret < 0) { + return HDF_FAILURE; + } + mExtraParams->route = route; + } else if (strcmp(key, AUDIO_ATTR_PARAM_FORMAT) == 0) { + int32_t format; + ret = TransferFormat(value, &format); + if (ret < 0) { + return HDF_FAILURE; + } + mExtraParams->format = format; + } else if (strcmp(key, AUDIO_ATTR_PARAM_CHANNELS) == 0) { + uint32_t channels; + ret = TransferChannels(value, &channels); + if (ret < 0) { + return HDF_FAILURE; + } + mExtraParams->channels = channels; + } else if (strcmp(key, AUDIO_ATTR_PARAM_FRAME_COUNT) == 0) { + uint64_t frames; + ret = TransferFrames(value, &frames); + if (ret < 0) { + return HDF_FAILURE; + } + mExtraParams->frames = frames; + mExtraParams->flag = true; + } else if (strcmp(key, AUDIO_ATTR_PARAM_SAMPLING_RATE) == 0) { + uint32_t sampleRate = 0; + ret = TransferSampleRate(value, &sampleRate); + if (ret < 0) { + return HDF_FAILURE; + } + mExtraParams->sampleRate = sampleRate; + } else { + LOG_FUN_ERR("NO this key correspond value or value is invalid!"); + return HDF_FAILURE; + } + return ret; +} + +int32_t GetErrorReason(int reason, char *reasonDesc) +{ + int32_t ret; + if (NULL == reasonDesc) { + return HDF_FAILURE; + } + switch (reason) { + case HDF_FAILURE: + ret = snprintf_s(reasonDesc, ERROR_REASON_DESC_LEN - 1, strlen("NOT SUPPORT") + 1, "%s", "NOT SUPPORT"); + break; + case HDF_ERR_NOT_SUPPORT: + ret = snprintf_s(reasonDesc, ERROR_REASON_DESC_LEN - 1, strlen("BUFFER FULL") + 1, "%s", "BUFFER FULL"); + break; + default: + ret = snprintf_s(reasonDesc, ERROR_REASON_DESC_LEN - 1, strlen("UNKNOW") + 1, "%s", "UNKNOW"); + break; + } + if (ret < 0) { + LOG_FUN_ERR("sprintf_s failed!"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} +int32_t GetCurrentTime(char *currentTime) +{ + if (NULL == currentTime) { + return HDF_FAILURE; + } + // Get the current time + char *week[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}; + time_t timeSec; + time(&timeSec); + struct tm *specificTime = localtime(&timeSec); + int32_t ret = sprintf_s(currentTime, ERROR_REASON_DESC_LEN - 1, "%d/%d/%d %s %d:%d:%d", + (TIME_BASE_YEAR_1900 + specificTime->tm_year), (1 + specificTime->tm_mon), specificTime->tm_mday, + week[specificTime->tm_wday], specificTime->tm_hour, specificTime->tm_min, specificTime->tm_sec); + if (ret < 0) { + LOG_FUN_ERR("sprintf_s failed!"); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + diff --git a/audio/hal/hdi_passthrough/src/audio_capture.c b/audio/hal/hdi_passthrough/src/audio_capture.c index 379a50d38d..7e4c1880cd 100755 --- a/audio/hal/hdi_passthrough/src/audio_capture.c +++ b/audio/hal/hdi_passthrough/src/audio_capture.c @@ -79,7 +79,7 @@ int32_t AudioCaptureStart(AudioHandle handle) return HDF_FAILURE; } hwCapture->captureParam.frameCaptureMode.buffer = tbuffer; - LOG_PARA_INFO("Capture Start SUCCESS!"); + AudioLogRecord(INFO, "[%s]-[%s]-[%d] :> [%s]", __FILE__, __func__, __LINE__, "Audio Capture Start"); return HDF_SUCCESS; } @@ -97,7 +97,6 @@ int32_t AudioCaptureStop(AudioHandle handle) if (hwCapture->captureParam.frameCaptureMode.buffer != NULL) { AudioMemFree((void **)&hwCapture->captureParam.frameCaptureMode.buffer); } else { - LOG_FUN_ERR("AudioCapture already stop!"); return HDF_ERR_INVALID_OBJECT; } InterfaceLibModeCaptureSo *pInterfaceLibModeCapture = AudioSoGetInterfaceLibModeCapture(); @@ -111,7 +110,7 @@ int32_t AudioCaptureStop(AudioHandle handle) LOG_FUN_ERR("AudioCaptureStart SetParams FAIL"); return HDF_FAILURE; } - LOG_PARA_INFO("Capture Stop SUCCESS!"); + AudioLogRecord(INFO, "[%s]-[%s]-[%d] :> [%s]", __FILE__, __func__, __LINE__, "Audio Capture Stop"); return HDF_SUCCESS; } @@ -148,6 +147,7 @@ int32_t AudioCapturePause(AudioHandle handle) hwCapture->captureParam.captureMode.ctlParam.pause = pauseStatus; return HDF_FAILURE; } + AudioLogRecord(INFO, "[%s]-[%s]-[%d] :> [%s]", __FILE__, __func__, __LINE__, "Audio Capture Pause"); return HDF_SUCCESS; } @@ -180,6 +180,7 @@ int32_t AudioCaptureResume(AudioHandle handle) hwCapture->captureParam.captureMode.ctlParam.pause = resumeStatus; return HDF_FAILURE; } + AudioLogRecord(INFO, "[%s]-[%s]-[%d] :> [%s]", __FILE__, __func__, __LINE__, "Audio Capture Resume"); return HDF_SUCCESS; } @@ -407,7 +408,7 @@ int32_t AudioCaptureSetMute(AudioHandle handle, bool mute) impl->captureParam.captureMode.ctlParam.mute = muteStatus; return HDF_FAILURE; } - LOG_PARA_INFO("SetMute SUCCESS!"); + AudioLogRecord(INFO, "[%s]-[%s]-[%d] :> [Setmute = %d]", __FILE__, __func__, __LINE__, mute); return HDF_SUCCESS; } @@ -596,19 +597,37 @@ int32_t AudioCaptureSetGain(AudioHandle handle, float gain) return HDF_SUCCESS; } -int32_t TimeToAudioTimeStampCapture(int64_t *totalTime, struct AudioTimeStamp *time) +void LogErrorCapture(AudioHandle handle, int errorCode, int reason) { - if (totalTime == NULL || time == NULL) { - return HDF_FAILURE; + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL) { + return; } - time->tvSec += (int64_t)(*totalTime) / SEC_TO_NSEC; - time->tvNSec += (int64_t)(*totalTime) % SEC_TO_NSEC; - int64_t carryBit = (int64_t)(time->tvNSec) / SEC_TO_NSEC; - if (carryBit) { - time->tvSec += carryBit; - time->tvNSec -= (int64_t)carryBit * SEC_TO_NSEC; + hwCapture->errorLog.totalErrors++; + if (hwCapture->errorLog.iter >= ERROR_LOG_MAX_NUM) { + hwCapture->errorLog.iter = 0; + } + char reasonDesc[ERROR_REASON_DESC_LEN] = {0}; + int32_t ret = GetErrorReason(reason, &reasonDesc); + if (ret < 0) { + LOG_FUN_ERR("Capture GetErrorReason failed!"); + return; + } + char time[ERROR_REASON_DESC_LEN] = {0}; + ret = GetCurrentTime(&time); + if (ret < 0) { + LOG_FUN_ERR("GetCurrentTime failed!"); + return; + } + if (errorCode == WRITE_FRAME_ERROR_CODE) { + hwCapture->errorLog.errorDump[hwCapture->errorLog.iter].errorCode = errorCode; + hwCapture->errorLog.errorDump[hwCapture->errorLog.iter].count = hwCapture->errorLog.iter; + hwCapture->errorLog.errorDump[hwCapture->errorLog.iter].frames = + hwCapture->captureParam.frameCaptureMode.frames; + hwCapture->errorLog.errorDump[hwCapture->errorLog.iter].reason = reasonDesc; + hwCapture->errorLog.errorDump[hwCapture->errorLog.iter].currentTime = time; + hwCapture->errorLog.iter++; } - return HDF_SUCCESS; } int32_t AudioCaptureCaptureFrame(struct AudioCapture *capture, void *frame, @@ -629,11 +648,11 @@ int32_t AudioCaptureCaptureFrame(struct AudioCapture *capture, void *frame, if (hwCapture->devDataHandle == NULL) { return HDF_FAILURE; } - memset_s(hwCapture->captureParam.frameCaptureMode.buffer, FRAME_DATA, 0, FRAME_DATA); int32_t ret = (*pInterfaceLibModeCapture)(hwCapture->devDataHandle, &hwCapture->captureParam, AUDIO_DRV_PCM_IOCTL_READ); if (ret < 0) { LOG_FUN_ERR("Capture Frame FAIL!"); + LogErrorCapture(capture, WRITE_FRAME_ERROR_CODE, ret); return HDF_FAILURE; } if (requestBytes < hwCapture->captureParam.frameCaptureMode.bufferSize) { @@ -652,9 +671,9 @@ int32_t AudioCaptureCaptureFrame(struct AudioCapture *capture, void *frame, LOG_FUN_ERR("Divisor cannot be zero!"); return HDF_FAILURE; } - int64_t totalTime = (hwCapture->captureParam.frameCaptureMode.bufferFrameSize * SEC_TO_NSEC) / - (int64_t)hwCapture->captureParam.frameCaptureMode.attrs.sampleRate; - if (TimeToAudioTimeStampCapture(&totalTime, &hwCapture->captureParam.frameCaptureMode.time) == HDF_FAILURE) { + if (TimeToAudioTimeStamp(hwCapture->captureParam.frameCaptureMode.bufferFrameSize, + &hwCapture->captureParam.frameCaptureMode.time, + hwCapture->captureParam.frameCaptureMode.attrs.sampleRate) == HDF_FAILURE) { LOG_FUN_ERR("Frame is NULL"); return HDF_FAILURE; } @@ -670,6 +689,220 @@ int32_t AudioCaptureGetCapturePosition(struct AudioCapture *capture, uint64_t *f } *frames = impl->captureParam.frameCaptureMode.frames; *time = impl->captureParam.frameCaptureMode.time; + return HDF_SUCCESS; +} + +int32_t SetValueCapture(struct ExtraParams mExtraParams, struct AudioHwCapture *capture) +{ + if (capture == NULL) { + return HDF_FAILURE; + } + if (mExtraParams.route != -1) { + capture->captureParam.captureMode.hwInfo.pathroute = mExtraParams.route; + } + if (mExtraParams.format != -1) { + capture->captureParam.frameCaptureMode.attrs.format = mExtraParams.format; + } + if (mExtraParams.channels != 0) { + capture->captureParam.frameCaptureMode.attrs.channelCount = mExtraParams.channels; + } + if (mExtraParams.flag) { + capture->captureParam.frameCaptureMode.frames = mExtraParams.frames; + } + if (mExtraParams.sampleRate != 0) { + capture->captureParam.frameCaptureMode.attrs.sampleRate = mExtraParams.sampleRate; + } + return HDF_SUCCESS; +} + +int32_t AudioCaptureSetExtraParams(AudioHandle handle, const char *keyValueList) +{ + struct AudioHwCapture *capture = (struct AudioHwCapture *)handle; + if (capture == NULL || keyValueList == NULL) { + return HDF_FAILURE; + } + + struct ParamValMap mParamValMap[MAP_MAX]; + int32_t count = 0; + int32_t ret = KeyValueListToMap(keyValueList, mParamValMap, &count); + if (ret < 0) { + LOG_FUN_ERR("Convert to map FAIL!"); + return HDF_FAILURE; + } + int index = 0; + int32_t sumOk = 0; + struct ExtraParams mExtraParams; + mExtraParams.route = -1; + mExtraParams.format = -1; + mExtraParams.channels = 0; + mExtraParams.frames = 0; + mExtraParams.sampleRate = 0; + mExtraParams.flag = false; + while (index < count) { + ret = SetExtParam(mParamValMap[index].key, mParamValMap[index].value, &mExtraParams); + if (ret < 0) { + return HDF_FAILURE; + } else { + sumOk++; + } + index++; + } + if (count != 0 && sumOk == count) { + SetValueCapture(mExtraParams, capture); + return HDF_SUCCESS; + } else { + return HDF_FAILURE; + } +} + +int32_t AudioCaptureGetExtraParams(AudioHandle handle, char *keyValueList, int32_t listLenth) +{ + struct AudioHwCapture *capture = (struct AudioHwCapture *)handle; + if (capture == NULL || keyValueList == NULL || listLenth <= 0) { + return HDF_FAILURE; + } + int32_t bufferSize = strlen(ROUTE_SAMPLE) + strlen(FORMAT_SAMPLE) + strlen(CHANNELS_SAMPLE) + + strlen(FRAME_COUNT_SAMPLE) + strlen(SAMPLING_RATE_SAMPLE); + if (listLenth < bufferSize) { + return HDF_FAILURE; + } + int32_t ret = AddElementToList(keyValueList, listLenth, AUDIO_ATTR_PARAM_ROUTE, + &capture->captureParam.captureMode.hwInfo.pathroute); + if (ret < 0) { + return HDF_FAILURE; + } + ret = AddElementToList(keyValueList, listLenth, + AUDIO_ATTR_PARAM_FORMAT, &capture->captureParam.frameCaptureMode.attrs.format); + if (ret < 0) { + return HDF_FAILURE; + } + ret = AddElementToList(keyValueList, listLenth, AUDIO_ATTR_PARAM_CHANNELS, + &capture->captureParam.frameCaptureMode.attrs.channelCount); + if (ret < 0) { + return HDF_FAILURE; + } + ret = AddElementToList(keyValueList, listLenth, AUDIO_ATTR_PARAM_FRAME_COUNT, + &capture->captureParam.frameCaptureMode.frames); + if (ret < 0) { + return HDF_FAILURE; + } + ret = AddElementToList(keyValueList, listLenth, AUDIO_ATTR_PARAM_SAMPLING_RATE, + &capture->captureParam.frameCaptureMode.attrs.sampleRate); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCaptureReqMmapBuffer(AudioHandle handle, int32_t reqSize, struct AudioMmapBufferDescripter *desc) +{ + struct AudioHwCapture *capture = (struct AudioHwCapture *)handle; + if (capture == NULL || capture->devDataHandle == NULL || desc == NULL) { + return HDF_FAILURE; + } + int32_t flags; + if (desc->isShareable) { + flags = MAP_SHARED; + } else { + flags = MAP_PRIVATE; + } + uint32_t formatBits = 0; + int32_t ret = FormatToBits(capture->captureParam.frameCaptureMode.attrs.format, &formatBits); + if (ret < 0) { + return ret; + } + + desc->memoryAddress = mmap(NULL, reqSize, PROT_READ | PROT_WRITE, flags, desc->memoryFd, 0); + if (desc->memoryAddress == NULL || desc->memoryAddress == (void *)-1) { + LOG_FUN_ERR("AudioCaptureReqMmapBuffer mmap FAIL and errno is:%d !", errno); + return HDF_FAILURE; + } + // formatBits Move right 3 + desc->totalBufferFrames = + reqSize / (capture->captureParam.frameCaptureMode.attrs.channelCount * (formatBits >> 3)); + InterfaceLibModeCaptureSo *pInterfaceLibModeCapture = AudioSoGetInterfaceLibModeCapture(); + if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) { + LOG_FUN_ERR("pInterfaceLibModeCapture Is NULL"); + munmap(desc->memoryAddress, reqSize); + return HDF_FAILURE; + } + capture->captureParam.frameCaptureMode.mmapBufDesc.memoryAddress = desc->memoryAddress; + capture->captureParam.frameCaptureMode.mmapBufDesc.memoryFd = desc->memoryFd; + capture->captureParam.frameCaptureMode.mmapBufDesc.totalBufferFrames = desc->totalBufferFrames; + capture->captureParam.frameCaptureMode.mmapBufDesc.transferFrameSize = desc->transferFrameSize; + capture->captureParam.frameCaptureMode.mmapBufDesc.isShareable = desc->isShareable; + capture->captureParam.frameCaptureMode.mmapBufDesc.offset = desc->offset; + ret = (*pInterfaceLibModeCapture)(capture->devDataHandle, &capture->captureParam, + AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER_CAPTURE); + if (ret < 0) { + LOG_FUN_ERR("AudioCaptureReqMmapBuffer FAIL!"); + munmap(desc->memoryAddress, reqSize); + return HDF_FAILURE; + } + LOG_PARA_INFO("AudioCaptureReqMmapBuffer Success!"); + return HDF_SUCCESS; +} +int32_t AudioCaptureGetMmapPosition(AudioHandle handle, uint64_t *frames, struct AudioTimeStamp *time) +{ + struct AudioHwCapture *capture = (struct AudioHwCapture *)handle; + if (capture == NULL || frames == NULL || time == NULL) { + return HDF_FAILURE; + } + *frames = capture->captureParam.frameCaptureMode.frames; + capture->captureParam.frameCaptureMode.time.tvSec = capture->captureParam.frameCaptureMode.frames / + (int64_t)capture->captureParam.frameCaptureMode.attrs.sampleRate; + int64_t lastBufFrames = capture->captureParam.frameCaptureMode.frames % + ((int64_t)capture->captureParam.frameCaptureMode.attrs.sampleRate); + capture->captureParam.frameCaptureMode.time.tvNSec = + (lastBufFrames * SEC_TO_NSEC) / ((int64_t)capture->captureParam.frameCaptureMode.attrs.sampleRate); + *time = capture->captureParam.frameCaptureMode.time; return HDF_SUCCESS; } + +int32_t AudioCaptureTurnStandbyMode(AudioHandle handle) +{ + struct AudioHwCapture *capture = (struct AudioHwCapture *)handle; + if (capture == NULL) { + return HDF_FAILURE; + } + capture->captureParam.captureMode.hwInfo.deviceDescript.pins = PIN_NONE; + int32_t ret = AudioCaptureStop((AudioHandle)capture); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCaptureAudioDevDump(AudioHandle handle, int32_t range, int32_t fd) +{ + struct AudioHwCapture *capture = (struct AudioHwCapture *)handle; + if (capture == NULL) { + return HDF_FAILURE; + } + dprintf(fd, "%s%d\n", "Number of errors: ", capture->errorLog.totalErrors); + if (range < RANGE_MIN - 1 || range > RANGE_MAX) { + dprintf(fd, "%s%d\n", "Out of range, invalid output"); + return HDF_SUCCESS; + } + uint32_t mSize = capture->errorLog.iter; + if (range < RANGE_MIN) { + dprintf(fd, "%-5s %-10s %s\n", "count", "errorCode", "Time"); + for (int i = 0; i < mSize; i++) { + dprintf(fd, FORMAT_TWO, capture->errorLog.errorDump[i].count + 1, + capture->errorLog.errorDump[i].errorCode, + capture->errorLog.errorDump[i].currentTime); + } + } else { + dprintf(fd, "%-5s %-10s %-20s %-15s %s\n", "count", "errorCode", "frames", "fail reason", "Time"); + for (int i = 0; i < mSize; i++) { + dprintf(fd, FORMAT_ONE, capture->errorLog.errorDump[i].count + 1, + capture->errorLog.errorDump[i].errorCode, + capture->errorLog.errorDump[i].frames, + capture->errorLog.errorDump[i].reason, + capture->errorLog.errorDump[i].currentTime); + } + } + return HDF_SUCCESS; +} + diff --git a/audio/hal/hdi_passthrough/src/audio_common.c b/audio/hal/hdi_passthrough/src/audio_common.c index 69691b1b01..43fb3cac8d 100755 --- a/audio/hal/hdi_passthrough/src/audio_common.c +++ b/audio/hal/hdi_passthrough/src/audio_common.c @@ -46,17 +46,29 @@ int32_t AudioGetSysTime(char *s, int32_t len) return ret; } -int32_t AudioCheckParaAttr(const struct AudioSampleAttributes *attrs) +int32_t CheckAttrSamplingRate(uint32_t param) { - if (NULL == attrs) { - return HDF_FAILURE; - } - enum AudioCategory audioCategory = attrs->type; - if (AUDIO_IN_MEDIA != audioCategory && AUDIO_IN_COMMUNICATION != audioCategory) { - return HDF_ERR_NOT_SUPPORT; + switch (param) { + case TELHPONE_RATE: + case BROADCAST_AM_RATE: + case BROADCAST_FM_RATE: + case MINI_CAM_DV_RATE: + case MUSIC_RATE: + case HIGHT_MUSIC_RATE: + case AUDIO_SAMPLE_RATE_12000: + case AUDIO_SAMPLE_RATE_16000: + case AUDIO_SAMPLE_RATE_24000: + case AUDIO_SAMPLE_RATE_64000: + case AUDIO_SAMPLE_RATE_96000: + return HDF_SUCCESS; + default: + return HDF_ERR_NOT_SUPPORT; } - enum AudioFormat audioFormat = attrs->format; - switch (audioFormat) { +} + +int32_t CheckAttrFormat(enum AudioFormat param) +{ + switch (param) { case AUDIO_FORMAT_PCM_8_BIT: case AUDIO_FORMAT_PCM_16_BIT: case AUDIO_FORMAT_PCM_24_BIT: @@ -71,16 +83,65 @@ int32_t AudioCheckParaAttr(const struct AudioSampleAttributes *attrs) default: return HDF_ERR_NOT_SUPPORT; } + return HDF_SUCCESS; +} + +int32_t AudioCheckParaAttr(const struct AudioSampleAttributes *attrs) +{ + if (NULL == attrs) { + return HDF_FAILURE; + } + int32_t ret; + enum AudioCategory audioCategory = attrs->type; + if (AUDIO_IN_MEDIA != audioCategory && AUDIO_IN_COMMUNICATION != audioCategory) { + return HDF_ERR_NOT_SUPPORT; + } + enum AudioFormat audioFormat = attrs->format; + ret = CheckAttrFormat(audioFormat); + if (ret < 0) { + return ret; + } uint32_t sampleRateTemp = attrs->sampleRate; - switch (sampleRateTemp) { - case TELHPONE_RATE: - case BROADCAST_AM_RATE: - case BROADCAST_FM_RATE: - case MINI_CAM_DV_RATE: - case MUSIC_RATE: - case HIGHT_MUSIC_RATE: - return HDF_SUCCESS; - default: - return HDF_ERR_NOT_SUPPORT; + return CheckAttrSamplingRate(sampleRateTemp); +} + +int32_t TimeToAudioTimeStamp(uint64_t bufferFrameSize, struct AudioTimeStamp *time, uint32_t sampleRate) +{ + if (time == NULL) { + return HDF_FAILURE; + } + time->tvSec += bufferFrameSize / (int64_t)sampleRate; + int64_t lastBufFrames = bufferFrameSize % ((int64_t)sampleRate); + time->tvNSec += (lastBufFrames * SEC_TO_NSEC) / ((int64_t)sampleRate); + if (time->tvNSec >= SEC_TO_NSEC) { + time->tvSec += 1; + time->tvNSec -= SEC_TO_NSEC; } + return HDF_SUCCESS; +} + +void AudioLogRecord(int errorLevel, const char *format, ...) +{ + va_list args; + FILE *fp = NULL; + char timeStr[TIME_LEN]; + char fileName[FILE_NAME_LEN]; + va_start(args, format); + time_t timeLog = time(NULL); + strftime(fileName, sizeof(fileName), "//data/%Y-%m-%d_audio_history.log", localtime(&timeLog)); + if (fileName[0] == '\0') { + va_end(args); + return; + } + if ((fp = fopen(fileName, "a+")) != NULL) { + strftime(timeStr, sizeof(timeStr), "%Y-%m-%d %H:%M:%S", localtime(&timeLog)); + if (errorLevel == (int)INFO) { + fprintf(fp, "[%s]-[%s]", timeStr, "INFO"); + vfprintf(fp, format, args); + fprintf(fp, "\n"); + } + fclose(fp); + } + va_end(args); + return; } diff --git a/audio/hal/hdi_passthrough/src/audio_manager.c b/audio/hal/hdi_passthrough/src/audio_manager.c index e1dd08bd29..78dc41d8b5 100755 --- a/audio/hal/hdi_passthrough/src/audio_manager.c +++ b/audio/hal/hdi_passthrough/src/audio_manager.c @@ -97,7 +97,7 @@ int32_t InitCaptureSoHandle(const char *captureSoPath) if (g_ptrCaptureHandle == NULL) { g_ptrCaptureHandle = dlopen(captureSoPath, RTLD_LAZY); if (g_ptrCaptureHandle == NULL) { - LOG_FUN_ERR("open lib capture so fail"); + LOG_FUN_ERR("open lib capture so fail, reason:%s", dlerror()); return HDF_FAILURE; } g_bindServiceCapture = dlsym(g_ptrCaptureHandle, "AudioBindServiceCapture"); @@ -121,7 +121,7 @@ int32_t InitRenderSoHandle(const char *renderSoPath) if (g_ptrRenderHandle == NULL) { g_ptrRenderHandle = dlopen(renderSoPath, RTLD_LAZY); if (g_ptrRenderHandle == NULL) { - LOG_FUN_ERR("open lib render so fail"); + LOG_FUN_ERR("open lib render so fail, reason:%s", dlerror()); return HDF_FAILURE; } g_bindServiceRender = dlsym(g_ptrRenderHandle, "AudioBindServiceRender"); @@ -146,7 +146,7 @@ int32_t InitPathSelectSoHandle(const char *pathSelectSoPath) if (g_ptrPathSelHandle == NULL) { g_ptrPathSelHandle = dlopen(pathSelectSoPath, RTLD_LAZY); if (g_ptrPathSelHandle == NULL) { - LOG_FUN_ERR("open lib render so fail"); + LOG_FUN_ERR("open lib PathSelct so fail, reason:%s", dlerror()); return HDF_FAILURE; } g_pathSelGetConfToJsonObj = dlsym(g_ptrPathSelHandle, "AudioPathSelGetConfToJsonObj"); @@ -234,6 +234,8 @@ int32_t AudioManagerLoadAdapter(struct AudioManager *manager, const struct Audio hwAdapter->common.GetPassthroughMode = AudioAdapterGetPassthroughMode; *adapter = &hwAdapter->common; hwAdapter->adapterDescriptor = *desc; + hwAdapter->adapterMgrRenderFlag = 0; // The adapterMgrRenderFlag init is zero + hwAdapter->adapterMgrCaptureFlag = 0; // The adapterMgrCaptureFlag init is zero return HDF_SUCCESS; } diff --git a/audio/hal/hdi_passthrough/src/audio_render.c b/audio/hal/hdi_passthrough/src/audio_render.c index 20161f2f77..9f8fb89b6e 100755 --- a/audio/hal/hdi_passthrough/src/audio_render.c +++ b/audio/hal/hdi_passthrough/src/audio_render.c @@ -28,29 +28,6 @@ #define DEEP_BUFFER_PLATFORM_DELAY (29*1000LL) #define LOW_LATENCY_PLATFORM_DELAY (13*1000LL) -int32_t FormatToBits(enum AudioFormat format, uint32_t *formatBits) -{ - if (formatBits == NULL) { - return HDF_FAILURE; - } - switch (format) { - case AUDIO_FORMAT_PCM_32_BIT: - *formatBits = BIT_NUM_32; - return HDF_SUCCESS; - case AUDIO_FORMAT_PCM_24_BIT: - *formatBits = BIT_NUM_24; - return HDF_SUCCESS; - case AUDIO_FORMAT_PCM_16_BIT: - *formatBits = BIT_NUM_16; - return HDF_SUCCESS; - case AUDIO_FORMAT_PCM_8_BIT: - *formatBits = BIT_NUM_8; - return HDF_SUCCESS; - default: - return HDF_ERR_NOT_SUPPORT; - } -} - int32_t PcmBytesToFrames(const struct AudioFrameRenderMode *frameRenderMode, uint64_t bytes, uint32_t *frameCount) { if (frameRenderMode == NULL || frameCount == NULL) { @@ -61,8 +38,11 @@ int32_t PcmBytesToFrames(const struct AudioFrameRenderMode *frameRenderMode, uin if (ret != HDF_SUCCESS) { return ret; } - *frameCount = bytes / (frameRenderMode->attrs.channelCount * - (formatBits >> 3)); // Adapter num max is 3 + uint32_t frameSize = frameRenderMode->attrs.channelCount * (formatBits >> 3); // Bit to byte >> 3 + if (frameSize == 0) { + return HDF_FAILURE; + } + *frameCount = bytes / frameSize; return HDF_SUCCESS; } @@ -96,7 +76,7 @@ int32_t AudioRenderStart(AudioHandle handle) return HDF_FAILURE; } hwRender->renderParam.frameRenderMode.buffer = buffer; - LOG_PARA_INFO("Render Start SUCCESS!"); + AudioLogRecord(INFO, "[%s]-[%s]-[%d] :> [%s]", __FILE__, __func__, __LINE__, "Audio Render Start"); return HDF_SUCCESS; } @@ -110,7 +90,6 @@ int32_t AudioRenderStop(AudioHandle handle) if (hwRender->renderParam.frameRenderMode.buffer != NULL) { AudioMemFree((void **)&hwRender->renderParam.frameRenderMode.buffer); } else { - LOG_FUN_ERR("AudioRender already stop!"); return HDF_ERR_INVALID_OBJECT; } if (hwRender->devDataHandle == NULL) { @@ -128,12 +107,12 @@ int32_t AudioRenderStop(AudioHandle handle) LOG_FUN_ERR("AudioRenderStart SetParams FAIL"); return HDF_FAILURE; } + AudioLogRecord(INFO, "[%s]-[%s]-[%d] :> [%s]", __FILE__, __func__, __LINE__, "Audio Render Stop"); return HDF_SUCCESS; } int32_t AudioRenderPause(AudioHandle handle) { - LOG_FUN_INFO(); struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; if (hwRender == NULL) { return HDF_FAILURE; @@ -164,6 +143,7 @@ int32_t AudioRenderPause(AudioHandle handle) hwRender->renderParam.renderMode.ctlParam.pause = pauseStatus; return HDF_FAILURE; } + AudioLogRecord(INFO, "[%s]-[%s]-[%d] :> [%s]", __FILE__, __func__, __LINE__, "Audio Render Pause"); return HDF_SUCCESS; } @@ -196,6 +176,7 @@ int32_t AudioRenderResume(AudioHandle handle) hwRender->renderParam.renderMode.ctlParam.pause = resumeStatus; return HDF_FAILURE; } + AudioLogRecord(INFO, "[%s]-[%s]-[%d] :> [%s]", __FILE__, __func__, __LINE__, "Audio Render Resume"); return HDF_SUCCESS; } @@ -239,7 +220,7 @@ int32_t AudioRenderGetFrameCount(AudioHandle handle, uint64_t *count) int32_t AudioRenderSetSampleAttributes(AudioHandle handle, const struct AudioSampleAttributes *attrs) { struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; - if (hwRender == NULL || attrs == NULL) { + if (hwRender == NULL || attrs == NULL || hwRender->devDataHandle == NULL) { return HDF_FAILURE; } int32_t ret = AudioCheckParaAttr(attrs); @@ -415,7 +396,7 @@ int32_t AudioRenderSetMute(AudioHandle handle, bool mute) impl->renderParam.renderMode.ctlParam.mute = muteStatus; return HDF_FAILURE; } - LOG_PARA_INFO("SetMute SUCCESS!"); + AudioLogRecord(INFO, "[%s]-[%s]-[%d] :> [Setmute = %d]", __FILE__, __func__, __LINE__, mute); return HDF_SUCCESS; } @@ -508,6 +489,10 @@ int32_t AudioRenderGetVolume(AudioHandle handle, float *volume) float volumeTemp = hwRender->renderParam.renderMode.ctlParam.volume; float volMax = (float)hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax; float volMin = (float)hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin; + if ((volMax - volMin) == 0) { + LOG_FUN_ERR("Divisor cannot be zero!"); + return HDF_FAILURE; + } volumeTemp = (volumeTemp - volMin) / ((volMax - volMin) / 2); int volumeT = (int)((pow(10, volumeTemp) + 5) / 10); // delet 0.X num *volume = (float)volumeT / 10; // get volume (0-1) @@ -606,22 +591,65 @@ int32_t AudioRenderGetLatency(struct AudioRender *render, uint32_t *ms) uint32_t byteRate = impl->renderParam.frameRenderMode.byteRate; uint32_t periodSize = impl->renderParam.frameRenderMode.periodSize; uint32_t periodCount = impl->renderParam.frameRenderMode.periodCount; + if (byteRate == 0) { + return HDF_FAILURE; + } uint32_t period_ms = (periodCount * periodSize * 1000) / byteRate; *ms = period_ms; return HDF_SUCCESS; } -int32_t TimeToAudioTimeStamp(int64_t *totalTime, struct AudioTimeStamp *time) +void LogError(AudioHandle handle, int32_t errorCode, int reason) +{ + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL) { + return; + } + hwRender->errorLog.totalErrors++; + if (hwRender->errorLog.iter >= ERROR_LOG_MAX_NUM) { + hwRender->errorLog.iter = 0; + } + char reasonDesc[ERROR_REASON_DESC_LEN] = {0}; + int32_t ret = GetErrorReason(reason, &reasonDesc); + if (ret < 0) { + LOG_FUN_ERR("GetErrorReason failed!"); + return; + } + char time[ERROR_REASON_DESC_LEN] = {0}; + ret = GetCurrentTime(&time); + if (ret < 0) { + LOG_FUN_ERR("GetCurrentTime Fail"); + return; + } + if (errorCode == WRITE_FRAME_ERROR_CODE) { + hwRender->errorLog.errorDump[hwRender->errorLog.iter].errorCode = errorCode; + hwRender->errorLog.errorDump[hwRender->errorLog.iter].count = hwRender->errorLog.iter; + hwRender->errorLog.errorDump[hwRender->errorLog.iter].frames = hwRender->renderParam.frameRenderMode.frames; + hwRender->errorLog.errorDump[hwRender->errorLog.iter].reason = reasonDesc; + hwRender->errorLog.errorDump[hwRender->errorLog.iter].currentTime = time; + hwRender->errorLog.iter++; + } +} + +int32_t AudioRenderRenderFramSplit(struct AudioHwRender *hwRender) { - if (totalTime == NULL || time == NULL) { + int32_t ret; + if (hwRender == NULL) { + return HDF_FAILURE; + } + InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender(); + if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) { + LOG_FUN_ERR("pInterfaceLibModeRender Is NULL"); + return HDF_FAILURE; + } + if (hwRender->devDataHandle == NULL) { return HDF_FAILURE; } - time->tvSec += (int64_t)(*totalTime) / SEC_TO_NSEC; - time->tvNSec += (int64_t)(*totalTime) % SEC_TO_NSEC; - int64_t carryBit = (int64_t)(time->tvNSec) / SEC_TO_NSEC; - if (carryBit) { - time->tvSec += carryBit; - time->tvNSec -= (int64_t)carryBit * SEC_TO_NSEC; + ret = (*pInterfaceLibModeRender)(hwRender->devDataHandle, &hwRender->renderParam, + AUDIO_DRV_PCM_IOCTL_WRITE); + if (ret < 0) { + LOG_FUN_ERR("Render Frame FAIL!"); + LogError((AudioHandle)hwRender, WRITE_FRAME_ERROR_CODE, ret); } return HDF_SUCCESS; } @@ -640,8 +668,7 @@ int32_t AudioRenderRenderFrame(struct AudioRender *render, const void *frame, LOG_FUN_ERR("Out of FRAME_DATA size!"); return HDF_FAILURE; } - memset_s(hwRender->renderParam.frameRenderMode.buffer, FRAME_DATA, 0, FRAME_DATA); - int32_t ret = memcpy_s(hwRender->renderParam.frameRenderMode.buffer, FRAME_DATA, frame, requestBytes); + int32_t ret = memcpy_s(hwRender->renderParam.frameRenderMode.buffer, FRAME_DATA, frame, (uint32_t)requestBytes); if (ret != EOK) { LOG_FUN_ERR("memcpy_s fail"); return HDF_FAILURE; @@ -653,24 +680,18 @@ int32_t AudioRenderRenderFrame(struct AudioRender *render, const void *frame, return ret; } hwRender->renderParam.frameRenderMode.bufferFrameSize = (uint64_t)frameCount; - InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender(); - if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) { - LOG_FUN_ERR("pInterfaceLibModeRender Is NULL"); + if (AudioRenderRenderFramSplit(hwRender) < 0) { return HDF_FAILURE; } - if (hwRender->devDataHandle == NULL) { - return HDF_FAILURE; - } - ret = (*pInterfaceLibModeRender)(hwRender->devDataHandle, &hwRender->renderParam, - AUDIO_DRV_PCM_IOCTL_WRITE); - if (ret < 0) { - LOG_FUN_ERR("Render Frame FAIL!"); - } *replyBytes = requestBytes; hwRender->renderParam.frameRenderMode.frames += hwRender->renderParam.frameRenderMode.bufferFrameSize; - int64_t totalTime = (hwRender->renderParam.frameRenderMode.bufferFrameSize * SEC_TO_NSEC) / - ((int64_t)hwRender->renderParam.frameRenderMode.attrs.sampleRate); - if (TimeToAudioTimeStamp(&totalTime, &hwRender->renderParam.frameRenderMode.time) == HDF_FAILURE) { + if (hwRender->renderParam.frameRenderMode.attrs.sampleRate == 0) { + LOG_FUN_ERR("Divisor cannot be zero!"); + return HDF_FAILURE; + } + if (TimeToAudioTimeStamp(hwRender->renderParam.frameRenderMode.bufferFrameSize, + &hwRender->renderParam.frameRenderMode.time, + hwRender->renderParam.frameRenderMode.attrs.sampleRate) == HDF_FAILURE) { LOG_FUN_ERR("Frame is NULL"); return HDF_FAILURE; } @@ -741,7 +762,7 @@ int32_t AudioRenderGetChannelMode(struct AudioRender *render, enum AudioChannelM { LOG_FUN_INFO(); struct AudioHwRender *impl = (struct AudioHwRender *)render; - if (impl == NULL || mode == NULL) { + if (impl == NULL || mode == NULL || impl->devCtlHandle == NULL) { return HDF_FAILURE; } InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender(); @@ -757,3 +778,266 @@ int32_t AudioRenderGetChannelMode(struct AudioRender *render, enum AudioChannelM *mode = impl->renderParam.frameRenderMode.mode; return HDF_SUCCESS; } + +int32_t SetValue(struct ExtraParams mExtraParams, struct AudioHwRender *render) +{ + if (render == NULL) { + return HDF_FAILURE; + } + if (mExtraParams.route != -1) { + render->renderParam.renderMode.hwInfo.pathroute = mExtraParams.route; + } + if (mExtraParams.format != -1) { + render->renderParam.frameRenderMode.attrs.format = mExtraParams.format; + } + if (mExtraParams.channels != 0) { + render->renderParam.frameRenderMode.attrs.channelCount = mExtraParams.channels; + } + if (mExtraParams.flag) { + render->renderParam.frameRenderMode.frames = mExtraParams.frames; + } + if (mExtraParams.sampleRate != 0) { + render->renderParam.frameRenderMode.attrs.sampleRate = mExtraParams.sampleRate; + } + return HDF_SUCCESS; +} + +int32_t AudioRenderSetExtraParams(AudioHandle handle, const char *keyValueList) +{ + struct AudioHwRender *render = (struct AudioHwRender *)handle; + if (render == NULL || keyValueList == NULL) { + return HDF_FAILURE; + } + + struct ParamValMap mParamValMap[MAP_MAX]; + int32_t count = 0; + int32_t ret = KeyValueListToMap(keyValueList, mParamValMap, &count); + if (ret < 0) { + LOG_FUN_ERR("Convert to map FAIL!"); + return HDF_FAILURE; + } + int index = 0; + int32_t sumOk = 0; + struct ExtraParams mExtraParams; + mExtraParams.route = -1; + mExtraParams.format = -1; + mExtraParams.channels = 0; + mExtraParams.frames = 0; + mExtraParams.sampleRate = 0; + mExtraParams.flag = false; + while (index < count) { + ret = SetExtParam(mParamValMap[index].key, mParamValMap[index].value, &mExtraParams); + if (ret < 0) { + return HDF_FAILURE; + } else { + sumOk++; + } + index++; + } + if (count != 0 && sumOk == count) { + SetValue(mExtraParams, render); + return HDF_SUCCESS; + } else { + return HDF_FAILURE; + } +} + +int32_t AudioRenderGetExtraParams(AudioHandle handle, char *keyValueList, int32_t listLenth) +{ + struct AudioHwRender *render = (struct AudioHwRender *)handle; + if (render == NULL || keyValueList == NULL || listLenth <= 0) { + return HDF_FAILURE; + } + int32_t bufferSize = strlen(ROUTE_SAMPLE) + strlen(FORMAT_SAMPLE) + strlen(CHANNELS_SAMPLE) + + strlen(FRAME_COUNT_SAMPLE) + strlen(SAMPLING_RATE_SAMPLE); + if (listLenth < bufferSize) { + return HDF_FAILURE; + } + int32_t ret = AddElementToList(keyValueList, listLenth, AUDIO_ATTR_PARAM_ROUTE, + &render->renderParam.renderMode.hwInfo.pathroute); + if (ret < 0) { + return HDF_FAILURE; + } + ret = AddElementToList(keyValueList, listLenth, AUDIO_ATTR_PARAM_FORMAT, + &render->renderParam.frameRenderMode.attrs.format); + if (ret < 0) { + return HDF_FAILURE; + } + ret = AddElementToList(keyValueList, listLenth, AUDIO_ATTR_PARAM_CHANNELS, + &render->renderParam.frameRenderMode.attrs.channelCount); + if (ret < 0) { + return HDF_FAILURE; + } + ret = AddElementToList(keyValueList, listLenth, AUDIO_ATTR_PARAM_FRAME_COUNT, + &render->renderParam.frameRenderMode.frames); + if (ret < 0) { + return HDF_FAILURE; + } + ret = AddElementToList(keyValueList, listLenth, AUDIO_ATTR_PARAM_SAMPLING_RATE, + &render->renderParam.frameRenderMode.attrs.sampleRate); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioRenderReqMmapBuffer(AudioHandle handle, int32_t reqSize, struct AudioMmapBufferDescripter *desc) +{ + struct AudioHwRender *render = (struct AudioHwRender *)handle; + if (render == NULL || render->devDataHandle == NULL || desc == NULL) { + return HDF_FAILURE; + } + int32_t flags; + if (desc->isShareable) { + flags = MAP_SHARED; + } else { + flags = MAP_PRIVATE; + } + uint32_t formatBits = 0; + int32_t ret = FormatToBits(render->renderParam.frameRenderMode.attrs.format, &formatBits); + if (ret < 0) { + return ret; + } + if (reqSize <= 0) { + return HDF_FAILURE; + } + desc->memoryAddress = mmap(NULL, reqSize, PROT_READ | PROT_WRITE, flags, desc->memoryFd, 0); + if (desc->memoryAddress == NULL || desc->memoryAddress == (void *)-1) { + LOG_FUN_ERR("AudioRenderReqMmapBuffer mmap FAIL and errno is:%d !", errno); + return HDF_FAILURE; + } + desc->totalBufferFrames = reqSize / (render->renderParam.frameRenderMode.attrs.channelCount * (formatBits >> 3)); + InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender(); + if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) { + LOG_FUN_ERR("pInterfaceLibModeRender Is NULL"); + munmap(desc->memoryAddress, reqSize); + return HDF_FAILURE; + } + render->renderParam.frameRenderMode.mmapBufDesc.memoryAddress = desc->memoryAddress; + render->renderParam.frameRenderMode.mmapBufDesc.memoryFd = desc->memoryFd; + render->renderParam.frameRenderMode.mmapBufDesc.totalBufferFrames = desc->totalBufferFrames; + render->renderParam.frameRenderMode.mmapBufDesc.transferFrameSize = desc->transferFrameSize; + render->renderParam.frameRenderMode.mmapBufDesc.isShareable = desc->isShareable; + render->renderParam.frameRenderMode.mmapBufDesc.offset = desc->offset; + ret = (*pInterfaceLibModeRender)(render->devDataHandle, &render->renderParam, AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER); + if (ret < 0) { + LOG_FUN_ERR("AudioRenderReqMmapBuffer FAIL!"); + munmap(desc->memoryAddress, reqSize); + return HDF_FAILURE; + } + LOG_PARA_INFO("AudioRenderReqMmapBuffer Success!"); + return HDF_SUCCESS; +} + +int32_t AudioRenderGetMmapPosition(AudioHandle handle, uint64_t *frames, struct AudioTimeStamp *time) +{ + struct AudioHwRender *render = (struct AudioHwRender *)handle; + if (render == NULL || frames == NULL || time == NULL) { + return HDF_FAILURE; + } + *frames = render->renderParam.frameRenderMode.frames; + render->renderParam.frameRenderMode.time.tvSec = render->renderParam.frameRenderMode.frames / + (int64_t)render->renderParam.frameRenderMode.attrs.sampleRate; + int64_t lastBufFrames = render->renderParam.frameRenderMode.frames % + ((int64_t)render->renderParam.frameRenderMode.attrs.sampleRate); + render->renderParam.frameRenderMode.time.tvNSec = + (lastBufFrames * SEC_TO_NSEC) / ((int64_t)render->renderParam.frameRenderMode.attrs.sampleRate); + *time = render->renderParam.frameRenderMode.time; + return HDF_SUCCESS; +} + +int32_t AudioRenderTurnStandbyMode(AudioHandle handle) +{ + struct AudioHwRender *render = (struct AudioHwRender *)handle; + if (render == NULL) { + return HDF_FAILURE; + } + int32_t ret = AudioRenderStop((AudioHandle)render); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioRenderAudioDevDump(AudioHandle handle, int32_t range, int32_t fd) +{ + struct AudioHwRender *render = (struct AudioHwRender *)handle; + if (render == NULL) { + return HDF_FAILURE; + } + dprintf(fd, "%s%d\n", "Number of errors: ", render->errorLog.totalErrors); + if (range < RANGE_MIN - 1 || range > RANGE_MAX) { + dprintf(fd, "%s\n", "Out of range, invalid output"); + return HDF_SUCCESS; + } + uint32_t mSize = render->errorLog.iter; + if (range < RANGE_MIN) { + dprintf(fd, "%-5s %-10s %s\n", "count", "errorCode", "Time"); + for (int i = 0; i < mSize; i++) { + dprintf(fd, FORMAT_TWO, render->errorLog.errorDump[i].count + 1, + render->errorLog.errorDump[i].errorCode, + render->errorLog.errorDump[i].currentTime); + } + } else { + dprintf(fd, "%-5s %-10s %-20s %-15s %s\n", "count", "errorCode", "frames", "fail reason", "Time"); + for (int i = 0; i < mSize; i++) { + dprintf(fd, FORMAT_ONE, render->errorLog.errorDump[i].count + 1, + render->errorLog.errorDump[i].errorCode, + render->errorLog.errorDump[i].frames, + render->errorLog.errorDump[i].reason, + render->errorLog.errorDump[i].currentTime); + } + } + return HDF_SUCCESS; +} +int32_t CallbackProcessing(AudioHandle handle, enum AudioCallbackType callBackType) +{ + struct AudioHwRender *render = (struct AudioHwRender *)handle; + if (render == NULL) { + LOG_PARA_INFO("Unregistered callback.\n"); + return HDF_FAILURE; + } + if (render->renderParam.frameRenderMode.callback == NULL) { + return HDF_FAILURE; + } + bool isCallBack = true; + switch (callBackType) { + case AUDIO_NONBLOCK_WRITE_COMPELETED: + case AUDIO_DRAIN_COMPELETED: + case AUDIO_FLUSH_COMPLETED: + case AUDIO_RENDER_FULL: + case AUDIO_ERROR_OCCUR: + isCallBack = true; + break; + default: + isCallBack = false; + break; + } + if (!isCallBack) { + LOG_PARA_INFO("No callback processing is required.\n"); + return HDF_ERR_NOT_SUPPORT; + } + render->renderParam.frameRenderMode.callback(callBackType, NULL, render->renderParam.frameRenderMode.cookie); + return HDF_SUCCESS; +} + +int32_t AudioRenderRegCallback(struct AudioRender *render, RenderCallback callback, void *cookie) +{ + struct AudioHwRender *pRender = (struct AudioHwRender *)render; + if (pRender == NULL) { + return HDF_FAILURE; + } + pRender->renderParam.frameRenderMode.callback = callback; + pRender->renderParam.frameRenderMode.cookie = cookie; + return HDF_SUCCESS; +} + +int32_t AudioRenderDrainBuffer(struct AudioRender *render, enum AudioDrainNotifyType *type) +{ + struct AudioHwRender *pRender = (struct AudioHwRender *)render; + if (pRender == NULL) { + return HDF_FAILURE; + } + return HDF_ERR_NOT_SUPPORT; +} + diff --git a/audio/hal/hdi_binder/server/src/BUILD.gn b/audio/hal/pathselect/BUILD.gn similarity index 31% rename from audio/hal/hdi_binder/server/src/BUILD.gn rename to audio/hal/pathselect/BUILD.gn index e412aeb88f..15161ba210 100755 --- a/audio/hal/hdi_binder/server/src/BUILD.gn +++ b/audio/hal/pathselect/BUILD.gn @@ -18,7 +18,7 @@ if (defined(ohos_lite)) { } import("//drivers/adapter/uhdf2/uhdf.gni") -config("hdi_service_config") { +config("pathseltct_config") { visibility = [ ":*" ] cflags = [ @@ -46,50 +46,88 @@ config("hdi_service_config") { ldflags = [ "-Wl" ] } -ohos_shared_library("audio_hdi_adapter_server") { - include_dirs = [ - "//drivers/peripheral/audio/interfaces/include", - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/hal/hdi_binder/server/include", - "$hdf_framework_path/include/core", - "$hdf_framework_path/include/utils", - "$hdf_framework_path/include/osal", - "$hdf_framework_path/include", - "//third_party/bounds_checking_function/include", - "$hdf_framework_path/ability/sbuf/include", - "$hdf_framework_path/utils/include", - "$hdf_framework_path/ability/sbuf/include", - "$hdf_uhdf_path/osal/include" - ] - - sources = [ - "hdf_audio_server.c", - "hdf_audio_server_capture.c", - "hdf_audio_server_common.c", - "hdf_audio_server_render.c", - ] - - deps = [ - "//drivers/peripheral/audio/hal/hdi_passthrough/src:hdi_audio", - "$hdf_uhdf_path/osal:libhdf_utils", - "$hdf_uhdf_path/manager:hdf_devmgr", - "$hdf_uhdf_path/manager:hdf_devmgr.rc", - "//utils/native/base:utils", - "$hdf_uhdf_path/hdi:libhdi", - "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", - "$hdf_uhdf_path/host:hdf_devhost", - "$hdf_uhdf_path/host:libhdf_host", - "$hdf_uhdf_path/config:libhdf_hcs", - "$hdf_uhdf_path/hcs:hdf_default.hcb", - ] +if (defined(ohos_lite)) { + shared_library("hdi_audio_path_select") { + sources = [ + "src/audio_pathselect.c", + "//third_party/cJSON/cJSON.c", + "$hdf_framework_path/support/posix/src/osal_time.c", + "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_common.c" + ] + + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/pathselect/include", + "//third_party/cJSON", + "$hdf_framework_path/include/core", + "$hdf_framework_path/include/utils", + "$hdf_framework_path/include/osal", + "$hdf_framework_path/ability/sbuf/include", + "$hdf_framework_path/utils/include", + "$hdf_framework_path/include", + "$hdf_framework_path/core/sec/include", + "$hdf_framework_path/core/shared/include", + "$hdf_framework_path/core/host/include", + "$hdf_framework_path/core/manager/include", + "$hdf_framework_path/core/common/include/host/", + "//drivers/peripheral/audio/interfaces/include", + "//third_party/bounds_checking_function/include", + "//drivers/adapter/khdf/liteos/osal/include", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/adapter/uhdf2/include/hdi/" + ] + + deps = [ + "//third_party/bounds_checking_function:libsec_shared" + ] - if (is_standard_system) { - external_deps = [ "hiviewdfx_hilog_native:libhilog" ] - } else { - external_deps = [ "hilog:libhilog" ] + public_configs = [ ":pathseltct_config" ] } +} else { + ohos_shared_library("hdi_audio_path_select") { + sources = [ + "//third_party/cJSON/cJSON.c", + "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_common.c", + "src/audio_pathselect.c", + ] + + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/pathselect/include", + "//third_party/cJSON", + "//drivers/peripheral/audio/interfaces/include", + "$hdf_framework_path/include/core", + "$hdf_framework_path/include/utils", + "$hdf_framework_path/include/osal", + "$hdf_framework_path/include", + "//third_party/bounds_checking_function/include", + "$hdf_framework_path/ability/sbuf/include", + "$hdf_framework_path/utils/include", + "$hdf_framework_path/ability/sbuf/include", + "$hdf_uhdf_path/osal/include" + ] + + deps = [ + "$hdf_uhdf_path/osal:libhdf_utils", + "$hdf_uhdf_path/manager:hdf_devmgr", + "$hdf_uhdf_path/manager:hdf_devmgr.rc", + "//utils/native/base:utils", + "$hdf_uhdf_path/hdi:libhdi", + "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", + "$hdf_uhdf_path/host:hdf_devhost", + "$hdf_uhdf_path/host:libhdf_host", + "$hdf_uhdf_path/config:libhdf_hcs", + "$hdf_uhdf_path/hcs:hdf_default.hcb", + ] - public_configs = [ ":hdi_service_config" ] + if (is_standard_system) { + external_deps = [ "hiviewdfx_hilog_native:libhilog" ] + } else { + external_deps = [ "hilog:libhilog" ] + } - subsystem_name = "hdf" + public_configs = [ ":pathseltct_config" ] + + subsystem_name = "hdf" + } } \ No newline at end of file diff --git a/audio/hal/pathselect/include/audio_pathselect.h b/audio/hal/pathselect/include/audio_pathselect.h index 969b1596e8..6efee8888b 100755 --- a/audio/hal/pathselect/include/audio_pathselect.h +++ b/audio/hal/pathselect/include/audio_pathselect.h @@ -16,16 +16,16 @@ #ifndef AUDIO_PATHSELECT_H #define AUDIO_PATHSELECT_H -#include -#include -#include -#include #include "audio_types.h" #include "audio_common.h" #include "audio_internal.h" #include "cJSON.h" +#ifdef __LITEOS__ +#define CJSONFILE_CONFIG_PATH "/etc/parse.json" +#else #define CJSONFILE_CONFIG_PATH "/system/etc/hdfconfig/parse.json" +#endif int32_t AudioPathSelGetConfToJsonObj(); int32_t AudioPathSelAnalysisJson(void *adapterParam, enum AudioAdaptType adaptType); diff --git a/audio/hal/pathselect/src/audio_pathselect.c b/audio/hal/pathselect/src/audio_pathselect.c index 555592aa18..72af806b7c 100755 --- a/audio/hal/pathselect/src/audio_pathselect.c +++ b/audio/hal/pathselect/src/audio_pathselect.c @@ -21,7 +21,7 @@ #define HS_MIC "micHs" #define JSON_UNPRINT 1 -static cJSON *g_cJsonObj; +static cJSON *g_cJsonObj = NULL; /* Depend on Audio_types.h : enum AudioCategory */ enum AudioCategoryPathSel { @@ -45,7 +45,6 @@ enum AudioPortPinPathSel { int32_t AudioPathSelGetConfToJsonObj() { - LOG_FUN_INFO(); FILE *fpJson = NULL; char *pJsonStr = NULL; fpJson = fopen(CJSONFILE_CONFIG_PATH, "r"); @@ -60,6 +59,10 @@ int32_t AudioPathSelGetConfToJsonObj() } int32_t jsonStrSize = ftell(fpJson); rewind(fpJson); + if (jsonStrSize <= 0) { + fclose(fpJson); + return HDF_FAILURE; + } pJsonStr = (char *)calloc(1, jsonStrSize); if (NULL == pJsonStr) { fclose(fpJson); @@ -144,7 +147,7 @@ static int32_t AudioPathSelGetPlanRenderScene(struct AudioHwRenderParam *renderS return HDF_FAILURE; } if (snprintf_s(pathName, sizeof(pathName), sizeof(pathName) - 1, "%s %s", useCase, deviceType) < 0) { - LOG_FUN_ERR("snprintf_s failed!"); + LOG_FUN_ERR("snprintf_s Invalid!"); return HDF_FAILURE; } if (g_cJsonObj == NULL) { @@ -153,12 +156,12 @@ static int32_t AudioPathSelGetPlanRenderScene(struct AudioHwRenderParam *renderS } cJSON *pathNode = cJSON_GetObjectItem(g_cJsonObj, pathName); if (pathNode == NULL) { - LOG_FUN_ERR("Get Object Fail!"); + LOG_FUN_ERR("Get Object Invalid!"); return HDF_ERR_NOT_SUPPORT; } cJSON *deviceNode = cJSON_GetObjectItem(g_cJsonObj, deviceType); if (deviceNode == NULL) { - LOG_FUN_ERR("Get Object Fail!"); + LOG_FUN_ERR("Get Object Invalid!"); return HDF_ERR_NOT_SUPPORT; } ret = strncpy_s(renderSceneParam->renderMode.hwInfo.pathSelect.useCase, @@ -233,14 +236,12 @@ static int32_t AudioPathSelGetPlanCaptureScene(struct AudioHwCaptureParam *captu static int32_t AudioCapturePathSelGetUsecaseDevice(struct AudioHwCaptureParam *captureParam, const char *pathName) { - LOG_FUN_INFO(); if (captureParam == NULL || pathName == NULL || g_cJsonObj == NULL) { LOG_FUN_ERR("AudioCapturePathSelGetUsecaseDevice param Is NULL"); return HDF_FAILURE; } int32_t pathIndex = 0; char *pathKey = NULL; - int32_t pathValue; int32_t ret; cJSON *pathNode = cJSON_GetObjectItem(g_cJsonObj, pathName); if (pathNode == NULL) { @@ -255,7 +256,7 @@ static int32_t AudioCapturePathSelGetUsecaseDevice(struct AudioHwCaptureParam *c while (pathList != NULL) { cJSON *device = cJSON_GetObjectItem(pathList, "name"); if (device == NULL) { - LOG_FUN_ERR("Get Object Fail!"); + LOG_FUN_ERR("Get Object Invalid!"); return HDF_FAILURE; } pathKey = device->valuestring; @@ -263,8 +264,11 @@ static int32_t AudioCapturePathSelGetUsecaseDevice(struct AudioHwCaptureParam *c pathList = pathList->next; continue; } - pathValue = cJSON_GetObjectItem(pathList, "value")->valueint; - captureParam->captureMode.hwInfo.pathSelect.pathPlan[pathIndex].value = pathValue; + device = cJSON_GetObjectItem(pathList, "value"); + if (device == NULL) { + return HDF_FAILURE; + } + captureParam->captureMode.hwInfo.pathSelect.pathPlan[pathIndex].value = device->valueint; ret = strncpy_s(captureParam->captureMode.hwInfo.pathSelect.pathPlan[pathIndex].pathPlanName, PATHPLAN_LEN - 1, pathKey, strlen(pathKey) + 1); if (ret != 0) { @@ -282,29 +286,20 @@ static int32_t AudioCapturePathSelGetUsecaseDevice(struct AudioHwCaptureParam *c return HDF_SUCCESS; } -static int32_t AudioCapturePathSelGetDevice(struct AudioHwCaptureParam *captureParam, const char *deviceType) +static int32_t AudioCapturePathSelGetDeviceSplit(struct AudioHwCaptureParam *captureParam, cJSON *deviceList) { LOG_FUN_INFO(); - if (captureParam == NULL || deviceType == NULL || g_cJsonObj == NULL) { - LOG_FUN_ERR("AudioCapturePathSelGetUsecaseDevice param Is NULL"); - return HDF_FAILURE; - } int32_t decIndex = 0; char *decKey = NULL; int32_t decValue; int32_t ret; - cJSON *deviceNode = cJSON_GetObjectItem(g_cJsonObj, deviceType); - if (deviceNode == NULL) { - LOG_FUN_ERR("Get deviceType Fail!"); - return HDF_FAILURE; - } - cJSON *deviceList = deviceNode->child; - if (deviceList == NULL) { - LOG_FUN_ERR("Get deviceList Fail!"); + cJSON *device = NULL; + if (captureParam == NULL || deviceList == NULL) { + LOG_FUN_ERR("param Is NULL"); return HDF_FAILURE; } while (deviceList != NULL) { - cJSON *device = cJSON_GetObjectItem(deviceList, "name"); + device = cJSON_GetObjectItem(deviceList, "name"); if (device == NULL) { LOG_FUN_ERR("Get Object Fail!"); return HDF_FAILURE; @@ -314,7 +309,11 @@ static int32_t AudioCapturePathSelGetDevice(struct AudioHwCaptureParam *captureP deviceList = deviceList->next; continue; } - decValue = cJSON_GetObjectItem(deviceList, "value")->valueint; + device = cJSON_GetObjectItem(deviceList, "value"); + if (device == NULL) { + return HDF_FAILURE; + } + decValue = device->valueint; captureParam->captureMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[decIndex].value = decValue; ret = strncpy_s(captureParam->captureMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[decIndex].deviceSwitch, PATHPLAN_LEN - 1, decKey, strlen(decKey) + 1); @@ -333,6 +332,30 @@ static int32_t AudioCapturePathSelGetDevice(struct AudioHwCaptureParam *captureP return HDF_SUCCESS; } +static int32_t AudioCapturePathSelGetDevice(struct AudioHwCaptureParam *captureParam, const char *deviceType) +{ + LOG_FUN_INFO(); + if (captureParam == NULL || deviceType == NULL || g_cJsonObj == NULL) { + LOG_FUN_ERR("AudioCapturePathSelGetUsecaseDevice param Is NULL"); + return HDF_FAILURE; + } + cJSON *deviceNode = cJSON_GetObjectItem(g_cJsonObj, deviceType); + if (deviceNode == NULL) { + LOG_FUN_ERR("Get deviceType Fail!"); + return HDF_FAILURE; + } + cJSON *deviceList = deviceNode->child; + if (deviceList == NULL) { + LOG_FUN_ERR("Get deviceList Fail!"); + return HDF_FAILURE; + } + if (AudioCapturePathSelGetDeviceSplit(captureParam, deviceList) < 0) { + LOG_FUN_ERR("AudioCapturePathSelGetDeviceSplit Fail!"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + static int32_t AudioPathSelGetPlanCapture(struct AudioHwCaptureParam *captureParam) { LOG_FUN_INFO(); @@ -383,14 +406,12 @@ static int32_t AudioPathSelGetPlanCapture(struct AudioHwCaptureParam *capturePar static int32_t AudioRenderPathSelGetUsecaseDevice(struct AudioHwRenderParam *renderParam, const char *pathName) { - LOG_FUN_INFO(); if (renderParam == NULL || pathName == NULL || g_cJsonObj == NULL) { LOG_FUN_ERR("AudioPathSelGetUsecaseDevice param Is NULL"); return HDF_FAILURE; } int32_t pathIndex = 0; char *pathKey = NULL; - int32_t pathValue; int32_t ret; cJSON *pathNode = cJSON_GetObjectItem(g_cJsonObj, pathName); if (pathNode == NULL) { @@ -413,8 +434,11 @@ static int32_t AudioRenderPathSelGetUsecaseDevice(struct AudioHwRenderParam *ren pathList = pathList->next; continue; } - pathValue = cJSON_GetObjectItem(pathList, "value")->valueint; - renderParam->renderMode.hwInfo.pathSelect.pathPlan[pathIndex].value = pathValue; + device = cJSON_GetObjectItem(pathList, "value"); + if (device == NULL) { + return HDF_FAILURE; + } + renderParam->renderMode.hwInfo.pathSelect.pathPlan[pathIndex].value = device->valueint; ret = strncpy_s(renderParam->renderMode.hwInfo.pathSelect.pathPlan[pathIndex].pathPlanName, PATHPLAN_LEN - 1, pathKey, strlen(pathKey)); if (ret != 0) { @@ -434,14 +458,12 @@ static int32_t AudioRenderPathSelGetUsecaseDevice(struct AudioHwRenderParam *ren static int32_t AudioRenderPathSelGetDevice(struct AudioHwRenderParam *renderParam, const char *deviceType) { - LOG_FUN_INFO(); if (renderParam == NULL || deviceType == NULL || g_cJsonObj == NULL) { LOG_FUN_ERR("AudioPathSelGetDevice param Is NULL"); return HDF_FAILURE; } char *decKey = NULL; int32_t decIndex = 0; - int32_t decValue; int32_t ret; cJSON *deviceNode = cJSON_GetObjectItem(g_cJsonObj, deviceType); if (deviceNode == NULL) { @@ -456,7 +478,7 @@ static int32_t AudioRenderPathSelGetDevice(struct AudioHwRenderParam *renderPara while (deviceList != NULL) { cJSON *device = cJSON_GetObjectItem(deviceList, "name"); if (device == NULL) { - LOG_FUN_ERR("Get Object Fail!"); + LOG_FUN_ERR("Get Object Invalid!"); return HDF_FAILURE; } decKey = device->valuestring; @@ -464,8 +486,11 @@ static int32_t AudioRenderPathSelGetDevice(struct AudioHwRenderParam *renderPara deviceList = deviceList->next; continue; } - decValue = cJSON_GetObjectItem(deviceList, "value")->valueint; - renderParam->renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[decIndex].value = decValue; + device = cJSON_GetObjectItem(deviceList, "value"); + if (device == NULL) { + return HDF_FAILURE; + } + renderParam->renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[decIndex].value = device->valueint; ret = strncpy_s(renderParam->renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[decIndex].deviceSwitch, PATHPLAN_LEN - 1, decKey, strlen(decKey) + 1); if (ret != 0) { diff --git a/audio/interfaces/include/audio_attribute.h b/audio/interfaces/include/audio_attribute.h index b9ca60a685..4f02de054a 100755 --- a/audio/interfaces/include/audio_attribute.h +++ b/audio/interfaces/include/audio_attribute.h @@ -113,7 +113,7 @@ struct AudioAttribute { * The format is key=value. Separate multiple key-value pairs by semicolons (;). * @return Returns 0 if the operation is successful; returns a negative value otherwise. */ - int32_t (*GetExtraParams)(AudioHandle handle, char *keyValueList); + int32_t (*GetExtraParams)(AudioHandle handle, char *keyValueList, int32_t listLenth); /** * @brief Requests a mmap buffer. diff --git a/audio/interfaces/include/audio_types.h b/audio/interfaces/include/audio_types.h index 8acefb426d..6322874332 100755 --- a/audio/interfaces/include/audio_types.h +++ b/audio/interfaces/include/audio_types.h @@ -285,6 +285,7 @@ struct AudioMmapBufferDescripter { int32_t totalBufferFrames; /**< Total size of the mmap buffer (unit: frame )*/ int32_t transferFrameSize; /**< Transfer size (unit: frame) */ int32_t isShareable; /**< Whether the mmap buffer can be shared among processes */ + uint32_t offset; }; /** diff --git a/audio/sample/BUILD.gn b/audio/sample/BUILD.gn index 13ffbd9740..c925846770 100755 --- a/audio/sample/BUILD.gn +++ b/audio/sample/BUILD.gn @@ -17,109 +17,209 @@ if (defined(ohos_lite)) { import("//build/ohos.gni") } import("//drivers/adapter/uhdf2/uhdf.gni") +import("//drivers/peripheral/audio/audio.gni") -ohos_executable("audio_sample_render") { - include_dirs = [ - "//drivers/peripheral/audio/interfaces/include", - "//utils/native/base/include", - "$hdf_framework_path/include", - "$hdf_framework_path/include/osal", - "$hdf_framework_path/include/utils", - "$hdf_framework_path/utils/include", - "$hdf_framework_path/ability/sbuf/include", - "$hdf_framework_path/core/adapter/syscall/include", - "$hdf_framework_path/core/adapter/vnode/include", - "$hdf_framework_path/core/shared/include", - "$hdf_framework_path/include/core/", - "$hdf_uhdf_path/osal/include", - "$hdf_uhdf_path/include/hdi", - "$hdf_uhdf_path/ipc/include", - "$hdf_uhdf_path/include/config", - "$hdf_uhdf_path/include/osal", - "$hdf_uhdf_path/include/host", - "$hdf_uhdf_path/shared/include", - "$hdf_uhdf_path/manager/include", - "$hdf_uhdf_path/host/include", - "$hdf_uhdf_path/include", - "$hdf_uhdf_path/common/security/include", - ] - - sources = [ - "framework_render.c", - ] - - deps = [ - "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", - "$hdf_uhdf_path/hcs:hdf_default.hcb", - "//utils/native/base:utils", - "$hdf_uhdf_path/hdi:libhdi", - "$hdf_uhdf_path/host:hdf_devhost", - "$hdf_uhdf_path/host:libhdf_host", - "$hdf_uhdf_path/config:libhdf_hcs", - "$hdf_uhdf_path/manager:hdf_devmgr.rc", - "$hdf_uhdf_path/manager:hdf_devmgr", - "$hdf_uhdf_path/osal:libhdf_utils", - ] - - if (is_standard_system) { - external_deps = [ "hiviewdfx_hilog_native:libhilog" ] - } else { - external_deps = [ "hilog:libhilog" ] +if (defined(ohos_lite)) { + executable("audio_sample_render") { + include_dirs = [ + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//utils/native/base/include", + "$hdf_framework_path/include", + "$hdf_framework_path/include/osal", + "$hdf_framework_path/include/utils", + "$hdf_framework_path/utils/include", + "$hdf_framework_path/ability/sbuf/include", + "$hdf_framework_path/core/adapter/syscall/include", + "$hdf_framework_path/core/adapter/vnode/include", + "$hdf_framework_path/core/shared/include", + "$hdf_framework_path/include/core/", + "$hdf_uhdf_path/osal/include", + "$hdf_uhdf_path/include/hdi", + "$hdf_uhdf_path/ipc/include", + "$hdf_uhdf_path/include/config", + "$hdf_uhdf_path/include/osal", + "$hdf_uhdf_path/include/host", + "$hdf_uhdf_path/shared/include", + "$hdf_uhdf_path/manager/include", + "$hdf_uhdf_path/host/include", + "$hdf_uhdf_path/include", + "$hdf_uhdf_path/common/security/include", + "//third_party/bounds_checking_function/include" + ] + + sources = [ + "framework_render.c", + ] + + deps = [ + "//third_party/bounds_checking_function:libsec_shared" + ] + + defines = [] + if (enable_audio_device_mpi) { + defines += [ "AUDIO_HAL_USER" ] + } } - install_enable = true - subsystem_name = "hdf" -} + executable("audio_sample_capture") { + include_dirs = [ + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//utils/native/base/include", + "$hdf_framework_path/include", + "$hdf_framework_path/include/osal", + "$hdf_framework_path/include/utils", + "$hdf_framework_path/utils/include", + "$hdf_framework_path/ability/sbuf/include", + "$hdf_framework_path/core/adapter/syscall/include", + "$hdf_framework_path/core/adapter/vnode/include", + "$hdf_framework_path/core/shared/include", + "$hdf_framework_path/include/core/", + "$hdf_uhdf_path/osal/include", + "$hdf_uhdf_path/include/hdi", + "$hdf_uhdf_path/ipc/include", + "$hdf_uhdf_path/include/config", + "$hdf_uhdf_path/include/osal", + "$hdf_uhdf_path/include/host", + "$hdf_uhdf_path/shared/include", + "$hdf_uhdf_path/manager/include", + "$hdf_uhdf_path/host/include", + "$hdf_uhdf_path/include", + "$hdf_uhdf_path/common/security/include", + "//third_party/bounds_checking_function/include" + ] + + sources = [ + "framework_capture.c", + ] -ohos_executable("audio_sample_capture") { - include_dirs = [ - "//drivers/peripheral/audio/interfaces/include", - "//utils/native/base/include", - "$hdf_framework_path/include", - "$hdf_framework_path/include/osal", - "$hdf_framework_path/include/utils", - "$hdf_framework_path/utils/include", - "$hdf_framework_path/ability/sbuf/include", - "$hdf_framework_path/core/adapter/syscall/include", - "$hdf_framework_path/core/adapter/vnode/include", - "$hdf_framework_path/core/shared/include", - "$hdf_framework_path/include/core/", - "$hdf_uhdf_path/osal/include", - "$hdf_uhdf_path/include/hdi", - "$hdf_uhdf_path/ipc/include", - "$hdf_uhdf_path/include/config", - "$hdf_uhdf_path/include/osal", - "$hdf_uhdf_path/include/host", - "$hdf_uhdf_path/shared/include", - "$hdf_uhdf_path/manager/include", - "$hdf_uhdf_path/host/include", - "$hdf_uhdf_path/include", - "$hdf_uhdf_path/common/security/include", - ] - - sources = [ - "framework_capture.c", - ] - - deps = [ - "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", - "$hdf_uhdf_path/hcs:hdf_default.hcb", - "//utils/native/base:utils", - "$hdf_uhdf_path/hdi:libhdi", - "$hdf_uhdf_path/host:hdf_devhost", - "$hdf_uhdf_path/host:libhdf_host", - "$hdf_uhdf_path/config:libhdf_hcs", - "$hdf_uhdf_path/manager:hdf_devmgr.rc", - "$hdf_uhdf_path/manager:hdf_devmgr", - "$hdf_uhdf_path/osal:libhdf_utils", - ] - - if (is_standard_system) { - external_deps = [ "hiviewdfx_hilog_native:libhilog" ] - } else { - external_deps = [ "hilog:libhilog" ] + deps = [ + "//third_party/bounds_checking_function:libsec_shared" + ] + + defines = [] + if (enable_audio_device_mpi) { + defines += [ "AUDIO_HAL_USER" ] + } } +} else { + ohos_executable("audio_sample_render") { + include_dirs = [ + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//utils/native/base/include", + "$hdf_framework_path/include", + "$hdf_framework_path/include/osal", + "$hdf_framework_path/include/utils", + "$hdf_framework_path/utils/include", + "$hdf_framework_path/ability/sbuf/include", + "$hdf_framework_path/core/adapter/syscall/include", + "$hdf_framework_path/core/adapter/vnode/include", + "$hdf_framework_path/core/shared/include", + "$hdf_framework_path/include/core/", + "$hdf_uhdf_path/osal/include", + "$hdf_uhdf_path/include/hdi", + "$hdf_uhdf_path/ipc/include", + "$hdf_uhdf_path/include/config", + "$hdf_uhdf_path/include/osal", + "$hdf_uhdf_path/include/host", + "$hdf_uhdf_path/shared/include", + "$hdf_uhdf_path/manager/include", + "$hdf_uhdf_path/host/include", + "$hdf_uhdf_path/include", + "$hdf_uhdf_path/common/security/include", + ] + + sources = [ + "framework_render.c", + ] + + deps = [ + "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", + "$hdf_uhdf_path/hcs:hdf_default.hcb", + "//utils/native/base:utils", + "$hdf_uhdf_path/hdi:libhdi", + "$hdf_uhdf_path/host:hdf_devhost", + "$hdf_uhdf_path/host:libhdf_host", + "$hdf_uhdf_path/config:libhdf_hcs", + "$hdf_uhdf_path/manager:hdf_devmgr.rc", + "$hdf_uhdf_path/manager:hdf_devmgr", + "$hdf_uhdf_path/osal:libhdf_utils", + ] + + defines = [] + if (enable_audio_device_mpi) { + defines += [ "AUDIO_HAL_USER" ] + } + + if (is_standard_system) { + external_deps = [ "hiviewdfx_hilog_native:libhilog" ] + } else { + external_deps = [ "hilog:libhilog" ] + } - install_enable = true - subsystem_name = "hdf" + install_enable = true + subsystem_name = "hdf" + } + + ohos_executable("audio_sample_capture") { + include_dirs = [ + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//utils/native/base/include", + "$hdf_framework_path/include", + "$hdf_framework_path/include/osal", + "$hdf_framework_path/include/utils", + "$hdf_framework_path/utils/include", + "$hdf_framework_path/ability/sbuf/include", + "$hdf_framework_path/core/adapter/syscall/include", + "$hdf_framework_path/core/adapter/vnode/include", + "$hdf_framework_path/core/shared/include", + "$hdf_framework_path/include/core/", + "$hdf_uhdf_path/osal/include", + "$hdf_uhdf_path/include/hdi", + "$hdf_uhdf_path/ipc/include", + "$hdf_uhdf_path/include/config", + "$hdf_uhdf_path/include/osal", + "$hdf_uhdf_path/include/host", + "$hdf_uhdf_path/shared/include", + "$hdf_uhdf_path/manager/include", + "$hdf_uhdf_path/host/include", + "$hdf_uhdf_path/include", + "$hdf_uhdf_path/common/security/include", + ] + + sources = [ + "framework_capture.c", + ] + + deps = [ + "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", + "$hdf_uhdf_path/hcs:hdf_default.hcb", + "//utils/native/base:utils", + "$hdf_uhdf_path/hdi:libhdi", + "$hdf_uhdf_path/host:hdf_devhost", + "$hdf_uhdf_path/host:libhdf_host", + "$hdf_uhdf_path/config:libhdf_hcs", + "$hdf_uhdf_path/manager:hdf_devmgr.rc", + "$hdf_uhdf_path/manager:hdf_devmgr", + "$hdf_uhdf_path/osal:libhdf_utils", + ] + + defines = [] + if (enable_audio_device_mpi) { + defines += [ "AUDIO_HAL_USER" ] + } + + if (is_standard_system) { + external_deps = [ "hiviewdfx_hilog_native:libhilog" ] + } else { + external_deps = [ "hilog:libhilog" ] + } + + install_enable = true + subsystem_name = "hdf" + } } + diff --git a/audio/sample/framework_capture.c b/audio/sample/framework_capture.c index dd5dbfec8d..97a64bd982 100755 --- a/audio/sample/framework_capture.c +++ b/audio/sample/framework_capture.c @@ -15,16 +15,22 @@ #include "audio_manager.h" #include -#include #include #include #include #include #include #include +#include #include +#include "audio_proxy_manager.h" #include "audio_types.h" #include "hdf_base.h" +#include "inttypes.h" + +#define LOG_FUN_ERR(fmt, arg...) do { \ + printf("%s: [%s]: [%d]:[ERROR]:" fmt"\n", __FILE__, __func__, __LINE__, ##arg); \ + } while (0) #define AUDIO_CHANNELCOUNT 2 #define AUDIO_SAMPLE_RATE_48K 48000 @@ -39,6 +45,11 @@ #define PCM_16_BIT 16 #define AUDIO_TOTALSIZE_15M (1024 * 15) #define AUDIO_RECORD_INTERVAL_512KB 512 +#define MAX_AUDIO_ADAPTER_NUM_T 3 +#define FILE_CAPTURE_SIZE (1024 * 1024 * 3) // 3M +#define BUFFER_LEN 256 +#define EXT_PARAMS_MAXLEN 106 + struct StrParaCapture { struct AudioCapture *capture; @@ -53,13 +64,20 @@ struct AudioDeviceDescriptor g_devDesc; struct AudioSampleAttributes g_attrs; struct AudioCapture *g_capture = NULL; struct AudioManager *g_manager = NULL; +struct AudioProxyManager *g_proxyManager = NULL; struct StrParaCapture g_str; +void *g_captureHandle; pthread_t g_tids; FILE *g_file; char *g_frame; void *g_handle; char g_path[256]; +#ifdef AUDIO_HAL_USER +void *g_sdkHandle; +int (*g_sdkInitSp)() = NULL; +void (*g_sdkExitSp)() = NULL; +#endif enum CaptureMenuId { CAPTURE_START = 1, @@ -71,6 +89,8 @@ enum CaptureMenuId { SET_CAPTURE_MUTE, SET_CAPTURE_ATTRIBUTES, SET_CAPTURE_SLECET_SCENE, + GET_CAPTURE_EXT_PARAMS, + GET_CAPTURE_POSITION, }; enum CaptureInputType { @@ -87,17 +107,14 @@ struct ProcessCaptureMenuSwitchList { }; static int32_t g_closeEnd = 0; -#define LOG_FUN_INFO_TS() do { \ - printf("%s: %s: %d\n", __FILE__, __func__, __LINE__); \ -} while (0) -#define LOG_FUN_ERR_TS(info) do { \ - printf("%s: %s: %d:[ERROR]:%s\n", __FILE__, __func__, __LINE__, (info)); \ -} while (0) - -#define LOG_PARA_INFO_TS(info) do { \ - printf("%s: %s: %d:[INFO]:%s\n", __FILE__, __func__, __LINE__, (info)); \ -} while (0) +void CleanStdin(void) +{ + int c; + do { + c = getchar(); + } while (c != '\n' && c != EOF); +} int32_t CheckInputName(int type, void *val) { @@ -111,8 +128,8 @@ int32_t CheckInputName(int type, void *val) switch (type) { case INPUT_INT: ret = scanf_s("%d", &inputInt); - if (inputInt < 0 || inputInt > SET_CAPTURE_SLECET_SCENE + 1) { - printf("Input failure\n"); + if (inputInt < 0 || inputInt > GET_CAPTURE_POSITION + 1) { + LOG_FUN_ERR("Input failure"); return HDF_FAILURE; } *(int *)val = inputInt; @@ -133,9 +150,9 @@ int32_t CheckInputName(int type, void *val) break; } if (ret == 0) { - fflush(stdin); + CleanStdin(); } else if (ret == EOF) { - printf("Input failure occurs!\n"); + LOG_FUN_ERR("Input failure occurs!"); return HDF_FAILURE; } return HDF_SUCCESS; @@ -182,13 +199,6 @@ int32_t InitDevDescCapture(struct AudioDeviceDescriptor *devDesc, return 0; } -void StreamClose(int32_t sig) -{ - /* allow the stream to be closed gracefully */ - signal(sig, SIG_IGN); - g_closeEnd = 1; -} - uint32_t PcmFormatToBits(enum AudioFormat format) { switch (format) { @@ -201,6 +211,13 @@ uint32_t PcmFormatToBits(enum AudioFormat format) }; } +void StreamClose(int32_t sig) +{ + /* allow the stream to be closed gracefully */ + signal(sig, SIG_IGN); + g_closeEnd = 1; +} + uint32_t PcmFramesToBytes(const struct AudioSampleAttributes attrs) { return DEEP_BUFFER_RENDER_PERIOD_SIZE * attrs.channelCount * (PcmFormatToBits(attrs.format) >> 3); @@ -221,14 +238,14 @@ int32_t StopButtonCapture(struct AudioCapture **captureS) } int ret = capture->control.Stop((AudioHandle)capture); if (ret < 0) { - printf("Stop capture!\n"); + LOG_FUN_ERR("Stop capture!"); } if (g_adapter == NULL) { return HDF_FAILURE; } ret = g_adapter->DestroyCapture(g_adapter, capture); if (ret < 0) { - printf("Capture already destroy!\n"); + LOG_FUN_ERR("Capture already destroy!"); } capture = NULL; g_capture = NULL; @@ -244,6 +261,62 @@ int32_t StopButtonCapture(struct AudioCapture **captureS) return HDF_SUCCESS; } +int32_t FrameStartCaptureMmap(void *param) +{ + if (param == NULL) { + return HDF_FAILURE; + } + struct StrParaCapture *strParam = (struct StrParaCapture *)param; + struct AudioCapture *capture = strParam->capture; + struct AudioMmapBufferDescripter desc; + // Modify file size + if (access(g_path, F_OK | R_OK)) { + return HDF_FAILURE; + } + FILE *fp = fopen(g_path, "rb+"); + if (fp == NULL) { + printf("Open file failed!\n"); + return HDF_FAILURE; + } + int fd = fileno(fp); + if (fd == -1) { + printf("fileno failed, fd is %d\n", fd); + return HDF_FAILURE; + } + ftruncate(fd, FILE_CAPTURE_SIZE); + // Init param + desc.memoryFd = fd; + desc.isShareable = 1; // 1:Shareable ,0:Don't share + desc.transferFrameSize = DEEP_BUFFER_RENDER_PERIOD_SIZE / 4; // One frame size 4 bit + desc.offset = 0; // Recording must be 0 + // start + int32_t ret = capture->attr.ReqMmapBuffer(capture, FILE_CAPTURE_SIZE, &desc); + if (ret < 0) { + printf("Request map fail,please check.\n"); + fclose(fp); + fp = NULL; + return HDF_FAILURE; + } + ret = msync(desc.memoryAddress, FILE_CAPTURE_SIZE, MS_ASYNC); + if (ret < 0) { + printf("sync fail.\n"); + } + munmap(desc.memoryAddress, FILE_CAPTURE_SIZE); + + uint64_t frames; + struct AudioTimeStamp timeStamp; + timeStamp.tvNSec = 0; + timeStamp.tvSec = 0; + ret = capture->attr.GetMmapPosition(capture, &frames, &timeStamp); + if (ret < 0) { + printf("GetMmapPosition fail,please check.\n"); + } + printf("frames = %"PRIu64", tvSec = %lld, tvNSec = %lld\n", frames, timeStamp.tvSec, timeStamp.tvNSec); + fclose(fp); + fp = NULL; + return HDF_SUCCESS; +} + int32_t FrameStartCapture(void *param) { if (param == NULL) { @@ -257,8 +330,8 @@ int32_t FrameStartCapture(void *param) uint64_t replyBytes = 0; uint64_t totalSize = 0; uint64_t requestBytes = AUDIO_BUFF_SIZE; // 16 * 1024 = 16KB - char *frame = NULL; - frame = (char *)calloc(1, bufferSize); + uint32_t failCount = 0; + char *frame = (char *)calloc(1, bufferSize); if (frame == NULL) { return HDF_FAILURE; } @@ -266,35 +339,41 @@ int32_t FrameStartCapture(void *param) ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes); if (ret < 0) { if (ret == HDF_ERR_INVALID_OBJECT) { - printf("Record already stop!\n"); + LOG_FUN_ERR("Record already stop!"); break; } + if (failCount++ >= 10) { // Frame loss for 10 consecutive times + free(frame); + return HDF_FAILURE; + } continue; } + failCount = 0; fwrite(frame, replyBytes, 1, file); totalSize += (replyBytes / PERIOD_SIZE); // 1024 = 1Kb if (totalSize % AUDIO_RECORD_INTERVAL_512KB == 0) { // 512KB - printf("\nRecording,the audio file size is %" PRIu64 "Kb\n", totalSize); + printf("\nRecording,the audio file size is %"PRIu64"Kb\n", totalSize); } } while ((totalSize <= AUDIO_TOTALSIZE_15M) && (!g_closeEnd)); // 15 * 1024 = 15M if (frame != NULL) { free(frame); - frame = NULL; } printf("Record end\n"); if (!g_closeEnd) { - StopButtonCapture(&g_capture); + if (StopButtonCapture(&g_capture) < 0) { + return HDF_FAILURE; + } } return HDF_SUCCESS; } int32_t StartButtonCapture(struct AudioCapture **captureS) { - if (captureS == NULL) { + if (captureS == NULL || g_adapter == NULL || g_adapter->CreateCapture == NULL) { return HDF_FAILURE; } if (g_file != NULL) { - printf("the capture is playing,please stop first\n"); + LOG_FUN_ERR("the capture is playing,please stop first"); return HDF_FAILURE; } g_closeEnd = false; @@ -303,6 +382,9 @@ int32_t StartButtonCapture(struct AudioCapture **captureS) if (capture == NULL || ret < 0) { return HDF_FAILURE; } + if (g_path[0] == '\0') { + return HDF_FAILURE; + } g_file = fopen(g_path, "wb+"); if (g_file == NULL) { printf("failed to open '%s'\n", g_path); @@ -338,16 +420,25 @@ int32_t StartButtonCapture(struct AudioCapture **captureS) int32_t SwitchAdapterCapture(struct AudioAdapterDescriptor *descs, const char *adapterNameCase, enum AudioPortDirection portFlag, struct AudioPort *capturePort, const int32_t size) { + struct AudioAdapterDescriptor *desc = NULL; + int32_t index; + uint32_t port; if (descs == NULL || adapterNameCase == NULL || capturePort == NULL) { return HDF_FAILURE; } - for (int32_t index = 0; index < size; index++) { - struct AudioAdapterDescriptor *desc = &descs[index]; + for (index = 0; index < size; index++) { + desc = &descs[index]; + if (desc == NULL) { + continue; + } + if (desc->adapterName == NULL) { + return HDF_FAILURE; + } if (strcmp(desc->adapterName, adapterNameCase)) { printf("adapter name case = %s\n", adapterNameCase); continue; } - for (uint32_t port = 0; ((desc != NULL) && (port < desc->portNum)); port++) { + for (port = 0; port < desc->portNum; port++) { // Only find out the port of out in the sound card if (desc->ports[port].dir == portFlag) { *capturePort = desc->ports[port]; @@ -366,88 +457,198 @@ void PrintMenu1() printf("| version. |\n"); printf(" =================================================== \n"); } + int32_t SelectLoadingMode(char *resolvedPath, char *func) { system("clear"); int choice = 0; + char *soPathHdi = NULL; + char *soPathProxy = NULL; + int32_t ret; +#ifdef __LITEOS__ + soPathHdi = "/usr/lib/libhdi_audio.so"; + soPathProxy = "/usr/lib/libaudio_hdi_proxy_server.so"; +#else + soPathHdi = "/system/lib/libhdi_audio.z.so"; + soPathProxy = "/system/lib/libaudio_hdi_proxy_server.z.so"; +#endif PrintMenu1(); printf("Please enter your choice:"); - int32_t ret = CheckInputName(INPUT_INT, (void *)&choice); + ret = CheckInputName(INPUT_INT, (void *)&choice); if (ret < 0) return HDF_FAILURE; switch (choice) { - case 1: - snprintf_s(resolvedPath, PATH_LEN, PATH_LEN - 1, "%s", "/system/lib/libhdi_audio.z.so"); - snprintf_s(func, PATH_LEN, PATH_LEN - 1, "%s", "GetAudioManagerFuncs"); + case 1: // 1. Capture Direct Loading + if (snprintf_s(resolvedPath, PATH_LEN, PATH_LEN - 1, "%s", soPathHdi) < 0) { + LOG_FUN_ERR("snprintf_s failed!"); + return HDF_FAILURE; + } + if (snprintf_s(func, PATH_LEN, PATH_LEN - 1, "%s", "GetAudioManagerFuncs") < 0) { + LOG_FUN_ERR("snprintf_s failed!"); + return HDF_FAILURE; + } break; case 2: // 2. Capture Service Loading - snprintf_s(resolvedPath, PATH_LEN, PATH_LEN - 1, "%s", "/system/lib/libaudio_hdi_proxy_server.z.so"); - snprintf_s(func, PATH_LEN, PATH_LEN - 1, "%s", "GetAudioProxyManagerFuncs"); + if (snprintf_s(resolvedPath, PATH_LEN, PATH_LEN - 1, "%s", soPathProxy) < 0) { + LOG_FUN_ERR("snprintf_s failed!"); + return HDF_FAILURE; + } + if (snprintf_s(func, PATH_LEN, PATH_LEN - 1, "%s", "GetAudioProxyManagerFuncs") < 0) { + return HDF_FAILURE; + } break; default: printf("Input error,Switched to direct loading in for you,"); SystemInputFail(); - snprintf_s(resolvedPath, PATH_LEN, PATH_LEN - 1, "%s", "/system/lib/libhdi_audio.z.so"); - snprintf_s(func, PATH_LEN, PATH_LEN - 1, "%s", "GetAudioManagerFuncs"); + if (snprintf_s(resolvedPath, PATH_LEN, PATH_LEN - 1, "%s", soPathHdi) < 0) { + return HDF_FAILURE; + } + if (snprintf_s(func, PATH_LEN, PATH_LEN - 1, "%s", "GetAudioManagerFuncs") < 0) { + return HDF_FAILURE; + } break; } return HDF_SUCCESS; } -int32_t InitParam() +int32_t GetCapturePassthroughManagerFunc(const char *adapterNameCase) { - int32_t ret; - int32_t index; - int32_t size = 0; - char resolvedPath[PATH_LEN] = {0}; - char func[PATH_LEN] = {0}; - if (SelectLoadingMode(resolvedPath, func) < 0) { + if (adapterNameCase == NULL) { + LOG_FUN_ERR("The Parameter is NULL"); return HDF_FAILURE; } - void *handle = dlopen(resolvedPath, 1); - struct AudioPort audioPort; + struct AudioManager *manager = NULL; struct AudioAdapterDescriptor *descs = NULL; + enum AudioPortDirection port = PORT_OUT; // Set port information struct AudioPort capturePort; + int32_t size = 0; + int32_t ret; + int32_t index; struct AudioManager *(*getAudioManager)() = NULL; - getAudioManager = (struct AudioManager *(*)())(dlsym(handle, func)); - audioPort.dir = PORT_IN; - audioPort.portId = 0; - audioPort.portName = "AOP"; - struct AudioManager *manager = getAudioManager(); + getAudioManager = (struct AudioManager *(*)())(dlsym(g_captureHandle, "GetAudioManagerFuncs")); + manager = getAudioManager(); if (manager == NULL) { + LOG_FUN_ERR("Get Audio Manager Funcs Fail"); return HDF_FAILURE; } ret = manager->GetAllAdapters(manager, &descs, &size); - // adapters is 0~3 - int32_t check = size > 3 || size == 0 || descs == NULL || ret < 0; - if (check) { + int32_t param = size > MAX_AUDIO_ADAPTER_NUM_T || size == 0 || descs == NULL || ret < 0; + if (param) { + LOG_FUN_ERR("Get All Adapters Fail"); return HDF_ERR_NOT_SUPPORT; } - char adapterNameCase[PATH_LEN] = "usb"; - index = SwitchAdapterCapture(descs, adapterNameCase, audioPort.dir, &capturePort, size); + index = SwitchAdapterCapture(descs, adapterNameCase, port, &capturePort, size); if (index < 0) { + LOG_FUN_ERR("Not Switch Adapter Fail"); return HDF_ERR_NOT_SUPPORT; } struct AudioAdapterDescriptor *desc = &descs[index]; if (manager->LoadAdapter(manager, desc, &g_adapter) != 0) { + LOG_FUN_ERR("Load Adapter Fail"); return HDF_ERR_NOT_SUPPORT; } g_manager = manager; if (g_adapter == NULL) { + LOG_FUN_ERR("load audio device failed"); + return HDF_FAILURE; + } + (void)g_adapter->InitAllPorts(g_adapter); + if (InitAttrsCapture(&g_attrs) < 0) { + g_manager->UnloadAdapter(g_manager, g_adapter); + return HDF_FAILURE; + } + // Specify a hardware device + if (InitDevDescCapture(&g_devDesc, capturePort.portId) < 0) { + g_manager->UnloadAdapter(g_manager, g_adapter); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t GetCaptureProxyManagerFunc(const char *adapterNameCase) +{ + if (adapterNameCase == NULL) { + LOG_FUN_ERR("The Parameter is NULL"); + return HDF_FAILURE; + } + struct AudioProxyManager *proxyManager = NULL; + struct AudioAdapterDescriptor *descs = NULL; + enum AudioPortDirection port = PORT_OUT; // Set port information + struct AudioPort capturePort; + int32_t size = 0; + int32_t ret; + int32_t index; + struct AudioProxyManager *(*getAudioManager)() = NULL; + getAudioManager = (struct AudioProxyManager *(*)())(dlsym(g_captureHandle, "GetAudioProxyManagerFuncs")); + proxyManager = getAudioManager(); + ret = proxyManager->GetAllAdapters(proxyManager, &descs, &size); + int32_t check = size > MAX_AUDIO_ADAPTER_NUM_T || size == 0 || descs == NULL || ret < 0; + if (check) { + LOG_FUN_ERR("Get All Adapters Fail"); + return HDF_ERR_NOT_SUPPORT; + } + // Get qualified sound card and port + index = SwitchAdapterCapture(descs, adapterNameCase, port, &capturePort, size); + if (index < 0) { + LOG_FUN_ERR("Not Switch Adapter Fail"); + return HDF_ERR_NOT_SUPPORT; + } + struct AudioAdapterDescriptor *desc = &descs[index]; + if (proxyManager->LoadAdapter(proxyManager, desc, &g_adapter) != 0) { + LOG_FUN_ERR("Load Adapter Fail"); + return HDF_ERR_NOT_SUPPORT; + } + g_proxyManager = proxyManager; + if (g_adapter == NULL) { + LOG_FUN_ERR("load audio device failed"); return HDF_FAILURE; } // Initialization port information, can fill through mode and other parameters (void)g_adapter->InitAllPorts(g_adapter); // User needs to set if (InitAttrsCapture(&g_attrs) < 0) { + g_proxyManager->UnloadAdapter(g_proxyManager, g_adapter); return HDF_FAILURE; } // Specify a hardware device if (InitDevDescCapture(&g_devDesc, capturePort.portId) < 0) { + g_proxyManager->UnloadAdapter(g_proxyManager, g_adapter); return HDF_FAILURE; } return HDF_SUCCESS; } +int32_t InitParam() +{ + char resolvedPath[PATH_LEN] = {0}; + char func[PATH_LEN] = {0}; + if (SelectLoadingMode(resolvedPath, func) < 0) { + return HDF_FAILURE; + } + g_captureHandle = dlopen(resolvedPath, 1); + if (g_captureHandle == NULL) { + LOG_FUN_ERR("Open so Fail, reason:%s", dlerror()); + return HDF_FAILURE; + } + struct AudioPort audioPort; + audioPort.dir = PORT_IN; + audioPort.portId = 0; + audioPort.portName = "AOP"; + char adapterNameCase[PATH_LEN] = "usb"; + if (strcmp(func, "GetAudioManagerFuncs") == 0) { + if (GetCapturePassthroughManagerFunc(adapterNameCase) < 0) { + LOG_FUN_ERR("GetCapturePassthroughManagerFunc Fail"); + return HDF_FAILURE; + } + } else { + // (strcmp(func,"GetAudioProxyManagerFuncs") == 0) + if (GetCaptureProxyManagerFunc(adapterNameCase) < 0) { + LOG_FUN_ERR("GetCaptureProxyManagerFunc Fail"); + return HDF_FAILURE; + } + } + return HDF_SUCCESS; +} + int32_t SetCaptureMute() { int32_t val = 0; @@ -458,7 +659,7 @@ int32_t SetCaptureMute() } ret = g_capture->volume.GetMute((AudioHandle)g_capture, &isMute); if (ret < 0) { - printf("The current mute state was not obtained!"); + LOG_FUN_ERR("The current mute state was not obtained!"); } printf("Now %s ,Do you need to set mute status(1/0):\n", isMute ? "mute" : "not mute"); ret = CheckInputName(INPUT_INT, (void *)&val); @@ -466,12 +667,12 @@ int32_t SetCaptureMute() return HDF_FAILURE; } if (isMute != 0 && isMute != 1) { - printf("Invalid value,"); + LOG_FUN_ERR("Invalid value,"); SystemInputFail(); return HDF_FAILURE; } if (g_capture == NULL) { - printf("Record already complete,Please record againand,"); + LOG_FUN_ERR("Record already complete,Please record againand,"); SystemInputFail(); return HDF_FAILURE; } @@ -490,7 +691,7 @@ int32_t SetCaptureVolume() } ret = g_capture->volume.GetVolume((AudioHandle)g_capture, &val); if (ret < 0) { - printf("Get current volume failed,"); + LOG_FUN_ERR("Get current volume failed,"); SystemInputFail(); return ret; } @@ -500,18 +701,18 @@ int32_t SetCaptureVolume() return HDF_FAILURE; } if (val < 0.0 || val > 1.0) { - printf("Invalid volume value,"); + LOG_FUN_ERR("Invalid volume value,"); SystemInputFail(); return HDF_FAILURE; } if (g_capture == NULL) { - printf("Record already complete,Please record againand,"); + LOG_FUN_ERR("Record already complete,Please record againand,"); SystemInputFail(); return HDF_FAILURE; } ret = g_capture->volume.SetVolume((AudioHandle)g_capture, val); if (ret < 0) { - printf("set volume fail,"); + LOG_FUN_ERR("set volume fail,"); SystemInputFail(); } return ret; @@ -526,7 +727,7 @@ int32_t SetCaptureGain() } ret = g_capture->volume.GetGain((AudioHandle)g_capture, &val); if (ret < 0) { - LOG_FUN_ERR_TS("Get current gain failed,"); + LOG_FUN_ERR("Get current gain failed,"); SystemInputFail(); return HDF_FAILURE; } @@ -537,18 +738,18 @@ int32_t SetCaptureGain() } // gain is 0.0 ~ 15.0 if (val < 0.0 || val > 15.0) { - printf("Invalid gain value,"); + LOG_FUN_ERR("Invalid gain value,"); SystemInputFail(); return HDF_FAILURE; } if (g_capture == NULL) { - printf("Record already complete,Please record againand,"); + LOG_FUN_ERR("Record already complete,Please record againand,"); SystemInputFail(); return HDF_FAILURE; } ret = g_capture->volume.SetGain((AudioHandle)g_capture, val); if (ret < 0) { - printf("Set capture gain failed,"); + LOG_FUN_ERR("Set capture gain failed,"); SystemInputFail(); } return ret; @@ -582,19 +783,22 @@ int32_t SetCaptureResume() void PrintAttributesFromat() { - printf(" ============= Sample Attributes Fromat =============== \n"); - printf("| 1. AUDIO_FORMAT_PCM_8_BIT |\n"); - printf("| 2. AUDIO_FORMAT_PCM_16_BIT |\n"); - printf("| 3. AUDIO_FORMAT_PCM_24_BIT |\n"); - printf("| 4. AUDIO_FORMAT_PCM_32_BIT |\n"); - printf(" ====================================================== \n"); + printf(" ============= Capture Sample Attributes Fromat =============== \n"); + printf("| 1. Capture AUDIO_FORMAT_PCM_8_BIT |\n"); + printf("| 2. Capture AUDIO_FORMAT_PCM_16_BIT |\n"); + printf("| 3. Capture AUDIO_FORMAT_PCM_24_BIT |\n"); + printf("| 4. Capture AUDIO_FORMAT_PCM_32_BIT |\n"); + printf(" ============================================================== \n"); } int32_t SelectAttributesFomat(uint32_t *fomat) { + if (fomat == NULL) { + return HDF_FAILURE; + } PrintAttributesFromat(); printf("Please select audio format,If not selected, the default is 16bit:"); - uint32_t ret; + int32_t ret; int val = 0; ret = CheckInputName(INPUT_INT, (void *)&val); if (ret < 0) { @@ -626,14 +830,13 @@ int32_t SetCaptureAttributes() struct AudioSampleAttributes attrs; ret = g_capture->attr.GetSampleAttributes((AudioHandle)g_capture, &attrs); if (ret < 0) { - LOG_FUN_ERR_TS("GetCaptureAttributes failed\n"); + LOG_FUN_ERR("GetCaptureAttributes failed\n"); } else { printf("Current sample attributes:\n"); printf("audioType is %u\nfomat is %u\nsampleRate is %u\nchannalCount is" "%u\nperiod is %u\nframesize is %u\nbigEndian is %u\nSignedData is %u\n", - attrs.type, attrs.format, attrs.sampleRate, - attrs.channelCount, attrs.period, attrs.frameSize, - attrs.isBigEndian, attrs.isSignedData); + attrs.type, attrs.format, attrs.sampleRate, attrs.channelCount, + attrs.period, attrs.frameSize, attrs.isBigEndian, attrs.isSignedData); } printf("Set Sample Attributes,"); SystemInputFail(); @@ -641,7 +844,7 @@ int32_t SetCaptureAttributes() printf("The sample attributes you want to set,Step by step, please.\n"); ret = SelectAttributesFomat((uint32_t *)(&attrs.format)); if (ret < 0) { - LOG_FUN_ERR_TS("SetCaptureAttributes format failed\n"); + LOG_FUN_ERR("SetCaptureAttributes format failed"); return HDF_FAILURE; } printf("\nPlease input sample rate(48000,44100,32000...):"); @@ -653,13 +856,13 @@ int32_t SetCaptureAttributes() return HDF_FAILURE; } if (g_capture == NULL) { - printf("Record already complete,Please record againand set the attrbutes,"); + LOG_FUN_ERR("Record already complete,Please record againand set the attrbutes,"); SystemInputFail(); return HDF_FAILURE; } ret = g_capture->attr.SetSampleAttributes((AudioHandle)g_capture, &attrs); if (ret < 0) { - printf("\nSet capture attributes failed,"); + LOG_FUN_ERR("Set capture attributes failed,"); SystemInputFail(); } return ret; @@ -678,7 +881,7 @@ int32_t SelectCaptureScene() printf("Please input your choice:\n"); ret = CheckInputName(INPUT_INT, (void *)&val); if (ret < 0 || (val != 0 && val != 1)) { - printf("Invalid value,"); + LOG_FUN_ERR("Invalid value,"); SystemInputFail(); return HDF_FAILURE; } @@ -690,16 +893,56 @@ int32_t SelectCaptureScene() scene.desc.pins = PIN_IN_MIC; } if (g_capture == NULL) { - printf("Record already stop,"); + LOG_FUN_ERR("Record already stop,"); SystemInputFail(); return HDF_FAILURE; } + if (g_capture->scene.SelectScene == NULL) { + return HDF_FAILURE; + } ret = g_capture->scene.SelectScene((AudioHandle)g_capture, &scene); if (ret < 0) { - printf("Select scene fail\n"); + LOG_FUN_ERR("Select scene fail"); } return ret; } +int32_t GetCaptureExtParams() +{ + char keyValueList[BUFFER_LEN] = {0}; + int32_t ret; + if (g_capture == NULL) { + return HDF_FAILURE; + } + ret = g_capture->attr.GetExtraParams((AudioHandle)g_capture, keyValueList, EXT_PARAMS_MAXLEN); + if (ret < 0) { + LOG_FUN_ERR("Get EXT params failed!"); + SystemInputFail(); + return HDF_FAILURE; + } + printf("keyValueList = %s\n", keyValueList); + return HDF_SUCCESS; +} + +int32_t GetCaptureMmapPosition() +{ + int32_t ret; + if (g_capture == NULL) { + return HDF_FAILURE; + } + uint64_t frames = 0; + struct AudioTimeStamp time; + time.tvNSec = 0; + time.tvSec = 0; + ret = g_capture->attr.GetMmapPosition((AudioHandle)g_capture, &frames, &time); + if (ret < 0) { + LOG_FUN_ERR("Get current Mmap frames Position failed!"); + SystemInputFail(); + return HDF_FAILURE; + } + printf("Now the Position is %"PRIu64"\n", frames); + SystemInputFail(); + return HDF_SUCCESS; +} void PrintMenu2() { @@ -713,7 +956,10 @@ void PrintMenu2() printf("| 7. Capture SetMute |\n"); printf("| 8. Capture SetAttributes |\n"); printf("| 9. Capture SelectScene |\n"); - printf("| 10.Exit |\n"); + printf("| 10. Capture GetExtParams |\n"); + + printf("| 11. Capture getMmapPosition |\n"); + printf("| 12.Exit |\n"); printf(" ======================================================= \n"); } @@ -727,21 +973,24 @@ static struct ProcessCaptureMenuSwitchList g_processCaptureMenuSwitchList[] = { {SET_CAPTURE_MUTE, SetCaptureMute}, {SET_CAPTURE_ATTRIBUTES, SetCaptureAttributes}, {SET_CAPTURE_SLECET_SCENE, SelectCaptureScene}, + {GET_CAPTURE_EXT_PARAMS, GetCaptureExtParams}, + {GET_CAPTURE_POSITION, GetCaptureMmapPosition}, + }; void ProcessMenu(int32_t choice) { int32_t i; - if (choice == SET_CAPTURE_SLECET_SCENE + 1) { - printf("Exit from application program!\n"); + if (choice == GET_CAPTURE_POSITION + 1) { + LOG_FUN_ERR("Exit from application program!"); return; } if (g_capture == NULL && choice != 1) { - printf("this capture already release,"); + LOG_FUN_ERR("this capture already release,"); SystemInputFail(); return; } - for (i = CAPTURE_START; i <= SET_CAPTURE_SLECET_SCENE; ++i) { + for (i = CAPTURE_START; i <= GET_CAPTURE_POSITION; ++i) { if ((choice == (int32_t)g_processCaptureMenuSwitchList[i - 1].cmd) && (g_processCaptureMenuSwitchList[i - 1].operation != NULL)) { g_processCaptureMenuSwitchList[i - 1].operation(&g_capture); @@ -749,34 +998,18 @@ void ProcessMenu(int32_t choice) } } -int32_t main(int32_t argc, char const *argv[]) +void Choice() { - if (argc < 2) { - printf("usage:[1]%s [2]%s\n", argv[0], "/data/test.wav"); - return 0; - } - strncpy_s(g_path, PATH_LEN - 1, argv[1], strlen(argv[1]) + 1); - FILE *file = fopen(g_path, "wb+"); - if (file == NULL) { - printf("failed to open '%s',Please enter the correct file name \n", g_path); - return HDF_FAILURE; - } - fclose(file); int32_t choice = 0; - int ret; - if (InitParam()) { // init - LOG_FUN_ERR_TS("InitParam Fail\n"); - return HDF_FAILURE; - } - while (choice < SET_CAPTURE_SLECET_SCENE + 1 && choice >= 0) { + while (choice < GET_CAPTURE_POSITION + 1 && choice >= 0) { system("clear"); PrintMenu2(); printf("your choice is:\n"); - ret = CheckInputName(INPUT_INT, (void *)&choice); + int32_t ret = CheckInputName(INPUT_INT, (void *)&choice); if (ret < 0) { continue; } - if (choice < CAPTURE_START || choice > SET_CAPTURE_SLECET_SCENE + 1) { + if (choice < CAPTURE_START || choice > GET_CAPTURE_POSITION + 1) { printf("You input is wrong,"); choice = 0; SystemInputFail(); @@ -784,11 +1017,46 @@ int32_t main(int32_t argc, char const *argv[]) } ProcessMenu(choice); } +} + +int32_t main(int32_t argc, char const *argv[]) +{ + if (argc < 2) { // The parameter number is not greater than 2 + printf("usage:[1]%s [2]%s\n", argv[0], "/data/test.wav"); + return 0; + } + int32_t ret; + if (argv[1] == NULL) { + return HDF_FAILURE; + } + ret = strncpy_s(g_path, PATH_LEN - 1, argv[1], strlen(argv[1]) + 1); + if (ret != 0) { + LOG_FUN_ERR("copy fail"); + return HDF_FAILURE; + } + if (g_path[0] == '\0') { + return HDF_FAILURE; + } + FILE *file = fopen(g_path, "wb+"); + if (file == NULL) { + printf("failed to open '%s',Please enter the correct file name \n", g_path); + return HDF_FAILURE; + } + fclose(file); + bool soMode = false; + if (InitParam()) { // init + LOG_FUN_ERR("InitParam Fail"); + return HDF_FAILURE; + } + Choice(); if (g_capture != NULL && g_adapter != NULL) { StopButtonCapture(&g_capture); } if (g_manager != NULL) { g_manager->UnloadAdapter(g_manager, g_adapter); + soMode = true; + } else { + g_proxyManager->UnloadAdapter(g_proxyManager, g_adapter); } dlclose(g_handle); printf("Record file path:%s\n", g_path); diff --git a/audio/sample/framework_render.c b/audio/sample/framework_render.c index 56da5ede78..d85e4b0334 100755 --- a/audio/sample/framework_render.c +++ b/audio/sample/framework_render.c @@ -22,20 +22,14 @@ #include #include #include +#include "audio_proxy_manager.h" #include "audio_types.h" #include "hdf_base.h" +#include "inttypes.h" -#define LOG_FUN_INFO_TS() do { \ - printf("%s: %s: %d\n", __FILE__, __func__, __LINE__); \ -} while (0) - -#define LOG_FUN_ERR_TS(info) do { \ - printf("%s: %s: %d:[ERROR]:%s\n", __FILE__, __func__, __LINE__, (info)); \ -} while (0) - -#define LOG_PARA_INFO_TS(info) do { \ - printf("%s: %s: %d:[INFO]:%s\n", __FILE__, __func__, __LINE__, (info)); \ -} while (0) +#define LOG_FUN_ERR(fmt, arg...) do { \ + printf("%s: [%s]: [%d]:[ERROR]:" fmt"\n", __FILE__, __func__, __LINE__, ##arg); \ + } while (0) #define MAX_AUDIO_ADAPTER_NUM_T 3 // Number of sound cards supported #define BUFFER_LEN 256 @@ -52,6 +46,7 @@ #define DEEP_BUFFER_RENDER_PERIOD_COUNT 8 #define INT_32_MAX 0x7fffffff #define PERIOD_SIZE 1024 +#define EXT_PARAMS_MAXLEN 106 enum AudioPCMBit { PCM_8_BIT = 8, /**< 8-bit PCM */ @@ -60,6 +55,16 @@ enum AudioPCMBit { PCM_32_BIT = 32, /**< 32-bit PCM */ }; +enum RenderSoundCardMode { + ACODEC = 1, + SMARTPA = 2, +}; + +enum RenderLoadingMode { + DIRECT = 1, + SERVICE = 2, +}; + struct AudioHeadInfo { uint32_t testFileRiffId; uint32_t testFileRiffSize; @@ -88,6 +93,7 @@ struct StrPara { struct AudioRender *g_render = NULL; struct AudioAdapter *g_adapter = NULL; struct AudioManager *g_manager = NULL; +struct AudioProxyManager *g_proxyManager = NULL; struct AudioDeviceDescriptor g_devDesc; struct AudioSampleAttributes g_attrs; struct AudioPort g_audioPort; @@ -115,6 +121,8 @@ enum RenderMenuId { SET_RENDER_MUTE, SET_RENDER_ATTRIBUTES, SET_RENDER_SLECET_SCENE, + GET_RENDER_EXT_PARAMS, + GET_RENDER_POSITION, }; enum RenderInputType { @@ -129,17 +137,29 @@ struct ProcessRenderMenuSwitchList { enum RenderMenuId cmd; AudioRenderOperation operation; }; + +void CleanStdin(void) +{ + int c; + do { + c = getchar(); + } while (c != '\n' && c != EOF); +} + int32_t CheckInputName(int type, void *val) { int ret; int inputInt = 0; float inputFloat = 0.0; uint32_t inputUint = 0; + if (val == NULL) { + return HDF_FAILURE; + } switch (type) { case INPUT_INT: ret = scanf_s("%d", &inputInt); - if (inputInt < 0 || inputInt > SET_RENDER_SLECET_SCENE + 1) { - printf("Input failure\n"); + if (inputInt < 0 || inputInt > GET_RENDER_POSITION + 1) { + LOG_FUN_ERR("Input failure"); return HDF_FAILURE; } *(int *)val = inputInt; @@ -160,9 +180,9 @@ int32_t CheckInputName(int type, void *val) break; } if (ret == 0) { - fflush(stdin); + CleanStdin(); } else if (ret == EOF) { - printf("Input failure occurs!\n"); + LOG_FUN_ERR("Input failure occurs!"); return HDF_FAILURE; } return HDF_SUCCESS; @@ -198,20 +218,6 @@ int32_t InitAttrs(struct AudioSampleAttributes *attrs) return HDF_SUCCESS; } -int32_t InitAttrsAgain(struct AudioSampleAttributes *attrs) -{ - if (attrs == NULL) { - return HDF_FAILURE; - } - /* Initialization of audio parameters for playback */ - attrs->format = AUDIO_FORMAT_PCM_8_BIT; - attrs->channelCount = 1; - attrs->sampleRate = AUDIO_SAMPLE_RATE_8K; - attrs->interleaved = 0; - attrs->type = AUDIO_IN_MEDIA; - return HDF_SUCCESS; -} - int32_t InitDevDesc(struct AudioDeviceDescriptor *devDesc, uint32_t portId) { if (devDesc == NULL) { @@ -241,7 +247,7 @@ int32_t WavHeadAnalysis(FILE *file, struct AudioSampleAttributes *attrs) if (file == NULL || attrs == NULL) { return HDF_FAILURE; } - int32_t ret; + uint32_t ret; char *audioRiffIdParam = "RIFF"; char *audioFileFmtParam = "WAVE"; char *aduioDataIdParam = "data"; @@ -285,15 +291,22 @@ int32_t SwitchAdapter(struct AudioAdapterDescriptor *descs, const char *adapterNameCase, enum AudioPortDirection portFlag, struct AudioPort *renderPort, int32_t size) { + struct AudioAdapterDescriptor *desc = NULL; if (descs == NULL || adapterNameCase == NULL || renderPort == NULL) { return HDF_FAILURE; } for (int32_t index = 0; index < size; index++) { - struct AudioAdapterDescriptor *desc = &descs[index]; + desc = &descs[index]; + if (desc == NULL) { + continue; + } + if (desc->adapterName == NULL) { + return HDF_FAILURE; + } if (strcmp(desc->adapterName, adapterNameCase)) { continue; } - for (uint32_t port = 0; ((desc != NULL) && (port < desc->portNum)); port++) { + for (uint32_t port = 0; port < desc->portNum; port++) { // Only find out the port of out in the sound card if (desc->ports[port].dir == portFlag) { *renderPort = desc->ports[port]; @@ -345,19 +358,19 @@ int32_t StopAudioFiles(struct AudioRender **renderS) } struct AudioRender *render = *renderS; if (render == NULL) { - LOG_PARA_INFO_TS("render is null"); + LOG_FUN_ERR("render is null"); return HDF_FAILURE; } int32_t ret = render->control.Stop((AudioHandle)render); if (ret < 0) { - printf("Stop Render!\n"); + LOG_FUN_ERR("Stop Render!"); } - if (g_adapter == NULL) { + if (g_adapter == NULL || g_adapter->DestroyRender == NULL) { return HDF_FAILURE; } ret = g_adapter->DestroyRender(g_adapter, render); if (ret < 0) { - printf("Destroy Render!\n"); + LOG_FUN_ERR("Destroy Render!"); } render = NULL; g_render = NULL; @@ -372,6 +385,61 @@ int32_t StopAudioFiles(struct AudioRender **renderS) return ret; } +int32_t FrameStartMmap(void *param) +{ + if (param == NULL) { + return HDF_FAILURE; + } + struct StrPara *strParam = (struct StrPara *)param; + struct AudioRender *render = strParam->render; + struct AudioMmapBufferDescripter desc; + signal(SIGINT, StreamClose); + // get file length + if (access(g_path, F_OK | R_OK)) { + return HDF_FAILURE; + } + FILE *fp = fopen(g_path, "rb+"); + if (fp == NULL) { + printf("Open file failed!\n"); + return HDF_FAILURE; + } + fseek(fp, 0, SEEK_END); + int32_t reqSize = ftell(fp); + // Converts a file pointer to a device descriptor + int fd = fileno(fp); + if (fd == -1) { + printf("fileno failed, fd is %d\n", fd); + fclose(fp); + fp = NULL; + return HDF_FAILURE; + } + // Init param + desc.memoryFd = fd; + desc.isShareable = 1; // 1:Shareable ,0:Don't share + desc.transferFrameSize = DEEP_BUFFER_RENDER_PERIOD_SIZE / 4; // One frame size 4 bit + desc.offset = sizeof(g_wavHeadInfo); + // start + int32_t ret = render->attr.ReqMmapBuffer(render, reqSize, &desc); + if (ret < 0) { + printf("Request map fail,please check.\n"); + fclose(fp); + fp = NULL; + return HDF_FAILURE; + } + uint64_t frames; + struct AudioTimeStamp timeStamp; + timeStamp.tvNSec = 0; + timeStamp.tvSec = 0; + ret = render->attr.GetMmapPosition(render, &frames, &timeStamp); + if (ret < 0) { + printf("GetMmapPosition fail,please check.\n"); + } + printf("frames = %"PRIu64", tvSec = %lld, tvNSec = %lld\n", frames, timeStamp.tvSec, timeStamp.tvNSec); + fclose(fp); + fp = NULL; + return ret; +} + int32_t FrameStart(void *param) { if (param == NULL) { @@ -387,13 +455,16 @@ int32_t FrameStart(void *param) int32_t numRead; signal(SIGINT, StreamClose); uint64_t replyBytes; + if (g_file == NULL) { + return HDF_FAILURE; + } do { readSize = (remainingDataSize > bufferSize) ? bufferSize : remainingDataSize; numRead = fread(frame, 1, readSize, g_file); if (numRead > 0) { ret = render->RenderFrame(render, frame, numRead, &replyBytes); if (ret == HDF_ERR_INVALID_OBJECT) { - printf("Render already stop!\n"); + LOG_FUN_ERR("Render already stop!"); break; } remainingDataSize -= numRead; @@ -413,58 +484,72 @@ int32_t FrameStart(void *param) void FileClose(FILE **file) { - if ((file != NULL) || ((*file) != NULL)) { + if ((file != NULL) && ((*file) != NULL)) { fclose(*file); *file = NULL; } return; } +int32_t InitPlayingAudioParam(struct AudioRender *render) +{ + if (render == NULL) { + return HDF_FAILURE; + } + uint32_t bufferSize = PcmFramesToBytes(g_attrs); + g_frame = (char *)calloc(1, bufferSize); + if (g_frame == NULL) { + return HDF_FAILURE; + } + memset_s(&g_str, sizeof(struct StrPara), 0, sizeof(struct StrPara)); + g_str.render = render; + g_str.bufferSize = bufferSize; + g_str.frame = g_frame; + return HDF_SUCCESS; +} + int32_t PlayingAudioFiles(struct AudioRender **renderS) { - if (renderS == NULL || g_adapter == NULL) { + if (renderS == NULL || g_adapter == NULL || g_adapter->CreateRender == NULL) { return HDF_FAILURE; } if (g_file != NULL) { - printf("the music is playing,please stop first\n"); + LOG_FUN_ERR("the music is playing,please stop first"); return HDF_FAILURE; } g_closeEnd = false; struct AudioRender *render; + if (access(g_path, F_OK | R_OK)) { + return HDF_FAILURE; + } g_file = fopen(g_path, "rb"); if (g_file == NULL) { printf("failed to open '%s'\n", g_path); return HDF_FAILURE; } if (WavHeadAnalysis(g_file, &g_attrs) < 0) { - LOG_FUN_ERR_TS("fream test is Fail"); + LOG_FUN_ERR("fream test is Fail"); FileClose(&g_file); return HDF_FAILURE; } int32_t ret = g_adapter->CreateRender(g_adapter, &g_devDesc, &g_attrs, &render); if (render == NULL || ret < 0 || render->RenderFrame == NULL) { - LOG_FUN_ERR_TS("AudioDeviceCreateRender failed or RenderFrame is null"); + LOG_FUN_ERR("AudioDeviceCreateRender failed or RenderFrame is null"); FileClose(&g_file); return HDF_FAILURE; } // Playing audio files if (render->control.Start((AudioHandle)render)) { - LOG_FUN_ERR_TS("Start Bind Fail!"); + LOG_FUN_ERR("Start Bind Fail!"); FileClose(&g_file); return HDF_FAILURE; } - uint32_t bufferSize = PcmFramesToBytes(g_attrs); - g_frame = (char *)calloc(1, bufferSize); - if (g_frame == NULL) { + if (InitPlayingAudioParam(render) < 0) { FileClose(&g_file); return HDF_FAILURE; } - memset_s(&g_str, sizeof(struct StrPara), 0, sizeof(struct StrPara)); - g_str.render = render; - g_str.bufferSize = bufferSize; - g_str.frame = g_frame; if (pthread_create(&g_tids, NULL, (void *)(&FrameStart), &g_str) != 0) { - LOG_FUN_ERR_TS("Create Thread Fail\n"); + LOG_FUN_ERR("Create Thread Fail"); FileClose(&g_file); return HDF_FAILURE; } @@ -500,10 +585,10 @@ int32_t SwitchInternalOrExternal(char *adapterNameCase) int32_t ret = CheckInputName(INPUT_INT, (void *)&choice); if (ret < 0) return HDF_FAILURE; switch (choice) { - case 1: + case ACODEC: snprintf_s(adapterNameCase, PATH_LEN, PATH_LEN - 1, "%s", "usb"); break; - case 2: // 2. Render SmartPA + case SMARTPA: snprintf_s(adapterNameCase, PATH_LEN, PATH_LEN - 1, "%s", "hdmi"); break; default: @@ -519,6 +604,15 @@ int32_t SelectLoadingMode(char *resolvedPath, char *func) { system("clear"); int choice = 0; + char *soPathHdi = NULL; + char *soPathProxy = NULL; +#ifdef __LITEOS__ + soPathHdi = "/usr/lib/libhdi_audio.so"; + soPathProxy = "/usr/lib/libaudio_hdi_proxy_server.so"; +#else + soPathHdi = "/system/lib/libhdi_audio.z.so"; + soPathProxy = "/system/lib/libaudio_hdi_proxy_server.z.so"; +#endif PrintMenu1(); printf("Please enter your choice:"); int32_t ret = CheckInputName(INPUT_INT, (void *)&choice); @@ -526,58 +620,138 @@ int32_t SelectLoadingMode(char *resolvedPath, char *func) return HDF_FAILURE; } switch (choice) { - case 1: - snprintf_s(resolvedPath, PATH_LEN, PATH_LEN - 1, "%s", "/system/lib/libhdi_audio.z.so"); - snprintf_s(func, PATH_LEN, PATH_LEN - 1, "%s", "GetAudioManagerFuncs"); + case DIRECT: + if (snprintf_s(resolvedPath, PATH_LEN, PATH_LEN - 1, "%s", soPathHdi) < 0) { + return HDF_FAILURE; + } + if (snprintf_s(func, PATH_LEN, PATH_LEN - 1, "%s", "GetAudioManagerFuncs") < 0) { + return HDF_FAILURE; + } break; - case 2: // 2. Render Service Loading - snprintf_s(resolvedPath, PATH_LEN, PATH_LEN - 1, "%s", "/system/lib/libaudio_hdi_proxy_server.z.so"); - snprintf_s(func, PATH_LEN, PATH_LEN - 1, "%s", "GetAudioProxyManagerFuncs"); + case SERVICE: + if (snprintf_s(resolvedPath, PATH_LEN, PATH_LEN - 1, "%s", soPathProxy) < 0) { + return HDF_FAILURE; + } + if (snprintf_s(func, PATH_LEN, PATH_LEN - 1, "%s", "GetAudioProxyManagerFuncs") < 0) { + return HDF_FAILURE; + } break; default: printf("Input error,Switched to direct loading in for you,"); SystemInputFail(); - snprintf_s(resolvedPath, PATH_LEN, PATH_LEN - 1, "%s", "/system/lib/libhdi_audio.z.so"); - snprintf_s(func, PATH_LEN, PATH_LEN - 1, "%s", "GetAudioManagerFuncs"); + if (snprintf_s(resolvedPath, PATH_LEN, PATH_LEN - 1, "%s", soPathHdi) < 0) { + return HDF_FAILURE; + } + if (snprintf_s(func, PATH_LEN, PATH_LEN - 1, "%s", "GetAudioManagerFuncs") < 0) { + return HDF_FAILURE; + } break; } return HDF_SUCCESS; } -int32_t InitParamSplit(struct AudioAdapterDescriptor *descs, struct AudioManager *manager, - const char *adapterNameCase, int size) +int32_t GetRenderPassthroughManagerFunc(const char *adapterNameCase) { - if (descs == NULL || manager == NULL || adapterNameCase == NULL) { + if (adapterNameCase == NULL) { + LOG_FUN_ERR("The Parameter is NULL"); return HDF_FAILURE; } - int32_t index; - struct AudioPort renderPort; - /* Set sound card information */ + struct AudioManager *manager = NULL; + struct AudioAdapterDescriptor *descs = NULL; enum AudioPortDirection port = PORT_OUT; // Set port information - /* Get qualified sound card and port */ + struct AudioPort renderPort; + int32_t size = 0; + int32_t ret; + int32_t index; + struct AudioManager *(*getAudioManager)() = NULL; + getAudioManager = (struct AudioManager *(*)())(dlsym(g_handle, "GetAudioManagerFuncs")); + manager = getAudioManager(); + if (manager == NULL) { + LOG_FUN_ERR("Get Audio Manager Funcs Fail"); + return HDF_FAILURE; + } + ret = manager->GetAllAdapters(manager, &descs, &size); + int32_t check = size > MAX_AUDIO_ADAPTER_NUM_T || size == 0 || descs == NULL || ret < 0; + if (check) { + LOG_FUN_ERR("Get All Adapters Fail"); + return HDF_ERR_NOT_SUPPORT; + } index = SwitchAdapter(descs, adapterNameCase, port, &renderPort, size); if (index < 0) { - LOG_FUN_ERR_TS("Not Switch Adapter Fail"); + LOG_FUN_ERR("Not Switch Adapter Invalid"); return HDF_ERR_NOT_SUPPORT; } struct AudioAdapterDescriptor *desc = &descs[index]; if (manager->LoadAdapter(manager, desc, &g_adapter) != 0) { - LOG_FUN_ERR_TS("Load Adapter Fail"); + LOG_FUN_ERR("Load Adapter Fail"); return HDF_ERR_NOT_SUPPORT; } g_manager = manager; if (g_adapter == NULL) { - LOG_FUN_ERR_TS("load audio device failed"); + LOG_FUN_ERR("load audio device Invalid"); + return HDF_FAILURE; + } + (void)g_adapter->InitAllPorts(g_adapter); + if (InitAttrs(&g_attrs) < 0) { + g_manager->UnloadAdapter(g_manager, g_adapter); + return HDF_FAILURE; + } + // Specify a hardware device + if (InitDevDesc(&g_devDesc, renderPort.portId) < 0) { + g_manager->UnloadAdapter(g_manager, g_adapter); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t GetRenderProxyManagerFunc(const char *adapterNameCase) +{ + if (adapterNameCase == NULL) { + LOG_FUN_ERR("The Parameter is NULL"); + return HDF_FAILURE; + } + struct AudioProxyManager *proxyManager = NULL; + struct AudioAdapterDescriptor *descs = NULL; + enum AudioPortDirection port = PORT_OUT; // Set port information + struct AudioPort renderPort; + int32_t size = 0; + int32_t ret; + int32_t index; + struct AudioProxyManager *(*getAudioManager)() = NULL; + getAudioManager = (struct AudioProxyManager *(*)())(dlsym(g_handle, "GetAudioProxyManagerFuncs")); + proxyManager = getAudioManager(); + ret = proxyManager->GetAllAdapters(proxyManager, &descs, &size); + int32_t temp = size > MAX_AUDIO_ADAPTER_NUM_T || size == 0 || descs == NULL || ret < 0; + if (temp) { + LOG_FUN_ERR("Get All Adapters Fail"); + return HDF_ERR_NOT_SUPPORT; + } + // Get qualified sound card and port + index = SwitchAdapter(descs, adapterNameCase, port, &renderPort, size); + if (index < 0) { + LOG_FUN_ERR("Not Switch Adapter Fail"); + return HDF_ERR_NOT_SUPPORT; + } + struct AudioAdapterDescriptor *desc = &descs[index]; + if (proxyManager->LoadAdapter(proxyManager, desc, &g_adapter) != 0) { + LOG_FUN_ERR("Load Adapter Fail"); + return HDF_ERR_NOT_SUPPORT; + } + g_proxyManager = proxyManager; + if (g_adapter == NULL) { + LOG_FUN_ERR("load audio device failed"); return HDF_FAILURE; } // Initialization port information, can fill through mode and other parameters (void)g_adapter->InitAllPorts(g_adapter); // User needs to set if (InitAttrs(&g_attrs) < 0) { + g_proxyManager->UnloadAdapter(g_proxyManager, g_adapter); return HDF_FAILURE; } // Specify a hardware device if (InitDevDesc(&g_devDesc, renderPort.portId) < 0) { + g_proxyManager->UnloadAdapter(g_proxyManager, g_adapter); return HDF_FAILURE; } return HDF_SUCCESS; @@ -585,49 +759,35 @@ int32_t InitParamSplit(struct AudioAdapterDescriptor *descs, struct AudioManager int32_t InitParam() { - LOG_FUN_INFO_TS(); - struct AudioAdapterDescriptor *descs = NULL; - struct AudioManager *manager; - int32_t ret; - int32_t size = 0; /* Internal and external switch,begin */ char adapterNameCase[PATH_LEN] = {0}; if (SwitchInternalOrExternal(adapterNameCase) < 0) { return HDF_FAILURE; } - // audio port init - g_audioPort.dir = PORT_OUT; - g_audioPort.portId = 0; - g_audioPort.portName = "AOP"; - /* Internal and external switch,end */ - /* Select loading mode,begin */ - char resolvedPath[PATH_LEN] = {0}; + char resolvedPath[PATH_LEN] = {0}; // Select loading mode,begin char func[PATH_LEN] = {0}; if (SelectLoadingMode(resolvedPath, func) < 0) { return HDF_FAILURE; } /* Select loading mode,end */ - struct AudioManager *(*getAudioManager)() = NULL; + g_audioPort.dir = PORT_OUT; + g_audioPort.portId = 0; + g_audioPort.portName = "AOP"; g_handle = dlopen(resolvedPath, 1); if (g_handle == NULL) { - LOG_FUN_ERR_TS("Open so Fail"); - return HDF_FAILURE; - } - getAudioManager = (struct AudioManager *(*)())(dlsym(g_handle, func)); - manager = getAudioManager(); - if (manager == NULL) { - LOG_FUN_ERR_TS("Get Audio Manager Funcs Fail"); + LOG_FUN_ERR("Open so Fail, reason:%s", dlerror()); return HDF_FAILURE; } - ret = manager->GetAllAdapters(manager, &descs, &size); - int32_t check = size > MAX_AUDIO_ADAPTER_NUM_T || size == 0 || descs == NULL || ret < 0; - if (check) { - LOG_FUN_ERR_TS("Get All Adapters Fail"); - return HDF_ERR_NOT_SUPPORT; - } - ret = InitParamSplit(descs, manager, adapterNameCase, size); - if (ret < 0) { - return ret; + if (strcmp(func, "GetAudioManagerFuncs") == 0) { + if (GetRenderPassthroughManagerFunc(adapterNameCase) < 0) { + LOG_FUN_ERR("GetPassthroughManagerFunc Fail"); + return HDF_FAILURE; + } + } else { + if (GetRenderProxyManagerFunc(adapterNameCase) < 0) { + LOG_FUN_ERR("GetProxyManagerFunc Fail"); + return HDF_FAILURE; + } } return HDF_SUCCESS; } @@ -637,12 +797,12 @@ int32_t SetRenderMute() int32_t val; bool isMute = false; int32_t ret; - if (g_render == NULL) { + if (g_render == NULL || g_render->volume.GetMute == NULL) { return HDF_FAILURE; } ret = g_render->volume.GetMute((AudioHandle)g_render, &isMute); if (ret < 0) { - printf("The current mute state was not obtained!"); + LOG_FUN_ERR("The current mute state was not obtained!"); } printf("Now %s ,Do you need to set mute status(1/0):", isMute ? "mute" : "not mute"); ret = CheckInputName(INPUT_INT, (void *)&val); @@ -650,12 +810,12 @@ int32_t SetRenderMute() return HDF_FAILURE; } if (isMute != 0 && isMute != 1) { - printf("Invalid value,"); + LOG_FUN_ERR("Invalid value!"); SystemInputFail(); return HDF_FAILURE; } if (g_render == NULL) { - printf("Music already stop,"); + LOG_FUN_ERR("Music already stop!"); SystemInputFail(); return HDF_FAILURE; } @@ -669,12 +829,12 @@ int32_t SetRenderVolume() { int32_t ret; float val = 0.0; - if (g_render == NULL) { + if (g_render == NULL || g_render->volume.GetVolume == NULL) { return HDF_FAILURE; } ret = g_render->volume.GetVolume((AudioHandle)g_render, &val); if (ret < 0) { - printf("Get current volume failed,"); + LOG_FUN_ERR("Get current volume failed!"); SystemInputFail(); return ret; } @@ -682,18 +842,18 @@ int32_t SetRenderVolume() ret = CheckInputName(INPUT_FLOAT, (void *)&val); if (ret < 0) return HDF_FAILURE; if (val < 0.0 || val > 1.0) { - printf("Invalid volume value,"); + LOG_FUN_ERR("Invalid volume value!"); SystemInputFail(); return HDF_FAILURE; } if (g_render == NULL) { - printf("Music already stop,"); + LOG_FUN_ERR("Music already stop!"); SystemInputFail(); return HDF_FAILURE; } ret = g_render->volume.SetVolume((AudioHandle)g_render, val); if (ret < 0) { - printf("set volume fail,"); + LOG_FUN_ERR("set volume fail!"); SystemInputFail(); } return ret; @@ -703,12 +863,12 @@ int32_t GetRenderGain() { int32_t ret; float val = 1.0; - if (g_render == NULL) { + if (g_render == NULL || g_render->volume.GetGain == NULL) { return HDF_FAILURE; } ret = g_render->volume.GetGain((AudioHandle)g_render, &val); if (ret < 0) { - printf("Get current gain failed,"); + LOG_FUN_ERR("Get current gain failed!"); SystemInputFail(); return HDF_FAILURE; } @@ -720,12 +880,12 @@ int32_t GetRenderGain() int32_t SetRenderPause() { if (g_waitSleep) { - printf("Already pause,not need pause again,"); + LOG_FUN_ERR("Already pause,not need pause again!"); SystemInputFail(); return HDF_FAILURE; } int32_t ret; - if (g_render == NULL) { + if (g_render == NULL || g_render->control.Pause == NULL) { return HDF_FAILURE; } ret = g_render->control.Pause((AudioHandle)g_render); @@ -739,12 +899,12 @@ int32_t SetRenderPause() int32_t SetRenderResume() { if (!g_waitSleep) { - printf("Now is Playing,not need resume,"); + LOG_FUN_ERR("Now is Playing,not need resume!"); SystemInputFail(); return HDF_FAILURE; } int32_t ret; - if (g_render == NULL) { + if (g_render == NULL || g_render->control.Resume == NULL) { return HDF_FAILURE; } ret = g_render->control.Resume((AudioHandle)g_render); @@ -760,12 +920,12 @@ int32_t SetRenderResume() } void PrintAttributesFromat() { - printf(" ============= Sample Attributes Fromat =============== \n"); - printf("| 1. AUDIO_FORMAT_PCM_8_BIT |\n"); - printf("| 2. AUDIO_FORMAT_PCM_16_BIT |\n"); - printf("| 3. AUDIO_FORMAT_PCM_24_BIT |\n"); - printf("| 4. AUDIO_FORMAT_PCM_32_BIT |\n"); - printf(" ====================================================== \n"); + printf(" ============= Render Sample Attributes Fromat =============== \n"); + printf("| 1. Render AUDIO_FORMAT_PCM_8_BIT |\n"); + printf("| 2. Render AUDIO_FORMAT_PCM_16_BIT |\n"); + printf("| 3. Render AUDIO_FORMAT_PCM_24_BIT |\n"); + printf("| 4. Render AUDIO_FORMAT_PCM_32_BIT |\n"); + printf(" ============================================================= \n"); } int32_t SelectAttributesFomat(uint32_t *fomat) { @@ -798,9 +958,13 @@ int32_t SetRenderAttributes() { int32_t ret; struct AudioSampleAttributes attrs; + if (g_render == NULL || g_render->attr.GetSampleAttributes == NULL) { + LOG_FUN_ERR("The pointer is null!"); + return HDF_FAILURE; + } ret = g_render->attr.GetSampleAttributes((AudioHandle)g_render, &attrs); if (ret < 0) { - LOG_FUN_ERR_TS("GetRenderAttributes failed\n"); + LOG_FUN_ERR("GetRenderAttributes failed!"); } else { printf("Current sample attributes:\n"); printf("audioType is %u\nfomat is %u\nsampleRate is %u\nchannalCount is" @@ -815,7 +979,7 @@ int32_t SetRenderAttributes() printf("The sample attributes you want to set,Step by step, please.\n"); ret = SelectAttributesFomat((uint32_t *)(&attrs.format)); if (ret < 0) { - LOG_FUN_ERR_TS("SetRenderAttributes format failed\n"); + LOG_FUN_ERR("SetRenderAttributes format failed!"); return HDF_FAILURE; } printf("\nPlease input sample rate(48000,44100,32000...):"); @@ -829,13 +993,13 @@ int32_t SetRenderAttributes() return HDF_FAILURE; } if (g_render == NULL) { - printf("Music already complete,Please replay and set the attrbutes,"); + LOG_FUN_ERR("Music already complete,Please replay and set the attrbutes!"); SystemInputFail(); return HDF_FAILURE; } ret = g_render->attr.SetSampleAttributes((AudioHandle)g_render, &attrs); if (ret < 0) { - printf("\nSet render attributes failed,"); + LOG_FUN_ERR("Set render attributes failed!"); SystemInputFail(); } return ret; @@ -854,7 +1018,7 @@ int32_t SelectRenderScene() printf("Please input your choice:\n"); ret = CheckInputName(INPUT_INT, (void *)&val); if (ret < 0 || (val != 0 && val != 1)) { - printf("Invalid value,"); + LOG_FUN_ERR("Invalid value!"); SystemInputFail(); return HDF_FAILURE; } @@ -866,16 +1030,56 @@ int32_t SelectRenderScene() scene.desc.pins = PIN_OUT_SPEAKER; } if (g_render == NULL) { - printf("Music already stop,"); + LOG_FUN_ERR("Music already stop,"); SystemInputFail(); return HDF_FAILURE; } + if (g_render->scene.SelectScene == NULL) { + return HDF_FAILURE; + } ret = g_render->scene.SelectScene((AudioHandle)g_render, &scene); if (ret < 0) { - printf("Select scene fail\n"); + LOG_FUN_ERR("Select scene fail\n"); } return ret; } +int32_t GetExtParams() +{ + char keyValueList[BUFFER_LEN] = {0}; + int32_t ret; + if (g_render == NULL) { + return HDF_FAILURE; + } + ret = g_render->attr.GetExtraParams((AudioHandle)g_render, keyValueList, EXT_PARAMS_MAXLEN); + if (ret < 0) { + LOG_FUN_ERR("Get EXT params failed!"); + SystemInputFail(); + return HDF_FAILURE; + } + printf("keyValueList = %s\n", keyValueList); + return HDF_SUCCESS; +} + +int32_t GetRenderMmapPosition() +{ + int32_t ret; + if (g_render == NULL) { + return HDF_FAILURE; + } + uint64_t frames = 0; + struct AudioTimeStamp time; + time.tvNSec = 0; + time.tvSec = 0; + ret = g_render->attr.GetMmapPosition((AudioHandle)g_render, &frames, &time); + if (ret < 0) { + LOG_FUN_ERR("Get current Mmap frames Position failed!"); + SystemInputFail(); + return HDF_FAILURE; + } + printf("Now the Position is %"PRIu64"\n", frames); + return HDF_SUCCESS; +} + void PrintMenu2() { printf(" ================== Play Render Menu ================== \n"); @@ -888,7 +1092,9 @@ void PrintMenu2() printf("| 7. Render SetMute |\n"); printf("| 8. Render SetAttributes |\n"); printf("| 9. Render SelectScene |\n"); - printf("| 10.Exit |\n"); + printf("| 10. Render getEXtParams |\n"); + printf("| 11. Render getMmapPosition |\n"); + printf("| 12.Exit |\n"); printf(" ====================================================== \n"); } @@ -902,21 +1108,23 @@ static struct ProcessRenderMenuSwitchList g_processRenderMenuSwitchList[] = { {SET_RENDER_MUTE, SetRenderMute}, {SET_RENDER_ATTRIBUTES, SetRenderAttributes}, {SET_RENDER_SLECET_SCENE, SelectRenderScene}, + {GET_RENDER_EXT_PARAMS, GetExtParams}, + {GET_RENDER_POSITION, GetRenderMmapPosition}, }; void ProcessMenu(int32_t choice) { int32_t i; - if (choice == SET_RENDER_SLECET_SCENE + 1) { - printf("Exit from application program!\n"); + if (choice == GET_RENDER_POSITION + 1) { + LOG_FUN_ERR("Exit from application program!"); return; } if (g_render == NULL && choice != 1) { - printf("This render already release,"); + LOG_FUN_ERR("This render already release!"); SystemInputFail(); return; } - for (i = RENDER_START; i <= SET_RENDER_SLECET_SCENE; ++i) { + for (i = RENDER_START; i <= GET_RENDER_POSITION; ++i) { if ((choice == (int32_t)g_processRenderMenuSwitchList[i - 1].cmd) && (g_processRenderMenuSwitchList[i - 1].operation != NULL)) { g_processRenderMenuSwitchList[i - 1].operation(&g_render); @@ -924,26 +1132,11 @@ void ProcessMenu(int32_t choice) } } -int32_t main(int32_t argc, char const *argv[]) +void Choice() { - if (argc < 2) { - printf("usage:[1]%s [2]%s\n", argv[0], "/test/test.wav"); - return 0; - } - strncpy_s(g_path, PATH_LEN - 1, argv[1], strlen(argv[1]) + 1); - FILE *file = fopen(g_path, "rb"); - if (file == NULL) { - printf("Failed to open '%s',Please enter the correct file name \n", g_path); - return HDF_FAILURE; - } - fclose(file); int32_t choice = 0; int ret; - if (InitParam()) { // init - LOG_FUN_ERR_TS("InitParam Fail\n"); - return HDF_FAILURE; - } - while (choice < SET_RENDER_SLECET_SCENE + 1 && choice >= 0) { + while (choice < GET_RENDER_POSITION + 1 && choice >= 0) { system("clear"); PrintMenu2(); printf("your choice is:\n"); @@ -951,19 +1144,53 @@ int32_t main(int32_t argc, char const *argv[]) if (ret < 0) { continue; } - if (choice < RENDER_START || choice > SET_RENDER_SLECET_SCENE + 1) { - printf("You input is wrong,"); + if (choice < RENDER_START || choice > GET_RENDER_POSITION + 1) { + LOG_FUN_ERR("You input is wrong!"); choice = 0; SystemInputFail(); continue; } ProcessMenu(choice); } +} + +int32_t main(int32_t argc, char const *argv[]) +{ + if (argc < 2) { // The parameter number is not greater than 2 + printf("usage:[1]%s [2]%s\n", argv[0], "/test/test.wav"); + return 0; + } + if (argv[1] == NULL) { + return HDF_FAILURE; + } + int32_t ret = strncpy_s(g_path, PATH_LEN - 1, argv[1], strlen(argv[1]) + 1); + if (ret != 0) { + return HDF_FAILURE; + } + if (access(g_path, F_OK | R_OK)) { + return HDF_FAILURE; + } + + FILE *file = fopen(g_path, "rb"); + if (file == NULL) { + printf("Failed to open '%s',Please enter the correct file name \n", g_path); + return HDF_FAILURE; + } + fclose(file); + bool soMode = false; + if (InitParam()) { // init + LOG_FUN_ERR("InitParam Fail!"); + return HDF_FAILURE; + } + Choice(); if (g_render != NULL && g_adapter != NULL) { StopAudioFiles(&g_render); } if (g_manager != NULL) { + soMode = true; g_manager->UnloadAdapter(g_manager, g_adapter); + } else { + g_proxyManager->UnloadAdapter(g_proxyManager, g_adapter); } dlclose(g_handle); return 0; diff --git a/audio/supportlibs/adm_adapter/BUILD.gn b/audio/supportlibs/adm_adapter/BUILD.gn new file mode 100755 index 0000000000..88803ca156 --- /dev/null +++ b/audio/supportlibs/adm_adapter/BUILD.gn @@ -0,0 +1,217 @@ +# 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. + +if (defined(ohos_lite)) { + import("//build/lite/config/component/lite_component.gni") +} else { + import("//build/ohos.gni") +} +import("//drivers/adapter/uhdf2/uhdf.gni") +import("//drivers/peripheral/audio/audio.gni") + +config("audio_interface_config") { + visibility = [ ":*" ] + + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-DGST_DISABLE_DEPRECATED", + "-DHAVE_CONFIG_H", + "-fno-strict-aliasing", + "-Wno-sign-compare", + "-Wno-builtin-requires-header", + "-Wno-implicit-function-declaration", + "-Wno-format", + "-Wno-int-conversion", + "-Wno-unused-function", + "-Wno-unused-parameter", + "-Wno-thread-safety-attributes", + "-Wno-missing-field-initializers", + "-Wno-inconsistent-missing-override", + "-fno-rtti", + "-fno-exceptions", + "-ffunction-sections", + "-fdata-sections", + ] + + ldflags = [ "-Wl" ] +} + +if (defined(ohos_lite)) { + shared_library("hdi_audio_interface_lib_capture") { + sources = [ + "src/audio_interface_lib_capture.c", + "src/audio_interface_lib_common.c", + "$hdf_framework_path/ability/sbuf/src/hdf_sbuf.c", + "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_common.c" + ] + + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/supportlibs/adm_adapter/include", + "//drivers/peripheral/audio/interfaces/include", + "$hdf_framework_path/include/core", + "$hdf_framework_path/include/utils", + "$hdf_framework_path/include/osal", + "$hdf_framework_path/include", + "//third_party/bounds_checking_function/include", + "$hdf_framework_path/ability/sbuf/include", + "$hdf_framework_path/utils/include", + "$hdf_framework_path/ability/sbuf/include", + "$hdf_uhdf_path/osal/include", + "//base/hiviewdfx/hilog_lite/interfaces/native/kits/", + "//device/hisilicon/hispark_taurus/sdk_linux/huawei_proprietary/include" + ] + + deps = [ + "//third_party/bounds_checking_function:libsec_shared", + "//base/hiviewdfx/hilog_lite/frameworks/featured:hilog_shared", + "//drivers/adapter/uhdf/manager:hdf_core", + "//drivers/adapter/uhdf/posix:hdf_posix_osal" + ] + + public_configs = [ ":audio_interface_config" ] + } + + shared_library("hdi_audio_interface_lib_render") { + sources = [ + "src/audio_interface_lib_render.c", + "src/audio_interface_lib_common.c", + "$hdf_framework_path/ability/sbuf/src/hdf_sbuf.c", + "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_common.c" + ] + + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/supportlibs/adm_adapter/include", + "//drivers/peripheral/audio/interfaces/include", + "$hdf_framework_path/include/core", + "$hdf_framework_path/include/utils", + "$hdf_framework_path/include/osal", + "$hdf_framework_path/include", + "//third_party/bounds_checking_function/include", + "$hdf_framework_path/ability/sbuf/include", + "$hdf_framework_path/utils/include", + "$hdf_framework_path/ability/sbuf/include", + "$hdf_uhdf_path/osal/include", + "//base/hiviewdfx/hilog_lite/interfaces/native/kits/", + "//device/hisilicon/hispark_taurus/sdk_linux/huawei_proprietary/include" + ] + + deps = [ + "//third_party/bounds_checking_function:libsec_shared", + "//base/hiviewdfx/hilog_lite/frameworks/featured:hilog_shared", + "//drivers/adapter/uhdf/manager:hdf_core", + "//drivers/adapter/uhdf/posix:hdf_posix_osal" + ] + + public_configs = [ ":audio_interface_config" ] + } +} else { + ohos_shared_library("hdi_audio_interface_lib_capture") { + sources = [ + "src/audio_interface_lib_capture.c", + "src/audio_interface_lib_common.c", + "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_common.c" + ] + + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/supportlibs/adm_adapter/include", + "//drivers/peripheral/audio/interfaces/include", + "$hdf_framework_path/include/core", + "$hdf_framework_path/include/utils", + "$hdf_framework_path/include/osal", + "$hdf_framework_path/include", + "//third_party/bounds_checking_function/include", + "$hdf_framework_path/ability/sbuf/include", + "$hdf_framework_path/utils/include", + "$hdf_framework_path/ability/sbuf/include", + "$hdf_uhdf_path/osal/include", + "//device/hisilicon/hispark_taurus/sdk_linux/huawei_proprietary/include", + ] + + deps = [ + "$hdf_uhdf_path/osal:libhdf_utils", + "$hdf_uhdf_path/manager:hdf_devmgr", + "$hdf_uhdf_path/manager:hdf_devmgr.rc", + "//utils/native/base:utils", + "$hdf_uhdf_path/hdi:libhdi", + "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", + "$hdf_uhdf_path/host:hdf_devhost", + "$hdf_uhdf_path/host:libhdf_host", + "$hdf_uhdf_path/config:libhdf_hcs", + "$hdf_uhdf_path/hcs:hdf_default.hcb", + ] + + if (is_standard_system) { + external_deps = [ "hiviewdfx_hilog_native:libhilog" ] + } else { + external_deps = [ "hilog:libhilog" ] + } + + public_configs = [ ":audio_interface_config" ] + + subsystem_name = "hdf" + } + + ohos_shared_library("hdi_audio_interface_lib_render") { + sources = [ + "src/audio_interface_lib_render.c", + "src/audio_interface_lib_common.c", + "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_common.c", + ] + + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/supportlibs/adm_adapter/include", + "//drivers/peripheral/audio/interfaces/include", + "$hdf_framework_path/include/core", + "$hdf_framework_path/include/utils", + "$hdf_framework_path/include/osal", + "$hdf_framework_path/include", + "//third_party/bounds_checking_function/include", + "$hdf_framework_path/ability/sbuf/include", + "$hdf_framework_path/utils/include", + "$hdf_framework_path/ability/sbuf/include", + "$hdf_uhdf_path/osal/include", + "//device/hisilicon/hispark_taurus/sdk_linux/huawei_proprietary/include", + ] + + deps = [ + "$hdf_uhdf_path/osal:libhdf_utils", + "$hdf_uhdf_path/manager:hdf_devmgr", + "$hdf_uhdf_path/manager:hdf_devmgr.rc", + "//utils/native/base:utils", + "$hdf_uhdf_path/hdi:libhdi", + "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", + "$hdf_uhdf_path/host:hdf_devhost", + "$hdf_uhdf_path/host:libhdf_host", + "$hdf_uhdf_path/config:libhdf_hcs", + "$hdf_uhdf_path/hcs:hdf_default.hcb", + ] + + if (is_standard_system) { + external_deps = [ "hiviewdfx_hilog_native:libhilog" ] + } else { + external_deps = [ "hilog:libhilog" ] + } + + public_configs = [ ":audio_interface_config" ] + + subsystem_name = "hdf" + } +} + + diff --git a/audio/supportlibs/adm_adapter/include/audio_interface_lib_capture.h b/audio/supportlibs/adm_adapter/include/audio_interface_lib_capture.h index 6d05c98117..47385b1330 100755 --- a/audio/supportlibs/adm_adapter/include/audio_interface_lib_capture.h +++ b/audio/supportlibs/adm_adapter/include/audio_interface_lib_capture.h @@ -16,25 +16,13 @@ #ifndef AUDIO_INTERFACE_LIB_CAPTURE_H #define AUDIO_INTERFACE_LIB_CAPTURE_H -#include -#include -#include -#include -#include "securec.h" -#include "audio_internal.h" -#include "audio_adapter.h" -#include "osal_mem.h" -#include "hdf_io_service_if.h" -#include "hdf_sbuf.h" +#include "audio_interface_lib_common.h" #ifdef __cplusplus extern "C" { #endif -#define CTRL_CMD_CAPTURE "control" // For Bind control service -#define CAPTURE_CMD "capture" // For Bind capture service -#define SERVIC_NAME_MAX_LEN 32 -#define CTRL_NUM 100 +#define CAPTURE_CMD "capture" // For Bind capture service enum AudioCriBuffStatusCapture { CIR_BUFF_NORMAL = 1, @@ -58,30 +46,38 @@ enum AudioInterfaceLibCaptureCtrl { }; struct DevHandleCapture *AudioBindServiceCapture(const char *name); -void AudioCloseServiceCapture(struct DevHandleCapture *handle); +void AudioCloseServiceCapture(const struct DevHandleCapture *handle); int32_t AudioInterfaceLibModeCapture(struct DevHandleCapture *handle, - struct AudioHwCaptureParam *handleData, - int cmdId); -int32_t AudioOutputCaptureHwParams(struct DevHandleCapture *handle, - int cmdId, - struct AudioHwCaptureParam *handleData); -int32_t AudioOutputCaptureRead(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData); -int32_t AudioOutputCaptureStop(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData); -int32_t AudioOutputCaptureStartPrepare(struct DevHandleCapture *handle, + struct AudioHwCaptureParam *handleData, int cmdId); +int32_t AudioOutputCaptureHwParams(const struct DevHandleCapture *handle, + int cmdId, const struct AudioHwCaptureParam *handleData); +int32_t AudioOutputCaptureRead(const struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData); -int32_t AudioCtlCaptureGetVolume(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData); -int32_t AudioCtlCaptureSetVolume(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData); -int32_t AudioCtlCaptureGetMuteStu(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData); -int32_t AudioCtlCaptureSetMuteStu(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData); -int32_t AudioCtlCaptureSetPauseStu(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData); -int32_t AudioCtlCaptureSetGainStu(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData); -int32_t AudioCtlCaptureGetGainStu(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData); -int32_t AudioCtlCaptureSceneSelect(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData); -int32_t AudioCtlCaptureGetGainThreshold(struct DevHandleCapture *handle, - int cmdId, - struct AudioHwCaptureParam *handleData); - -int32_t AudioCtlCaptureGetVolThreshold(struct DevHandleCapture *handle, +int32_t AudioOutputCaptureStop(const struct DevHandleCapture *handle, + int cmdId, const struct AudioHwCaptureParam *handleData); +int32_t AudioOutputCaptureStartPrepare(const struct DevHandleCapture *handle, + int cmdId, const struct AudioHwCaptureParam *handleData); +int32_t AudioCtlCaptureGetVolume(const struct DevHandleCapture *handle, + int cmdId, struct AudioHwCaptureParam *handleData); +int32_t AudioCtlCaptureSetVolume(const struct DevHandleCapture *handle, + int cmdId, const struct AudioHwCaptureParam *handleData); +int32_t AudioCtlCaptureGetMuteStu(const struct DevHandleCapture *handle, + int cmdId, struct AudioHwCaptureParam *handleData); +int32_t AudioCtlCaptureSetMuteStu(const struct DevHandleCapture *handle, + int cmdId, const struct AudioHwCaptureParam *handleData); +int32_t AudioCtlCaptureSetPauseStu(const struct DevHandleCapture *handle, + int cmdId, const struct AudioHwCaptureParam *handleData); +int32_t AudioCtlCaptureSetGainStu(const struct DevHandleCapture *handle, + int cmdId, const struct AudioHwCaptureParam *handleData); +int32_t AudioCtlCaptureGetGainStu(const struct DevHandleCapture *handle, + int cmdId, struct AudioHwCaptureParam *handleData); +int32_t AudioCtlCaptureSceneSelect(const struct DevHandleCapture *handle, + int cmdId, const struct AudioHwCaptureParam *handleData); +int32_t AudioCtlCaptureGetGainThreshold(const struct DevHandleCapture *handle, + int cmdId, struct AudioHwCaptureParam *handleData); +int32_t AudioCtlCaptureGetVolThreshold(const struct DevHandleCapture *handle, + int cmdId, struct AudioHwCaptureParam *handleData); +int32_t AudioOutputCaptureReqMmapBuffer(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData); #ifdef __cplusplus } diff --git a/audio/supportlibs/adm_adapter/include/audio_interface_lib_common.h b/audio/supportlibs/adm_adapter/include/audio_interface_lib_common.h old mode 100644 new mode 100755 index 678abccdb8..7251a222e6 --- a/audio/supportlibs/adm_adapter/include/audio_interface_lib_common.h +++ b/audio/supportlibs/adm_adapter/include/audio_interface_lib_common.h @@ -16,12 +16,68 @@ #ifndef AUDIO_INTERFACE_LIB_COMMON_H #define AUDIO_INTERFACE_LIB_COMMON_H -#include "audio_interface_lib_render.h" -#include "audio_interface_lib_capture.h" +#include +#include +#include +#include +#include "securec.h" +#include "audio_internal.h" +#include "audio_adapter.h" +#include "osal_mem.h" +#include "hdf_io_service_if.h" +#include "hdf_sbuf.h" -#define AUDIODRV_CTL_ELEM_IFACE_GAIN 2 -#define AUDIO_MIN_DEVICENUM 1 +#define CTRL_NUM 100 +#define SERVIC_NAME_MAX_LEN 32 +#define AUDIO_MIN_DEVICENUM 1 +#define AUDIODRV_CTL_ELEM_IFACE_GAIN 2 + +#define AUDIO_WAIT_DELAY (10 * 1000) // 10ms +#define AUDIO_CAP_WAIT_DELAY (5 * 1000) // 5ms + +#define CTRL_CMD "control" // For Bind control service + +struct AudioPcmHwParams { + enum AudioStreamType streamType; + uint32_t channels; + uint32_t rate; + uint32_t periodSize; + uint32_t periodCount; + enum AudioFormat format; + char *cardServiceName; + uint32_t period; + uint32_t frameSize; + uint32_t startThreshold; + uint32_t stopThreshold; + uint32_t silenceThreshold; + bool isBigEndian; + bool isSignedData; +}; + +struct AudioCtlElemId { + const char *cardServiceName; + const char *itemName; /* ASCII name of item */ + int32_t iface; +}; + +struct AudioCtlElemValue { + struct AudioCtlElemId id; + int32_t value[2]; +}; + +struct AudioCtrlElemInfo { + struct AudioCtlElemId id; + uint32_t count; /* count of values */ + int32_t type; /* R: value type - AUDIODRV_CTL_ELEM_IFACE_MIXER_* */ + int32_t min; /* R: minimum value */ + int32_t max; /* R: maximum value */ +}; struct HdfIoService *HdfIoServiceBindName(const char *serviceName); +void AudioBufReplyRecycle(struct HdfSBuf *sBuf, struct HdfSBuf *reply); +int32_t AudioServiceDispatch(struct HdfIoService *service, int cmdId, + struct HdfSBuf *sBuf, struct HdfSBuf *reply); +struct HdfSBuf *AudioObtainHdfSBuf(void); +int32_t AudioCtlGetVolThresholdRead(struct HdfSBuf *reply, struct AudioCtrlElemInfo *volThreshold); #endif /* AUDIO_INTERFACE_LIB_COMMON_H */ diff --git a/audio/supportlibs/adm_adapter/include/audio_interface_lib_render.h b/audio/supportlibs/adm_adapter/include/audio_interface_lib_render.h index a37158c7ab..a095368e56 100755 --- a/audio/supportlibs/adm_adapter/include/audio_interface_lib_render.h +++ b/audio/supportlibs/adm_adapter/include/audio_interface_lib_render.h @@ -16,25 +16,13 @@ #ifndef AUDIO_INTERFACE_LIB_RENDER_H #define AUDIO_INTERFACE_LIB_RENDER_H -#include -#include -#include -#include -#include "securec.h" -#include "audio_internal.h" -#include "audio_adapter.h" -#include "osal_mem.h" -#include "hdf_io_service_if.h" -#include "hdf_sbuf.h" +#include "audio_interface_lib_common.h" #ifdef __cplusplus extern "C" { #endif -#define CTRL_CMD "control" // For Bind control service -#define RENDER_CMD "render" // For Bind render service -#define SERVIC_NAME_MAX_LEN 32 -#define CTRL_NUM 100 +#define RENDER_CMD "render" // For Bind render service enum AudioCriBuffStatus { CIR_BUFF_NO_FULL = 1, @@ -67,25 +55,39 @@ struct InterfaceLibCtlRenderList { }; struct DevHandle *AudioBindServiceRender(const char *name); -void AudioCloseServiceRender(struct DevHandle *handle); +void AudioCloseServiceRender(const struct DevHandle *handle); int32_t AudioInterfaceLibModeRender(struct DevHandle *handle, struct AudioHwRenderParam *handleData, int cmdId); -int32_t AudioOutputRenderHwParams(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); -int32_t AudioOutputRenderWrite(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); -int32_t AudioOutputRenderStop(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); -int32_t AudioOutputRenderStartPrepare(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); -int32_t AudioCtlRenderGetVolume(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); -int32_t AudioCtlRenderSetVolume(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); -int32_t AudioCtlRenderGetMuteStu(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); -int32_t AudioCtlRenderSetMuteStu(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); -int32_t AudioCtlRenderSetPauseStu(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); -int32_t AudioCtlRenderGetChannelMode(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); -int32_t AudioCtlRenderSetChannelMode(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); -int32_t AudioCtlRenderSetGainStu(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); -int32_t AudioCtlRenderGetGainStu(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); -int32_t AudioCtlRenderSceneSelect(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); -int32_t AudioCtlRenderSceneGetGainThreshold(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); -int32_t AudioCtlRenderSetAcodecMode(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); -int32_t AudioCtlRenderGetVolThreshold(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); +int32_t AudioOutputRenderHwParams(const struct DevHandle *handle, + const int cmdId, const struct AudioHwRenderParam *handleData); +int32_t AudioOutputRenderWrite(const struct DevHandle *handle, + const int cmdId, const struct AudioHwRenderParam *handleData); +int32_t AudioOutputRenderStop(const struct DevHandle *handle, + const int cmdId, const struct AudioHwRenderParam *handleData); +int32_t AudioOutputRenderStartPrepare(struct DevHandle *handle, + const int cmdId, const struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderGetVolume(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderSetVolume(const struct DevHandle *handle, + int cmdId, const struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderGetMuteStu(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderSetMuteStu(const struct DevHandle *handle, + int cmdId, const struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderSetPauseStu(const struct DevHandle *handle, + int cmdId, const struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderGetChannelMode(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderSetChannelMode(const struct DevHandle *handle, + int cmdId, const struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderSetGainStu(const struct DevHandle *handle, + int cmdId, const struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderGetGainStu(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderSceneSelect(const struct DevHandle *handle, + int cmdId, const struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderSceneGetGainThreshold(const struct DevHandle *handle, + int cmdId, struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderSetAcodecMode(const struct DevHandle *handle, + const int cmdId, const struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderGetVolThreshold(const struct DevHandle *handle, + int cmdId, struct AudioHwRenderParam *handleData); +int32_t AudioOutputRenderReqMmapBuffer(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); #ifdef __cplusplus } diff --git a/audio/supportlibs/adm_adapter/src/BUILD.gn b/audio/supportlibs/adm_adapter/src/BUILD.gn deleted file mode 100755 index 9a76e3752c..0000000000 --- a/audio/supportlibs/adm_adapter/src/BUILD.gn +++ /dev/null @@ -1,143 +0,0 @@ -# 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. - -if (defined(ohos_lite)) { - import("//build/lite/config/component/lite_component.gni") -} else { - import("//build/ohos.gni") -} -import("//drivers/adapter/uhdf2/uhdf.gni") -import("//drivers/peripheral/audio/audio.gni") - -config("audio_interface_config") { - visibility = [ ":*" ] - - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-DGST_DISABLE_DEPRECATED", - "-DHAVE_CONFIG_H", - "-fno-strict-aliasing", - "-Wno-sign-compare", - "-Wno-builtin-requires-header", - "-Wno-implicit-function-declaration", - "-Wno-format", - "-Wno-int-conversion", - "-Wno-unused-function", - "-Wno-unused-parameter", - "-Wno-thread-safety-attributes", - "-Wno-missing-field-initializers", - "-Wno-inconsistent-missing-override", - "-fno-rtti", - "-fno-exceptions", - "-ffunction-sections", - "-fdata-sections", - ] - - ldflags = [ "-Wl" ] -} - -ohos_shared_library("hdi_audio_interface_lib_capture") { - sources = [ - "audio_interface_lib_capture.c", - "audio_interface_lib_common.c", - "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_common.c", - ] - - include_dirs = [ - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/supportlibs/adm_adapter/include", - "//drivers/peripheral/audio/interfaces/include", - "$hdf_framework_path/include/core", - "$hdf_framework_path/include/utils", - "$hdf_framework_path/include/osal", - "$hdf_framework_path/include", - "//third_party/bounds_checking_function/include", - "$hdf_framework_path/ability/sbuf/include", - "$hdf_framework_path/utils/include", - "$hdf_framework_path/ability/sbuf/include", - "$hdf_uhdf_path/osal/include", - "//device/hisilicon/hispark_taurus/sdk_linux/huawei_proprietary/include", - ] - - deps = [ - "$hdf_uhdf_path/osal:libhdf_utils", - "$hdf_uhdf_path/manager:hdf_devmgr", - "$hdf_uhdf_path/manager:hdf_devmgr.rc", - "//utils/native/base:utils", - "$hdf_uhdf_path/hdi:libhdi", - "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", - "$hdf_uhdf_path/host:hdf_devhost", - "$hdf_uhdf_path/host:libhdf_host", - "$hdf_uhdf_path/config:libhdf_hcs", - "$hdf_uhdf_path/hcs:hdf_default.hcb", - ] - - if (is_standard_system) { - external_deps = [ "hiviewdfx_hilog_native:libhilog" ] - } else { - external_deps = [ "hilog:libhilog" ] - } - - public_configs = [ ":audio_interface_config" ] - - subsystem_name = "hdf" -} - -ohos_shared_library("hdi_audio_interface_lib_render") { - sources = [ - "audio_interface_lib_render.c", - "audio_interface_lib_common.c", - "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_common.c", - ] - - include_dirs = [ - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/supportlibs/adm_adapter/include", - "//drivers/peripheral/audio/interfaces/include", - "$hdf_framework_path/include/core", - "$hdf_framework_path/include/utils", - "$hdf_framework_path/include/osal", - "$hdf_framework_path/include", - "//third_party/bounds_checking_function/include", - "$hdf_framework_path/ability/sbuf/include", - "$hdf_framework_path/utils/include", - "$hdf_framework_path/ability/sbuf/include", - "$hdf_uhdf_path/osal/include", - "//device/hisilicon/hispark_taurus/sdk_linux/huawei_proprietary/include", - ] - - deps = [ - "$hdf_uhdf_path/osal:libhdf_utils", - "$hdf_uhdf_path/manager:hdf_devmgr", - "$hdf_uhdf_path/manager:hdf_devmgr.rc", - "//utils/native/base:utils", - "$hdf_uhdf_path/hdi:libhdi", - "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", - "$hdf_uhdf_path/host:hdf_devhost", - "$hdf_uhdf_path/host:libhdf_host", - "$hdf_uhdf_path/config:libhdf_hcs", - "$hdf_uhdf_path/hcs:hdf_default.hcb", - ] - - if (is_standard_system) { - external_deps = [ "hiviewdfx_hilog_native:libhilog" ] - } else { - external_deps = [ "hilog:libhilog" ] - } - - public_configs = [ ":audio_interface_config" ] - - subsystem_name = "hdf" -} diff --git a/audio/supportlibs/adm_adapter/src/audio_interface_lib_capture.c b/audio/supportlibs/adm_adapter/src/audio_interface_lib_capture.c index a5fc94f564..e21b370ffd 100755 --- a/audio/supportlibs/adm_adapter/src/audio_interface_lib_capture.c +++ b/audio/supportlibs/adm_adapter/src/audio_interface_lib_capture.c @@ -13,7 +13,7 @@ * limitations under the License. */ -#include "audio_interface_lib_common.h" +#include "audio_interface_lib_capture.h" /* virtual mixer device */ #define AUDIODRV_CTL_CAPTUREELEM_IFACE_MIXER ((int32_t)2) @@ -21,110 +21,32 @@ #define AUDIODRV_CTL_ELEM_IFACE_SELECT 5 #define AUDIO_REPLY_EXTEND 16 #define AUDIO_SIZE_FRAME_16K (16 * 1024) -#define AUDIO_WAIT_MSEC 10000 -/* Out Put Render/Capture */ -static struct AudioPcmHwParams { - enum AudioStreamType streamType; - uint32_t channels; - uint32_t rate; - uint32_t periodSize; - uint32_t periodCount; - enum AudioFormat format; - char *cardServiceName; - uint32_t period; - uint32_t frameSize; - bool isBigEndian; - bool isSignedData; - uint32_t startThreshold; - uint32_t stopThreshold; - uint32_t silenceThreshold; -} g_hwParams; - -/* Frames data and size */ -struct AudioCtlCaptureElemId { - const char *cardServiceName; - int32_t iface; - const char *itemName; -}; - -static struct AudioCtlCaptureElemValue { - struct AudioCtlCaptureElemId id; - int32_t value[2]; -} g_elemCaptureValue; - -static struct AudioCtrlCaptureElemInfo { - struct AudioCtlCaptureElemId id; - uint32_t count; /* count of values */ - int32_t type; /* R: value type - AUDIODRV_CTL_ELEM_IFACE_MIXER_* */ - int32_t min; /* R: minimum value */ - int32_t max; /* R: maximum value */ -} g_elemCaptureInfo; - -struct HdfSBuf *AudioCapturebtainHdfSBuf() -{ - enum HdfSbufType bufType; -#ifdef AUDIO_HDF_SBUF_IPC - bufType = SBUF_IPC; -#else - bufType = SBUF_RAW; -#endif - return HdfSBufTypedObtain(bufType); -} - -char *g_audioServiceCapture[AUDIO_SERVICE_MAX] = { +/* Out Put Capture */ +static struct AudioPcmHwParams g_hwParams; +static char *g_audioLibCaptureService[AUDIO_SERVICE_MAX] = { [AUDIO_SERVICE_IN] = "hdf_audio_codec_dev0", [AUDIO_SERVICE_OUT] = "hdf_audio_smartpa_dev0", }; -void AudioCaptureBufReplyRecycle(struct HdfSBuf *sBuf, struct HdfSBuf *reply) -{ - if (sBuf != NULL) { - HdfSBufRecycle(sBuf); - } - if (reply != NULL) { - HdfSBufRecycle(reply); - } - return; -} - -int32_t AudioServiceCaptureDispatch(struct HdfIoService *service, - int cmdId, - struct HdfSBuf *sBuf, - struct HdfSBuf *reply) -{ - if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL || - sBuf == NULL) { - LOG_FUN_ERR("Service is NULL!"); - return HDF_FAILURE; - } - int32_t ret; - ret = service->dispatcher->Dispatch(&(service->object), cmdId, sBuf, reply); - if (ret != HDF_SUCCESS) { - LOG_FUN_ERR("Failed to send service call!"); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - int32_t SetHwParamsCapture(const struct AudioHwCaptureParam * const handleData) { if (handleData == NULL) { LOG_FUN_ERR("handleData is NULL!"); return HDF_FAILURE; } - memset_s(&g_hwParams, sizeof(struct AudioPcmHwParams), 0, sizeof(struct AudioPcmHwParams)); uint32_t card = handleData->captureMode.hwInfo.card; - if (card < 0 || card >= AUDIO_SERVICE_MAX) { + if (card >= AUDIO_SERVICE_MAX) { LOG_FUN_ERR("card is Error!"); return HDF_FAILURE; } + memset_s(&g_hwParams, sizeof(struct AudioPcmHwParams), 0, sizeof(struct AudioPcmHwParams)); g_hwParams.streamType = AUDIO_CAPTURE_STREAM; g_hwParams.channels = handleData->frameCaptureMode.attrs.channelCount; g_hwParams.rate = handleData->frameCaptureMode.attrs.sampleRate; g_hwParams.periodSize = handleData->frameCaptureMode.periodSize; g_hwParams.periodCount = handleData->frameCaptureMode.periodCount; - g_hwParams.cardServiceName = g_audioServiceCapture[card]; + g_hwParams.cardServiceName = g_audioLibCaptureService[card]; g_hwParams.format = handleData->frameCaptureMode.attrs.format; g_hwParams.period = handleData->frameCaptureMode.attrs.period; g_hwParams.frameSize = handleData->frameCaptureMode.attrs.frameSize; @@ -138,6 +60,9 @@ int32_t SetHwParamsCapture(const struct AudioHwCaptureParam * const handleData) int32_t ParamsSbufWriteBuffer(struct HdfSBuf *sBuf) { + if (sBuf == NULL) { + return HDF_FAILURE; + } if (!HdfSbufWriteUint32(sBuf, (uint32_t)g_hwParams.streamType)) { return HDF_FAILURE; } @@ -183,52 +108,53 @@ int32_t ParamsSbufWriteBuffer(struct HdfSBuf *sBuf) return HDF_SUCCESS; } -int32_t AudioCtlCaptureSetPauseBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureSetPauseBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData) { if (handleData == NULL || sBuf == NULL) { LOG_FUN_ERR("handleData or sBuf is NULL!"); return HDF_FAILURE; } - memset_s(&g_elemCaptureValue, sizeof(struct AudioCtlCaptureElemValue), 0, sizeof(struct AudioCtlCaptureElemValue)); uint32_t card = handleData->captureMode.hwInfo.card; - if (card < 0 || card >= AUDIO_SERVICE_MAX) { + if (card >= AUDIO_SERVICE_MAX) { LOG_FUN_ERR("wrong card!"); return HDF_FAILURE; } - g_elemCaptureValue.id.cardServiceName = g_audioServiceCapture[card]; - g_elemCaptureValue.id.iface = AUDIODRV_CTL_CAPTUREELEM_IFACE_MIXER; - g_elemCaptureValue.id.itemName = "Master Playback Pause"; - g_elemCaptureValue.value[0] = (int32_t)handleData->captureMode.ctlParam.pause; - if (!HdfSbufWriteInt32(sBuf, g_elemCaptureValue.value[0])) { + struct AudioCtlElemValue elemCaptureValue; + elemCaptureValue.id.cardServiceName = g_audioLibCaptureService[card]; + elemCaptureValue.id.iface = AUDIODRV_CTL_CAPTUREELEM_IFACE_MIXER; + elemCaptureValue.id.itemName = "Master Playback Pause"; + elemCaptureValue.value[0] = (int32_t)handleData->captureMode.ctlParam.pause; + if (!HdfSbufWriteInt32(sBuf, elemCaptureValue.value[0])) { LOG_FUN_ERR("CaptureSetPauseBuf pause Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteInt32(sBuf, g_elemCaptureValue.id.iface)) { + if (!HdfSbufWriteInt32(sBuf, elemCaptureValue.id.iface)) { LOG_FUN_ERR("CaptureSetPauseBuf iface Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemCaptureValue.id.cardServiceName)) { + if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.cardServiceName)) { LOG_FUN_ERR("CaptureSetPauseBuf cardServiceName Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemCaptureValue.id.itemName)) { + if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.itemName)) { LOG_FUN_ERR("CaptureSetPauseBuf itemName Write Fail!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlCaptureSetPauseStu(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureSetPauseStu(const struct DevHandleCapture *handle, + int cmdId, const struct AudioHwCaptureParam *handleData) { int32_t ret; - LOG_FUN_INFO(); + if (handle == NULL || handle->object == NULL || handleData == NULL) { LOG_FUN_ERR("CaptureSetPauseStu paras is NULL!"); return HDF_FAILURE; } struct HdfIoService *service = NULL; struct HdfSBuf *reply = NULL; - struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); if (sBuf == NULL) { LOG_FUN_ERR("CaptureSetPauseStu Failed to obtain sBuf"); return HDF_FAILURE; @@ -236,143 +162,139 @@ int32_t AudioCtlCaptureSetPauseStu(struct DevHandleCapture *handle, int cmdId, s ret = AudioCtlCaptureSetPauseBuf(sBuf, handleData); if (ret < 0) { LOG_FUN_ERR("Failed to Set Pause sBuf!"); - AudioCaptureBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return ret; } - if (handleData->captureMode.ctlParam.pause) { - cmdId = AUDIO_DRV_PCM_IOCTRL_PAUSE_CAPTURE; - } else { - cmdId = AUDIO_DRV_PCM_IOCTRL_RESUME_CAPTURE; - } service = (struct HdfIoService *)handle->object; if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { LOG_FUN_ERR("SetPauseStu Service is NULL!"); - AudioCaptureBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } + cmdId = handleData->captureMode.ctlParam.pause ? + AUDIO_DRV_PCM_IOCTRL_PAUSE_CAPTURE : AUDIO_DRV_PCM_IOCTRL_RESUME_CAPTURE; ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, reply); if (ret != HDF_SUCCESS) { LOG_FUN_ERR("SetPauseStu Failed to send service call!"); - AudioCaptureBufReplyRecycle(sBuf, NULL); - return ret; } - AudioCaptureBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return ret; } -int32_t AudioCtlCaptureGetVolumeSBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureGetVolumeSBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData) { if (handleData == NULL || sBuf == NULL) { LOG_FUN_ERR("CaptureGetVolumeSBuf parameter is empty!"); return HDF_FAILURE; } - memset_s(&g_elemCaptureValue, sizeof(struct AudioCtlCaptureElemValue), 0, sizeof(struct AudioCtlCaptureElemValue)); uint32_t card = handleData->captureMode.hwInfo.card; - if (card < 0 || card >= AUDIO_SERVICE_MAX) { + if (card >= AUDIO_SERVICE_MAX) { LOG_FUN_ERR("card is Error!"); return HDF_FAILURE; } - g_elemCaptureValue.id.cardServiceName = g_audioServiceCapture[card]; - g_elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_ADC; - g_elemCaptureValue.id.itemName = "Master Capture Volume"; - if (!HdfSbufWriteInt32(sBuf, g_elemCaptureValue.id.iface)) { + struct AudioCtlElemValue elemCaptureValue; + elemCaptureValue.id.cardServiceName = g_audioLibCaptureService[card]; + elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_ADC; + elemCaptureValue.id.itemName = "Master Capture Volume"; + if (!HdfSbufWriteInt32(sBuf, elemCaptureValue.id.iface)) { LOG_FUN_ERR("CaptureGetVolumeSBuf iface Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemCaptureValue.id.cardServiceName)) { + if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.cardServiceName)) { LOG_FUN_ERR("CaptureGetVolumeSBuf cardServiceName Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemCaptureValue.id.itemName)) { + if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.itemName)) { LOG_FUN_ERR("CaptureGetVolumeSBuf itemName Write Fail!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlCaptureGetVolume(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureGetVolume(const struct DevHandleCapture *handle, + int cmdId, struct AudioHwCaptureParam *handleData) { int32_t ret; - LOG_FUN_INFO(); + if (handle == NULL || handle->object == NULL || handleData == NULL) { LOG_FUN_ERR("CaptureGetVolume paras is NULL!"); return HDF_FAILURE; } struct HdfIoService *service = NULL; struct HdfSBuf *reply = NULL; - struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); if (sBuf == NULL) { LOG_FUN_ERR("CaptureGetVolume Failed to obtain sBuf"); return HDF_FAILURE; } - reply = AudioCapturebtainHdfSBuf(); + reply = AudioObtainHdfSBuf(); if (reply == NULL) { LOG_FUN_ERR("Failed to obtain reply"); - AudioCaptureBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } ret = AudioCtlCaptureGetVolumeSBuf(sBuf, handleData); if (ret < 0) { LOG_FUN_ERR("Failed to Get Volume sBuf!"); - AudioCaptureBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return ret; } - cmdId = AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE - CTRL_NUM; // ADM Ctrl Num Begin zero service = (struct HdfIoService *)handle->object; - ret = AudioServiceCaptureDispatch(service, cmdId, sBuf, reply); + cmdId = AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE - CTRL_NUM; + ret = AudioServiceDispatch(service, cmdId, sBuf, reply); if (ret != HDF_SUCCESS) { LOG_FUN_ERR("GetVolume Dispatch Fail!"); - AudioCaptureBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } - struct AudioCtlCaptureElemValue elemValue; - memset_s(&elemValue, sizeof(struct AudioCtlCaptureElemValue), 0, sizeof(struct AudioCtlCaptureElemValue)); - if (!HdfSbufReadInt32(reply, &elemValue.value[0])) { + int32_t elemValue = 0; + if (!HdfSbufReadInt32(reply, &elemValue)) { LOG_FUN_ERR("Failed to Get Volume sBuf!"); - AudioCaptureBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } - handleData->captureMode.ctlParam.volume = elemValue.value[0]; - AudioCaptureBufReplyRecycle(sBuf, reply); + handleData->captureMode.ctlParam.volume = (float)elemValue; + AudioBufReplyRecycle(sBuf, reply); return ret; } -int32_t AudioCtlCaptureSetVolumeSBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureSetVolumeSBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData) { if (handleData == NULL || sBuf == NULL) { LOG_FUN_ERR("CaptureSetVolumeSBuf parameter is empty!"); return HDF_FAILURE; } - memset_s(&g_elemCaptureValue, sizeof(struct AudioCtlCaptureElemValue), 0, sizeof(struct AudioCtlCaptureElemValue)); uint32_t card = handleData->captureMode.hwInfo.card; - if (card < 0 || card >= AUDIO_SERVICE_MAX) { + if (card >= AUDIO_SERVICE_MAX) { LOG_FUN_ERR("CaptureSetVolumeSBuf card is Error!"); return HDF_FAILURE; } - g_elemCaptureValue.id.cardServiceName = g_audioServiceCapture[card]; - g_elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_ADC; - g_elemCaptureValue.id.itemName = "Master Capture Volume"; - g_elemCaptureValue.value[0] = (int32_t)handleData->captureMode.ctlParam.volume; - if (!HdfSbufWriteInt32(sBuf, g_elemCaptureValue.value[0])) { + struct AudioCtlElemValue elemCaptureValue; + elemCaptureValue.id.cardServiceName = g_audioLibCaptureService[card]; + elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_ADC; + elemCaptureValue.id.itemName = "Master Capture Volume"; + elemCaptureValue.value[0] = (int32_t)handleData->captureMode.ctlParam.volume; + if (!HdfSbufWriteInt32(sBuf, elemCaptureValue.value[0])) { LOG_FUN_ERR("CaptureSetVolumeSBuf value[0] Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteInt32(sBuf, g_elemCaptureValue.id.iface)) { + if (!HdfSbufWriteInt32(sBuf, elemCaptureValue.id.iface)) { LOG_FUN_ERR("CaptureSetVolumeSBuf iface Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemCaptureValue.id.cardServiceName)) { + if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.cardServiceName)) { LOG_FUN_ERR("CaptureSetVolumeSBuf cardServiceName Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemCaptureValue.id.itemName)) { + if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.itemName)) { LOG_FUN_ERR("CaptureSetVolumeSBuf itemName Write Fail!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlCaptureSetVolume(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureSetVolume(const struct DevHandleCapture *handle, + int cmdId, const struct AudioHwCaptureParam *handleData) { int32_t ret; LOG_FUN_INFO(); @@ -382,7 +304,7 @@ int32_t AudioCtlCaptureSetVolume(struct DevHandleCapture *handle, int cmdId, str } struct HdfIoService *service = NULL; struct HdfSBuf *reply = NULL; - struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); if (sBuf == NULL) { LOG_FUN_ERR("CaptureSetVolume Failed to obtain sBuf"); return HDF_FAILURE; @@ -390,73 +312,71 @@ int32_t AudioCtlCaptureSetVolume(struct DevHandleCapture *handle, int cmdId, str ret = AudioCtlCaptureSetVolumeSBuf(sBuf, handleData); if (ret < 0) { LOG_FUN_ERR("CaptureSetVolume Failed to Set Volume sBuf!"); - AudioCaptureBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return ret; } - cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE; - cmdId -= CTRL_NUM; // ADM Ctrl Num Begin zero service = (struct HdfIoService *)handle->object; if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { LOG_FUN_ERR("CaptureSetVolume Service is NULL!"); - AudioCaptureBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } + cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE - CTRL_NUM; ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, reply); if (ret != HDF_SUCCESS) { LOG_FUN_ERR("CaptureSetVolume Failed to send service call!"); - AudioCaptureBufReplyRecycle(sBuf, NULL); - return HDF_FAILURE; } - AudioCaptureBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return ret; } -int32_t AudioCtlCaptureSetMuteSBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureSetMuteSBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData) { if (handleData == NULL || sBuf == NULL) { LOG_FUN_ERR("handleData or sBuf is NULL!"); return HDF_FAILURE; } - memset_s(&g_elemCaptureValue, sizeof(struct AudioCtlCaptureElemValue), 0, sizeof(struct AudioCtlCaptureElemValue)); uint32_t card = handleData->captureMode.hwInfo.card; - if (card < 0 || card >= AUDIO_SERVICE_MAX) { + if (card >= AUDIO_SERVICE_MAX) { LOG_FUN_ERR("CaptureSetMuteSBuf card is Error!"); return HDF_FAILURE; } - g_elemCaptureValue.id.cardServiceName = g_audioServiceCapture[card]; - g_elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_ADC; - g_elemCaptureValue.id.itemName = "Capture Mute"; - g_elemCaptureValue.value[0] = (int32_t)handleData->captureMode.ctlParam.mute; - if (!HdfSbufWriteInt32(sBuf, g_elemCaptureValue.value[0])) { + struct AudioCtlElemValue elemCaptureValue; + elemCaptureValue.id.cardServiceName = g_audioLibCaptureService[card]; + elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_ADC; + elemCaptureValue.id.itemName = "Capture Mute"; + elemCaptureValue.value[0] = (int32_t)handleData->captureMode.ctlParam.mute; + if (!HdfSbufWriteInt32(sBuf, elemCaptureValue.value[0])) { LOG_FUN_ERR("CaptureSetMuteSBuf mute Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteInt32(sBuf, g_elemCaptureValue.id.iface)) { + if (!HdfSbufWriteInt32(sBuf, elemCaptureValue.id.iface)) { LOG_FUN_ERR("CaptureSetMuteSBuf iface Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemCaptureValue.id.cardServiceName)) { + if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.cardServiceName)) { LOG_FUN_ERR("CaptureSetMuteSBuf cardServiceName Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemCaptureValue.id.itemName)) { + if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.itemName)) { LOG_FUN_ERR("CaptureSetMuteSBuf itemName Write Fail!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlCaptureSetMuteStu(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureSetMuteStu(const struct DevHandleCapture *handle, + int cmdId, const struct AudioHwCaptureParam *handleData) { int32_t ret; - LOG_FUN_INFO(); + if (handle == NULL || handle->object == NULL || handleData == NULL) { LOG_FUN_ERR("CaptureSetMuteStu paras is NULL!"); return HDF_FAILURE; } struct HdfIoService *service = NULL; struct HdfSBuf *reply = NULL; - struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); if (sBuf == NULL) { LOG_FUN_ERR("CaptureSetMuteStu Failed to obtain sBuf"); return HDF_FAILURE; @@ -464,151 +384,148 @@ int32_t AudioCtlCaptureSetMuteStu(struct DevHandleCapture *handle, int cmdId, st ret = AudioCtlCaptureSetMuteSBuf(sBuf, handleData); if (ret < 0) { LOG_FUN_ERR("CaptureSetMuteStu Failed to Get Mute sBuf!"); - AudioCaptureBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return ret; } - cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE; - cmdId -= CTRL_NUM; // ADM Ctrl Num Begin zero service = (struct HdfIoService *)handle->object; if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { LOG_FUN_ERR("CaptureSetMuteStu Service is NULL!"); - AudioCaptureBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } + cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE - CTRL_NUM; ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, reply); if (ret != HDF_SUCCESS) { LOG_FUN_ERR("CaptureSetMuteStu Failed to send service call!"); - AudioCaptureBufReplyRecycle(sBuf, NULL); - return HDF_FAILURE; } - AudioCaptureBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return ret; } -int32_t AudioCtlCaptureGetMuteSBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureGetMuteSBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData) { if (handleData == NULL || sBuf == NULL) { LOG_FUN_ERR("The parameter is empty!"); return HDF_FAILURE; } - memset_s(&g_elemCaptureValue, sizeof(struct AudioCtlCaptureElemValue), 0, sizeof(struct AudioCtlCaptureElemValue)); uint32_t card = handleData->captureMode.hwInfo.card; - if (card < 0 || card >= AUDIO_SERVICE_MAX) { + if (card >= AUDIO_SERVICE_MAX) { LOG_FUN_ERR("CaptureGetMuteSBuf card is Error!"); return HDF_FAILURE; } - g_elemCaptureValue.id.cardServiceName = g_audioServiceCapture[card]; - g_elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_ADC; - g_elemCaptureValue.id.itemName = "Capture Mute"; - if (!HdfSbufWriteInt32(sBuf, g_elemCaptureValue.id.iface)) { + struct AudioCtlElemValue elemCaptureValue; + elemCaptureValue.id.cardServiceName = g_audioLibCaptureService[card]; + elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_ADC; + elemCaptureValue.id.itemName = "Capture Mute"; + if (!HdfSbufWriteInt32(sBuf, elemCaptureValue.id.iface)) { LOG_FUN_ERR("CaptureGetMuteSBuf iface Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemCaptureValue.id.cardServiceName)) { + if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.cardServiceName)) { LOG_FUN_ERR("CaptureGetMuteSBuf cardServiceName Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemCaptureValue.id.itemName)) { + if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.itemName)) { LOG_FUN_ERR("CaptureGetMuteSBuf itemName Write Fail!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlCaptureGetMuteStu(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureGetMuteStu(const struct DevHandleCapture *handle, + int cmdId, struct AudioHwCaptureParam *handleData) { int32_t ret; - LOG_FUN_INFO(); + if (handle == NULL || handle->object == NULL || handleData == NULL) { LOG_FUN_ERR("CaptureGetMuteStu paras is NULL!"); return HDF_FAILURE; } struct HdfIoService *service = NULL; struct HdfSBuf *reply = NULL; - struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); if (sBuf == NULL) { LOG_FUN_ERR("CaptureGetMuteStu Failed to obtain sBuf"); return HDF_FAILURE; } - reply = AudioCapturebtainHdfSBuf(); + reply = AudioObtainHdfSBuf(); if (reply == NULL) { LOG_FUN_ERR("Failed to obtain reply"); - AudioCaptureBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } ret = AudioCtlCaptureGetMuteSBuf(sBuf, handleData); if (ret < 0) { LOG_FUN_ERR("Failed to Get Mute sBuf!"); - AudioCaptureBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return ret; } - cmdId = AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE - CTRL_NUM; // ADM Ctrl Num Begin zero service = (struct HdfIoService *)handle->object; - ret = AudioServiceCaptureDispatch(service, cmdId, sBuf, reply); + cmdId = AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE - CTRL_NUM; + ret = AudioServiceDispatch(service, cmdId, sBuf, reply); if (ret != HDF_SUCCESS) { LOG_FUN_ERR("CaptureGetMuteStu Dispatch Fail!"); - AudioCaptureBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } - struct AudioCtlCaptureElemValue muteValueStu; - memset_s(&muteValueStu, sizeof(struct AudioCtlCaptureElemValue), 0, sizeof(struct AudioCtlCaptureElemValue)); - if (!HdfSbufReadInt32(reply, &muteValueStu.value[0])) { + int32_t muteValueStu = 0; + if (!HdfSbufReadInt32(reply, &muteValueStu)) { LOG_FUN_ERR("CaptureGetMuteStu Failed to Get Volume sBuf!"); - AudioCaptureBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } - handleData->captureMode.ctlParam.mute = muteValueStu.value[0]; - AudioCaptureBufReplyRecycle(sBuf, reply); + handleData->captureMode.ctlParam.mute = (bool)muteValueStu; + AudioBufReplyRecycle(sBuf, reply); return ret; } -int32_t AudioCtlCaptureSetGainSBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureSetGainSBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData) { - LOG_FUN_INFO(); if (handleData == NULL || sBuf == NULL) { LOG_FUN_ERR("CaptureSetGainSBuf( handleData or sBuf is NULL!"); return HDF_FAILURE; } - memset_s(&g_elemCaptureValue, sizeof(struct AudioCtlCaptureElemValue), 0, sizeof(struct AudioCtlCaptureElemValue)); uint32_t card = handleData->captureMode.hwInfo.card; - if (card < 0 || card >= AUDIO_SERVICE_MAX) { + if (card >= AUDIO_SERVICE_MAX) { LOG_FUN_ERR("CaptureSetGainSBuf card is Error!"); return HDF_FAILURE; } - g_elemCaptureValue.id.cardServiceName = g_audioServiceCapture[card]; - g_elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_GAIN; - g_elemCaptureValue.id.itemName = "Mic Left Gain"; - g_elemCaptureValue.value[0] = handleData->captureMode.ctlParam.audioGain.gain; - if (!HdfSbufWriteInt32(sBuf, g_elemCaptureValue.value[0])) { + struct AudioCtlElemValue elemCaptureValue; + elemCaptureValue.id.cardServiceName = g_audioLibCaptureService[card]; + elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_GAIN; + elemCaptureValue.id.itemName = "Mic Left Gain"; + elemCaptureValue.value[0] = handleData->captureMode.ctlParam.audioGain.gain; + if (!HdfSbufWriteInt32(sBuf, elemCaptureValue.value[0])) { LOG_FUN_ERR("CaptureSetGainSBuf mute Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteInt32(sBuf, g_elemCaptureValue.id.iface)) { + if (!HdfSbufWriteInt32(sBuf, elemCaptureValue.id.iface)) { LOG_FUN_ERR("CaptureSetGainSBuf iface Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemCaptureValue.id.cardServiceName)) { + if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.cardServiceName)) { LOG_FUN_ERR("CaptureSetGainSBuf cardServiceName Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemCaptureValue.id.itemName)) { + if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.itemName)) { LOG_FUN_ERR("CaptureSetGainSBuf itemName Write Fail!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlCaptureSetGainStu(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureSetGainStu(const struct DevHandleCapture *handle, + int cmdId, const struct AudioHwCaptureParam *handleData) { - LOG_FUN_INFO(); int32_t ret; + if (handle == NULL || handle->object == NULL || handleData == NULL) { LOG_FUN_ERR("CaptureSetGainStu paras is NULL!"); return HDF_FAILURE; } struct HdfIoService *service = NULL; struct HdfSBuf *reply = NULL; - struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); if (sBuf == NULL) { LOG_FUN_ERR("CaptureSetGainStu Failed to obtain sBuf"); return HDF_FAILURE; @@ -616,107 +533,103 @@ int32_t AudioCtlCaptureSetGainStu(struct DevHandleCapture *handle, int cmdId, st ret = AudioCtlCaptureSetGainSBuf(sBuf, handleData); if (ret < 0) { LOG_FUN_ERR("CaptureSetGainStu Failed to Get Gain sBuf!"); - AudioCaptureBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return ret; } - cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE; - cmdId -= CTRL_NUM; // ADM Ctrl Num Begin zero service = (struct HdfIoService *)handle->object; if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { LOG_FUN_ERR("CaptureSetGainStu Service is NULL!"); - AudioCaptureBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } + cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE - CTRL_NUM; ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, reply); if (ret != HDF_SUCCESS) { LOG_FUN_ERR("CaptureSetGainStu Failed to send service call!"); - AudioCaptureBufReplyRecycle(sBuf, NULL); - return HDF_FAILURE; } - AudioCaptureBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return ret; } -int32_t AudioCtlCaptureGetGainSBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureGetGainSBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData) { if (handleData == NULL || sBuf == NULL) { LOG_FUN_ERR("CaptureGetGainSBuf paras is NULL!"); return HDF_FAILURE; } - memset_s(&g_elemCaptureValue, sizeof(struct AudioCtlCaptureElemValue), 0, sizeof(struct AudioCtlCaptureElemValue)); uint32_t card = handleData->captureMode.hwInfo.card; - if (card < 0 || card >= AUDIO_SERVICE_MAX) { + if (card >= AUDIO_SERVICE_MAX) { LOG_FUN_ERR("CaptureGetGainSBuf card is Error!"); return HDF_FAILURE; } - g_elemCaptureValue.id.cardServiceName = g_audioServiceCapture[card]; - g_elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_GAIN; - g_elemCaptureValue.id.itemName = "Mic Left Gain"; - if (!HdfSbufWriteInt32(sBuf, g_elemCaptureValue.id.iface)) { + struct AudioCtlElemValue elemCaptureValue; + elemCaptureValue.id.cardServiceName = g_audioLibCaptureService[card]; + elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_GAIN; + elemCaptureValue.id.itemName = "Mic Left Gain"; + if (!HdfSbufWriteInt32(sBuf, elemCaptureValue.id.iface)) { LOG_FUN_ERR("CaptureGetGainSBuf iface Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemCaptureValue.id.cardServiceName)) { + if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.cardServiceName)) { LOG_FUN_ERR("CaptureGetGainSBuf cardServiceName Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemCaptureValue.id.itemName)) { + if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.itemName)) { LOG_FUN_ERR("CaptureGetGainSBuf itemName Write Fail!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlCaptureGetGainStu(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureGetGainStu(const struct DevHandleCapture *handle, + int cmdId, struct AudioHwCaptureParam *handleData) { - LOG_FUN_INFO(); int32_t ret; + if (handle == NULL || handle->object == NULL || handleData == NULL) { LOG_FUN_ERR("CaptureGetGainStu paras is NULL!"); return HDF_FAILURE; } struct HdfIoService *service = NULL; struct HdfSBuf *reply = NULL; - struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); if (sBuf == NULL) { LOG_FUN_ERR("CaptureGetGainStu Failed to obtain sBuf"); return HDF_FAILURE; } - reply = AudioCapturebtainHdfSBuf(); + reply = AudioObtainHdfSBuf(); if (reply == NULL) { LOG_FUN_ERR("Failed to obtain reply"); - AudioCaptureBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } ret = AudioCtlCaptureGetGainSBuf(sBuf, handleData); if (ret < 0) { LOG_FUN_ERR("Failed to Get Gain sBuf!"); - AudioCaptureBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return ret; } - cmdId = AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE - CTRL_NUM; // ADM Ctrl Num Begin zero service = (struct HdfIoService *)handle->object; - ret = AudioServiceCaptureDispatch(service, cmdId, sBuf, reply); + cmdId = AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE - CTRL_NUM; + ret = AudioServiceDispatch(service, cmdId, sBuf, reply); if (ret != HDF_SUCCESS) { LOG_FUN_ERR("GetGainStu Dispatch Fail!"); - AudioCaptureBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } - struct AudioCtlCaptureElemValue muteValueStu; - memset_s(&muteValueStu, sizeof(struct AudioCtlCaptureElemValue), 0, sizeof(struct AudioCtlCaptureElemValue)); - if (!HdfSbufReadInt32(reply, &muteValueStu.value[0])) { + int32_t muteValueStu = 0; + if (!HdfSbufReadInt32(reply, &muteValueStu)) { LOG_FUN_ERR("Failed to GetGain sBuf!"); - AudioCaptureBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } - handleData->captureMode.ctlParam.audioGain.gain = muteValueStu.value[0]; - AudioCaptureBufReplyRecycle(sBuf, reply); + handleData->captureMode.ctlParam.audioGain.gain = (float)muteValueStu; + AudioBufReplyRecycle(sBuf, reply); return ret; } int32_t AudioCtlCaptureSceneSelectSBuf(struct HdfSBuf *sBuf, - struct AudioHwCaptureParam *handleData, - int32_t deviceIndex) + const struct AudioHwCaptureParam *handleData, int32_t deviceIndex) { if (handleData == NULL || sBuf == NULL) { LOG_FUN_ERR("CaptureSceneSelectSBuf handleData or sBufs is NULL!"); @@ -726,251 +639,241 @@ int32_t AudioCtlCaptureSceneSelectSBuf(struct HdfSBuf *sBuf, LOG_FUN_ERR("deviceIndex is Invalid!"); return HDF_FAILURE; } - memset_s(&g_elemCaptureValue, sizeof(struct AudioCtlCaptureElemValue), 0, sizeof(struct AudioCtlCaptureElemValue)); uint32_t card = handleData->captureMode.hwInfo.card; - if (card < 0 || card >= AUDIO_SERVICE_MAX) { + if (card >= AUDIO_SERVICE_MAX) { LOG_FUN_ERR("CaptureSceneSelectSBuf card is Error!"); return HDF_FAILURE; } - g_elemCaptureValue.id.cardServiceName = g_audioServiceCapture[card]; - g_elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_SELECT; - g_elemCaptureValue.id.itemName = + struct AudioCtlElemValue elemCaptureValue; + elemCaptureValue.id.cardServiceName = g_audioLibCaptureService[card]; + elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_SELECT; + elemCaptureValue.id.itemName = handleData->captureMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[deviceIndex].deviceSwitch; - g_elemCaptureValue.value[0] = handleData->captureMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[deviceIndex].value; - if (!HdfSbufWriteInt32(sBuf, g_elemCaptureValue.value[0])) { + elemCaptureValue.value[0] = handleData->captureMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[deviceIndex].value; + if (!HdfSbufWriteInt32(sBuf, elemCaptureValue.value[0])) { LOG_FUN_ERR("CaptureSceneSelectSBuf Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteInt32(sBuf, g_elemCaptureValue.id.iface)) { + if (!HdfSbufWriteInt32(sBuf, elemCaptureValue.id.iface)) { LOG_FUN_ERR("CaptureSceneSelectSBuf iface Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemCaptureValue.id.cardServiceName)) { + if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.cardServiceName)) { LOG_FUN_ERR("CaptureSceneSelectSBuf cardServiceName Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemCaptureValue.id.itemName)) { + if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.itemName)) { LOG_FUN_ERR("CaptureSceneSelectSBuf itemName Write Fail!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlCaptureSceneSelect(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureSceneSelect(const struct DevHandleCapture *handle, + int cmdId, const struct AudioHwCaptureParam *handleData) { - LOG_FUN_INFO(); int32_t index; + if (handle == NULL || handle->object == NULL || handleData == NULL) { LOG_FUN_ERR("CaptureSceneSelect parameter is empty!"); return HDF_FAILURE; } struct HdfIoService *service = NULL; struct HdfSBuf *reply = NULL; - struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); if (sBuf == NULL) { LOG_FUN_ERR("Failed to obtain sBuf"); return HDF_FAILURE; } - cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE - CTRL_NUM; // ADM Ctrl Num Begin zero; service = (struct HdfIoService *)handle->object; int32_t deviceNum = handleData->captureMode.hwInfo.pathSelect.deviceInfo.deviceNum; if (deviceNum < AUDIO_MIN_DEVICENUM) { LOG_FUN_ERR("AUDIO_MIN_ADAPTERNUM Failed!"); - AudioCaptureBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } + cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE - CTRL_NUM; for (index = 0; index < deviceNum; index++) { HdfSbufFlush(sBuf); if (AudioCtlCaptureSceneSelectSBuf(sBuf, handleData, index) < 0) { LOG_FUN_ERR("AudioCtlRenderSceneSelectSBuf Failed!"); - AudioCaptureBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { LOG_FUN_ERR("CaptureSceneSelect Service is NULL!"); - AudioCaptureBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } if (service->dispatcher->Dispatch(&service->object, cmdId, sBuf, reply) < 0) { LOG_FUN_ERR("CaptureSceneSelect Failed to send service call!"); - AudioCaptureBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } } - AudioCaptureBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_SUCCESS; } -int32_t AudioCtlCaptureGetGainThresholdSBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureGetGainThresholdSBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData) { if (handleData == NULL || sBuf == NULL) { LOG_FUN_ERR("CaptureGetGainThresholdSBuf paras is empty!"); return HDF_FAILURE; } - memset_s(&g_elemCaptureInfo, sizeof(struct AudioCtrlCaptureElemInfo), 0, sizeof(struct AudioCtrlCaptureElemInfo)); uint32_t card = handleData->captureMode.hwInfo.card; - if (card < 0 || card >= AUDIO_SERVICE_MAX) { + if (card >= AUDIO_SERVICE_MAX) { LOG_FUN_ERR("CaptureGetGainThresholdSBuf card is Error!"); return HDF_FAILURE; } - g_elemCaptureInfo.id.cardServiceName = g_audioServiceCapture[card]; - g_elemCaptureInfo.id.iface = AUDIODRV_CTL_CAPTUREELEM_IFACE_MIXER; - g_elemCaptureInfo.id.itemName = "Mic Left Gain"; - if (!HdfSbufWriteInt32(sBuf, g_elemCaptureInfo.id.iface)) { + struct AudioCtrlElemInfo elemCaptureInfo; + elemCaptureInfo.id.cardServiceName = g_audioLibCaptureService[card]; + elemCaptureInfo.id.iface = AUDIODRV_CTL_CAPTUREELEM_IFACE_MIXER; + elemCaptureInfo.id.itemName = "Mic Left Gain"; + if (!HdfSbufWriteInt32(sBuf, elemCaptureInfo.id.iface)) { LOG_FUN_ERR("CaptureGetGainThresholdSBuf iface Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemCaptureInfo.id.cardServiceName)) { + if (!HdfSbufWriteString(sBuf, elemCaptureInfo.id.cardServiceName)) { LOG_FUN_ERR("CaptureGetGainThresholdSBuf cardServiceName Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemCaptureInfo.id.itemName)) { + if (!HdfSbufWriteString(sBuf, elemCaptureInfo.id.itemName)) { LOG_FUN_ERR("CaptureGetGainThresholdSBuf itemName Write Fail!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlCaptureGetGainThreshold(struct DevHandleCapture *handle, - int cmdId, - struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureGetGainThreshold(const struct DevHandleCapture *handle, + int cmdId, struct AudioHwCaptureParam *handleData) { - LOG_FUN_INFO(); int32_t ret; + if (handle == NULL || handle->object == NULL || handleData == NULL) { LOG_FUN_ERR("CaptureGetGainThreshold paras is NULL!"); return HDF_FAILURE; } struct HdfIoService *service = NULL; struct HdfSBuf *reply = NULL; - struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); if (sBuf == NULL) { LOG_FUN_ERR("CaptureGetGainThreshold Failed to obtain sBuf"); return HDF_FAILURE; } - reply = AudioCapturebtainHdfSBuf(); + reply = AudioObtainHdfSBuf(); if (reply == NULL) { LOG_FUN_ERR("CaptureGetGainThreshold Failed to obtain reply"); - AudioCaptureBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } ret = AudioCtlCaptureGetGainThresholdSBuf(sBuf, handleData); - if (ret < 0) { + if (ret != HDF_SUCCESS) { LOG_FUN_ERR("CaptureGetGainThreshold Failed to Get Threshold sBuf!"); - AudioCaptureBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return ret; } - cmdId = AUDIODRV_CTL_IOCTL_ELEM_INFO_CAPTURE - CTRL_NUM; // ADM Ctrl Num Begin zero service = (struct HdfIoService *)handle->object; - ret = AudioServiceCaptureDispatch(service, cmdId, sBuf, reply); + cmdId = AUDIODRV_CTL_IOCTL_ELEM_INFO_CAPTURE - CTRL_NUM; + ret = AudioServiceDispatch(service, cmdId, sBuf, reply); if (ret != HDF_SUCCESS) { - AudioCaptureBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } - struct AudioCtrlCaptureElemInfo gainThreshold; - memset_s(&gainThreshold, sizeof(struct AudioCtrlCaptureElemInfo), 0, sizeof(struct AudioCtrlCaptureElemInfo)); + struct AudioCtrlElemInfo gainThreshold; if (!HdfSbufReadInt32(reply, &gainThreshold.type)) { LOG_FUN_ERR("CaptureGetGainThreshold Failed to HdfSbufReadBuffer!"); - AudioCaptureBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } if (!HdfSbufReadInt32(reply, &gainThreshold.max)) { LOG_FUN_ERR("CaptureGetGainThreshold Failed to HdfSbufReadBuffer!"); - AudioCaptureBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } handleData->captureMode.ctlParam.audioGain.gainMax = gainThreshold.max; handleData->captureMode.ctlParam.audioGain.gainMin = 0; - AudioCaptureBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return ret; } -int32_t AudioCtlCaptureGetVolThresholdSBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureGetVolThresholdSBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData) { if (handleData == NULL || sBuf == NULL) { LOG_FUN_ERR("CaptureGetVolThresholdSBuf paras is empty!"); return HDF_FAILURE; } - memset_s(&g_elemCaptureInfo, sizeof(struct AudioCtrlCaptureElemInfo), 0, sizeof(struct AudioCtrlCaptureElemInfo)); uint32_t card = handleData->captureMode.hwInfo.card; - if (card < 0 || card >= AUDIO_SERVICE_MAX) { + if (card >= AUDIO_SERVICE_MAX) { LOG_FUN_ERR("CaptureGetVolThresholdSBuf card is Error!"); return HDF_FAILURE; } - g_elemCaptureInfo.id.cardServiceName = g_audioServiceCapture[card]; - g_elemCaptureInfo.id.iface = AUDIODRV_CTL_ELEM_IFACE_ADC; - g_elemCaptureInfo.id.itemName = "Master Capture Volume"; - if (!HdfSbufWriteInt32(sBuf, g_elemCaptureInfo.id.iface)) { - LOG_FUN_ERR("CaptureGetVolThresholdSBuf iface Write Fail!"); + struct AudioCtrlElemInfo elemCaptureInfo; + elemCaptureInfo.id.cardServiceName = g_audioLibCaptureService[card]; + elemCaptureInfo.id.iface = AUDIODRV_CTL_ELEM_IFACE_ADC; + elemCaptureInfo.id.itemName = "Master Capture Volume"; + if (!HdfSbufWriteInt32(sBuf, elemCaptureInfo.id.iface)) { + LOG_FUN_ERR("elemCaptureInfo.id.iface iface Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemCaptureInfo.id.cardServiceName)) { + if (!HdfSbufWriteString(sBuf, elemCaptureInfo.id.cardServiceName)) { LOG_FUN_ERR("CaptureGetVolThresholdSBuf cardServiceName Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemCaptureInfo.id.itemName)) { + if (!HdfSbufWriteString(sBuf, elemCaptureInfo.id.itemName)) { LOG_FUN_ERR("CaptureGetVolThresholdSBuf itemName Write Fail!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlCaptureGetVolThreshold(struct DevHandleCapture *handle, +int32_t AudioCtlCaptureGetVolThreshold(const struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData) { - LOG_FUN_INFO(); if (handle == NULL || handle->object == NULL || handleData == NULL) { LOG_FUN_ERR("paras is NULL!"); return HDF_FAILURE; } - struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); if (sBuf == NULL) { - LOG_FUN_ERR("Failed to obtain sBuf"); + LOG_FUN_ERR("Failed to Get sBuf"); return HDF_FAILURE; } - struct HdfSBuf *reply = AudioCapturebtainHdfSBuf(); + struct HdfSBuf *reply = AudioObtainHdfSBuf(); if (reply == NULL) { LOG_FUN_ERR("Failed to obtain reply"); - AudioCaptureBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } int32_t ret = AudioCtlCaptureGetVolThresholdSBuf(sBuf, handleData); if (ret < 0) { LOG_FUN_ERR("Failed to Get Threshold sBuf!"); - AudioCaptureBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return ret; } - cmdId = AUDIODRV_CTL_IOCTL_ELEM_INFO_CAPTURE - CTRL_NUM; // ADM Ctrl Num Begin zero struct HdfIoService *service = (struct HdfIoService *)handle->object; - ret = AudioServiceCaptureDispatch(service, cmdId, sBuf, reply); + cmdId = AUDIODRV_CTL_IOCTL_ELEM_INFO_CAPTURE - CTRL_NUM; + ret = AudioServiceDispatch(service, cmdId, sBuf, reply); if (ret != HDF_SUCCESS) { - AudioCaptureBufReplyRecycle(sBuf, reply); - return HDF_FAILURE; - } - struct AudioCtrlCaptureElemInfo volThreshold; - memset_s(&volThreshold, sizeof(struct AudioCtrlCaptureElemInfo), 0, sizeof(struct AudioCtrlCaptureElemInfo)); - if (!HdfSbufReadInt32(reply, &volThreshold.type)) { - AudioCaptureBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } - if (!HdfSbufReadInt32(reply, &volThreshold.max)) { - AudioCaptureBufReplyRecycle(sBuf, reply); - return HDF_FAILURE; - } - if (!HdfSbufReadInt32(reply, &volThreshold.min)) { - AudioCaptureBufReplyRecycle(sBuf, reply); + struct AudioCtrlElemInfo volThreshold; + ret = AudioCtlGetVolThresholdRead(reply, &volThreshold); + if (ret < 0) { + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } handleData->captureMode.ctlParam.volThreshold.volMax = volThreshold.max; handleData->captureMode.ctlParam.volThreshold.volMin = volThreshold.min; - AudioCaptureBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return ret; } int32_t AudioInterfaceLibCtlCapture(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData) { int32_t ret; - LOG_FUN_INFO(); + if (handle == NULL || handle->object == NULL || handleData == NULL) { LOG_FUN_ERR("paras is NULL!"); return HDF_FAILURE; @@ -1013,53 +916,54 @@ int32_t AudioInterfaceLibCtlCapture(struct DevHandleCapture *handle, int cmdId, return ret; } -int32_t AudioOutputCaptureHwParams(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData) +int32_t AudioOutputCaptureHwParams(const struct DevHandleCapture *handle, + int cmdId, const struct AudioHwCaptureParam *handleData) { - LOG_FUN_INFO(); if (handle == NULL || handle->object == NULL || handleData == NULL) { - LOG_FUN_ERR("paras is NULL!"); + LOG_FUN_ERR("Function parameter is NULL!"); return HDF_FAILURE; } + int32_t ret; struct HdfIoService *service = NULL; - struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); if (sBuf == NULL) { LOG_FUN_ERR("Failed to obtain sBuf"); return HDF_FAILURE; } if (SetHwParamsCapture(handleData) < 0) { - AudioCaptureBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } if (ParamsSbufWriteBuffer(sBuf) < 0) { - AudioCaptureBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } service = (struct HdfIoService *)handle->object; if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { - LOG_FUN_ERR("Service is NULL!"); - AudioCaptureBufReplyRecycle(sBuf, NULL); + LOG_FUN_ERR("Function parameter is empty!"); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } - int32_t ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, NULL); + ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, NULL); if (ret != HDF_SUCCESS) { LOG_FUN_ERR("Failed to send service call!"); - AudioCaptureBufReplyRecycle(sBuf, NULL); - return HDF_FAILURE; } - AudioCaptureBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return ret; } int32_t AudioOutputCaptureReadFrame(struct HdfIoService *service, int cmdId, struct HdfSBuf *reply) { - LOG_FUN_INFO(); int32_t ret; uint32_t buffStatus = 0; - int32_t tryNumReply = 50; // try get reply count + int32_t tryNumReply = 100; // try get reply count if (service == NULL || reply == NULL) { LOG_FUN_ERR("paras is NULL!"); return HDF_FAILURE; } + if (service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { + return HDF_FAILURE; + } do { ret = service->dispatcher->Dispatch(&service->object, cmdId, NULL, reply); if (ret != HDF_SUCCESS) { @@ -1076,7 +980,7 @@ int32_t AudioOutputCaptureReadFrame(struct HdfIoService *service, int cmdId, str LOG_PARA_INFO("Cir buff empty wait 50ms"); tryNumReply--; HdfSbufFlush(reply); - usleep(AUDIO_WAIT_MSEC); // wait 10ms + usleep(AUDIO_CAP_WAIT_DELAY); continue; } break; @@ -1088,9 +992,9 @@ int32_t AudioOutputCaptureReadFrame(struct HdfIoService *service, int cmdId, str return HDF_SUCCESS; } -int32_t AudioOutputCaptureRead(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData) +int32_t AudioOutputCaptureRead(const struct DevHandleCapture *handle, + int cmdId, struct AudioHwCaptureParam *handleData) { - LOG_FUN_INFO(); uint32_t dataSize = 0; uint32_t frameCount = 0; size_t replySize = AUDIO_SIZE_FRAME_16K + AUDIO_REPLY_EXTEND; @@ -1107,12 +1011,12 @@ int32_t AudioOutputCaptureRead(struct DevHandleCapture *handle, int cmdId, struc service = (struct HdfIoService *)handle->object; if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { LOG_FUN_ERR("Service is NULL!"); - AudioCaptureBufReplyRecycle(NULL, reply); + AudioBufReplyRecycle(NULL, reply); return HDF_FAILURE; } int32_t ret = AudioOutputCaptureReadFrame(service, cmdId, reply); if (ret != 0) { - LOG_FUN_ERR("AudioOutputCaptureReadFrame is Fail!"); + LOG_FUN_ERR("AudioOutputCaptureReadFrame is invalid!"); return HDF_FAILURE; } if (!HdfSbufReadBuffer(reply, (const void **)&frame, &dataSize)) { @@ -1129,17 +1033,20 @@ int32_t AudioOutputCaptureRead(struct DevHandleCapture *handle, int cmdId, struc HdfSBufRecycle(reply); return HDF_FAILURE; } - memcpy_s(handleData->frameCaptureMode.buffer, FRAME_DATA, frame, dataSize); + ret = memcpy_s(handleData->frameCaptureMode.buffer, FRAME_DATA, frame, dataSize); + if (ret != 0) { + HdfSBufRecycle(reply); + return HDF_FAILURE; + } handleData->frameCaptureMode.bufferSize = dataSize; handleData->frameCaptureMode.bufferFrameSize = frameCount; HdfSBufRecycle(reply); return HDF_SUCCESS; } -int32_t AudioOutputCaptureStartPrepare(struct DevHandleCapture *handle, - int cmdId, struct AudioHwCaptureParam *handleData) +int32_t AudioOutputCaptureStartPrepare(const struct DevHandleCapture *handle, + int cmdId, const struct AudioHwCaptureParam *handleData) { - LOG_FUN_INFO(); int32_t ret; struct HdfIoService *service = NULL; if (handle == NULL || handle->object == NULL || handleData == NULL) { @@ -1159,9 +1066,9 @@ int32_t AudioOutputCaptureStartPrepare(struct DevHandleCapture *handle, return HDF_SUCCESS; } -int32_t AudioOutputCaptureStop(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData) +int32_t AudioOutputCaptureStop(const struct DevHandleCapture *handle, + int cmdId, const struct AudioHwCaptureParam *handleData) { - LOG_FUN_INFO(); int32_t ret; struct HdfIoService *service = NULL; if (handle == NULL || handle->object == NULL || handleData == NULL) { @@ -1181,10 +1088,104 @@ int32_t AudioOutputCaptureStop(struct DevHandleCapture *handle, int cmdId, struc return HDF_SUCCESS; } +int32_t MmapDescWriteBufferCapture(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData) +{ + if (sBuf == NULL || handleData == NULL) { + return HDF_FAILURE; + } + uint64_t mmapAddr = (uint64_t)(handleData->frameCaptureMode.mmapBufDesc.memoryAddress); + if (!HdfSbufWriteUint64(sBuf, mmapAddr)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(sBuf, handleData->frameCaptureMode.mmapBufDesc.memoryFd)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(sBuf, handleData->frameCaptureMode.mmapBufDesc.totalBufferFrames)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(sBuf, handleData->frameCaptureMode.mmapBufDesc.transferFrameSize)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(sBuf, handleData->frameCaptureMode.mmapBufDesc.isShareable)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, handleData->frameCaptureMode.mmapBufDesc.offset)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioOutputCaptureReqMmapBuffer(struct DevHandleCapture *handle, + int cmdId, struct AudioHwCaptureParam *handleData) +{ + if (handle == NULL || handle->object == NULL || handleData == NULL) { + return HDF_FAILURE; + } + int32_t ret; + struct HdfIoService *service = NULL; + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); + if (sBuf == NULL) { + return HDF_FAILURE; + } + if (MmapDescWriteBufferCapture(sBuf, handleData)) { + AudioBufReplyRecycle(sBuf, NULL); + return HDF_FAILURE; + } + service = (struct HdfIoService *)handle->object; + if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { + AudioBufReplyRecycle(sBuf, NULL); + LOG_FUN_ERR("The pointer is empty!"); + return HDF_FAILURE; + } + ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, NULL); + if (ret != HDF_SUCCESS) { + LOG_FUN_ERR("Failed to send service call!"); + AudioBufReplyRecycle(sBuf, NULL); + return HDF_FAILURE; + } + AudioBufReplyRecycle(sBuf, NULL); + return HDF_SUCCESS; +} + +int32_t AudioOutputCaptureGetMmapPosition(struct DevHandleCapture *handle, + int cmdId, struct AudioHwCaptureParam *handleData) +{ + if (handle == NULL || handle->object == NULL || handleData == NULL) { + return HDF_FAILURE; + } + int32_t ret; + struct HdfIoService *service = NULL; + struct HdfSBuf *reply = NULL; + service = (struct HdfIoService *)handle->object; + if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { + LOG_FUN_ERR("The pointer is empty!"); + return HDF_FAILURE; + } + reply = AudioObtainHdfSBuf(); + if (reply == NULL) { + LOG_FUN_ERR("CaptureGetMmapPosition Failed to obtain reply"); + return HDF_FAILURE; + } + ret = service->dispatcher->Dispatch(&service->object, cmdId, NULL, reply); + if (ret != HDF_SUCCESS) { + LOG_FUN_ERR("Failed to send service call!"); + AudioBufReplyRecycle(NULL, reply); + return HDF_FAILURE; + } + uint64_t frames = 0; + if (!HdfSbufReadUint64(reply, &frames)) { + LOG_FUN_ERR("Failed to Get frames sBuf!"); + AudioBufReplyRecycle(NULL, reply); + return HDF_FAILURE; + } + handleData->frameCaptureMode.frames = frames; + AudioBufReplyRecycle(NULL, reply); + return HDF_SUCCESS; +} + int32_t AudioInterfaceLibOutputCapture(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData) { - LOG_FUN_INFO(); if (handle == NULL) { LOG_FUN_ERR("Input Capture handle is NULL!"); return HDF_FAILURE; @@ -1210,6 +1211,12 @@ int32_t AudioInterfaceLibOutputCapture(struct DevHandleCapture *handle, int cmdI case AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE: ret = AudioCtlCaptureSetPauseStu(handle, cmdId, handleData); break; + case AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER_CAPTURE: + ret = AudioOutputCaptureReqMmapBuffer(handle, cmdId, handleData); + break; + case AUDIO_DRV_PCM_IOCTL_MMAP_POSITION_CAPTURE: + ret = AudioOutputCaptureGetMmapPosition(handle, cmdId, handleData); + break; default: LOG_FUN_ERR("Output Mode not support!"); ret = HDF_FAILURE; @@ -1221,7 +1228,6 @@ int32_t AudioInterfaceLibOutputCapture(struct DevHandleCapture *handle, int cmdI struct DevHandleCapture *AudioBindServiceCaptureObject(struct DevHandleCapture * const handle, const char *name) { - LOG_FUN_INFO(); if (handle == NULL || name == NULL) { LOG_FUN_ERR("service name or handle is NULL!"); return NULL; @@ -1246,7 +1252,6 @@ struct DevHandleCapture *AudioBindServiceCaptureObject(struct DevHandleCapture * AudioMemFree((void **)&handle); return NULL; } - LOG_PARA_INFO("serviceName = %s", serviceName); AudioMemFree((void **)&serviceName); handle->object = service; return handle->object; @@ -1255,8 +1260,8 @@ struct DevHandleCapture *AudioBindServiceCaptureObject(struct DevHandleCapture * /* CreatCapture for Bind handle */ struct DevHandleCapture *AudioBindServiceCapture(const char *name) { - LOG_FUN_INFO(); struct DevHandleCapture *handle = NULL; + struct DevHandleCapture *object = NULL; if (name == NULL) { LOG_FUN_ERR("service name NULL!"); return NULL; @@ -1266,8 +1271,10 @@ struct DevHandleCapture *AudioBindServiceCapture(const char *name) LOG_FUN_ERR("Failed to OsalMemCalloc handle"); return NULL; } - handle->object = AudioBindServiceCaptureObject(handle, name); - if (handle->object == NULL) { + object = AudioBindServiceCaptureObject(handle, name); + if (object != NULL) { + handle->object = object; + } else { LOG_FUN_ERR("handle->object is NULL!"); return NULL; } @@ -1275,7 +1282,7 @@ struct DevHandleCapture *AudioBindServiceCapture(const char *name) return handle; } -void AudioCloseServiceCapture(struct DevHandleCapture *handle) +void AudioCloseServiceCapture(const struct DevHandleCapture *handle) { LOG_FUN_INFO(); if (handle == NULL || handle->object == NULL) { @@ -1303,6 +1310,8 @@ int32_t AudioInterfaceLibModeCapture(struct DevHandleCapture * const handle, case AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE: case AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE: case AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE: + case AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER_CAPTURE: + case AUDIO_DRV_PCM_IOCTL_MMAP_POSITION_CAPTURE: return (AudioInterfaceLibOutputCapture(handle, cmdId, handleData)); case AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE: case AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE: diff --git a/audio/supportlibs/adm_adapter/src/audio_interface_lib_common.c b/audio/supportlibs/adm_adapter/src/audio_interface_lib_common.c old mode 100644 new mode 100755 index b63cee80f2..c9d28f9b50 --- a/audio/supportlibs/adm_adapter/src/audio_interface_lib_common.c +++ b/audio/supportlibs/adm_adapter/src/audio_interface_lib_common.c @@ -32,4 +32,52 @@ struct HdfIoService *HdfIoServiceBindName(const char *serviceName) } LOG_FUN_ERR("service name not support!"); return NULL; -} \ No newline at end of file +} + +void AudioBufReplyRecycle(struct HdfSBuf *sBuf, struct HdfSBuf *reply) +{ + if (sBuf != NULL) { + HdfSBufRecycle(sBuf); + } + if (reply != NULL) { + HdfSBufRecycle(reply); + } +} + +int32_t AudioServiceDispatch(struct HdfIoService *service, + int cmdId, struct HdfSBuf *sBuf, struct HdfSBuf *reply) +{ + if (service == NULL || service->dispatcher == NULL || + service->dispatcher->Dispatch == NULL || sBuf == NULL) { + return HDF_FAILURE; + } + + return service->dispatcher->Dispatch(&(service->object), cmdId, sBuf, reply); +} + +struct HdfSBuf *AudioObtainHdfSBuf(void) +{ +#ifdef AUDIO_HDF_SBUF_IPC + return HdfSBufTypedObtain(SBUF_IPC); +#else + return HdfSBufTypedObtain(SBUF_RAW); +#endif +} + +int32_t AudioCtlGetVolThresholdRead(struct HdfSBuf *reply, struct AudioCtrlElemInfo *volThreshold) +{ + if (reply == NULL || volThreshold == NULL) { + return HDF_FAILURE; + } + if (!HdfSbufReadInt32(reply, &volThreshold->type)) { + LOG_FUN_ERR("Failed to Get Volume sBuf!"); + return HDF_FAILURE; + } + if (!HdfSbufReadInt32(reply, &volThreshold->max)) { + return HDF_FAILURE; + } + if (!HdfSbufReadInt32(reply, &volThreshold->min)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} diff --git a/audio/supportlibs/adm_adapter/src/audio_interface_lib_render.c b/audio/supportlibs/adm_adapter/src/audio_interface_lib_render.c index 889d31d815..35313bdcd3 100755 --- a/audio/supportlibs/adm_adapter/src/audio_interface_lib_render.c +++ b/audio/supportlibs/adm_adapter/src/audio_interface_lib_render.c @@ -13,7 +13,7 @@ * limitations under the License. */ -#include "audio_interface_lib_common.h" +#include "audio_interface_lib_render.h" #define AUDIODRV_CTL_ELEM_IFACE_DAC 0 #define AUDIODRV_CTL_ELEM_IFACE_MIX 3 @@ -28,106 +28,31 @@ #define AUDIODRV_CTL_EXTERN_CODEC_STR "External Codec Enable" #define AUDIODRV_CTL_INTERNAL_CODEC_STR "Internally Codec Enable" -/* Out Put Render/Capture */ -static struct AudioPcmHwParams { - enum AudioStreamType streamType; - uint32_t channels; - uint32_t rate; - uint32_t periodSize; - uint32_t periodCount; - enum AudioFormat format; - char *cardServiceName; - uint32_t period; - uint32_t frameSize; - bool isBigEndian; - bool isSignedData; - uint32_t startThreshold; - uint32_t stopThreshold; - uint32_t silenceThreshold; -} g_hwParams; - -struct AudioCtlElemId { - const char *cardServiceName; - int32_t iface; - const char *itemName; /* ASCII name of item */ -}; - -static struct AudioCtlElemValue { - struct AudioCtlElemId id; - int32_t value[2]; -} g_elemValue; - -static struct AudioCtrlElemInfo { - struct AudioCtlElemId id; - uint32_t count; /* count of values */ - int32_t type; /* R: value type - AUDIODRV_CTL_ELEM_IFACE_MIXER_* */ - int32_t min; /* R: minimum value */ - int32_t max; /* R: maximum value */ -} g_elemInfo; - -char *g_audioService[AUDIO_SERVICE_MAX] = { +/* Out Put Render */ +static struct AudioPcmHwParams g_hwParams; +char *g_audioLibRenderService[AUDIO_SERVICE_MAX] = { [AUDIO_SERVICE_IN] = "hdf_audio_codec_dev0", [AUDIO_SERVICE_OUT] = "hdf_audio_smartpa_dev0", }; -struct HdfSBuf *AudioRenderObtainHdfSBuf() -{ - enum HdfSbufType bufType; -#ifdef AUDIO_HDF_SBUF_IPC - bufType = SBUF_IPC; -#else - bufType = SBUF_RAW; -#endif - return HdfSBufTypedObtain(bufType); -} - -void AudioRenderBufReplyRecycle(struct HdfSBuf *sBuf, struct HdfSBuf *reply) -{ - if (sBuf != NULL) { - HdfSBufRecycle(sBuf); - } - if (reply != NULL) { - HdfSBufRecycle(reply); - } - return; -} - -int32_t AudioServiceRenderDispatch(struct HdfIoService *service, - int cmdId, - struct HdfSBuf *sBuf, - struct HdfSBuf *reply) -{ - if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL || - sBuf == NULL) { - LOG_FUN_ERR("Service is NULL!"); - return HDF_FAILURE; - } - int32_t ret = service->dispatcher->Dispatch(&(service->object), cmdId, sBuf, reply); - if (ret != HDF_SUCCESS) { - LOG_FUN_ERR("Failed to send service call!"); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - int32_t SetHwParams(const struct AudioHwRenderParam *handleData) { if (handleData == NULL) { LOG_FUN_ERR("handleData is NULL!"); return HDF_FAILURE; } - memset_s(&g_hwParams, sizeof(struct AudioPcmHwParams), 0, sizeof(struct AudioPcmHwParams)); uint32_t card = handleData->renderMode.hwInfo.card; - if (card < 0 || card >= AUDIO_SERVICE_MAX) { + if (card >= AUDIO_SERVICE_MAX) { LOG_FUN_ERR("card is Error!"); return HDF_FAILURE; } + memset_s(&g_hwParams, sizeof(struct AudioPcmHwParams), 0, sizeof(struct AudioPcmHwParams)); g_hwParams.streamType = AUDIO_RENDER_STREAM; g_hwParams.channels = handleData->frameRenderMode.attrs.channelCount; g_hwParams.rate = handleData->frameRenderMode.attrs.sampleRate; g_hwParams.periodSize = handleData->frameRenderMode.periodSize; g_hwParams.periodCount = handleData->frameRenderMode.periodCount; - g_hwParams.cardServiceName = g_audioService[card]; + g_hwParams.cardServiceName = g_audioLibRenderService[card]; g_hwParams.format = handleData->frameRenderMode.attrs.format; g_hwParams.period = handleData->frameRenderMode.attrs.period; g_hwParams.frameSize = handleData->frameRenderMode.attrs.frameSize; @@ -139,82 +64,82 @@ int32_t SetHwParams(const struct AudioHwRenderParam *handleData) return HDF_SUCCESS; } -int32_t AudioCtlRenderSetVolumeSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderSetVolumeSBuf(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData) { if (handleData == NULL || sBuf == NULL) { LOG_FUN_ERR("RenderSetVolumeSBuf handleData or sBuf is NULL!"); return HDF_FAILURE; } - memset_s(&g_elemValue, sizeof(struct AudioCtlElemValue), 0, sizeof(struct AudioCtlElemValue)); uint32_t card = handleData->renderMode.hwInfo.card; - if (card < 0 || card >= AUDIO_SERVICE_MAX) { + if (card >= AUDIO_SERVICE_MAX) { LOG_FUN_ERR("RenderSetVolumeSBuf card is Error!"); return HDF_FAILURE; } - g_elemValue.id.cardServiceName = g_audioService[card]; - g_elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC; - g_elemValue.id.itemName = "Master Playback Volume"; - g_elemValue.value[0] = (int32_t)handleData->renderMode.ctlParam.volume; - if (!HdfSbufWriteInt32(sBuf, g_elemValue.value[0])) { + struct AudioCtlElemValue elemValue; + elemValue.id.cardServiceName = g_audioLibRenderService[card]; + elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC; + elemValue.id.itemName = "Master Playback Volume"; + elemValue.value[0] = (int32_t)handleData->renderMode.ctlParam.volume; + if (!HdfSbufWriteInt32(sBuf, elemValue.value[0])) { LOG_FUN_ERR("RenderSetVolumeSBuf Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteInt32(sBuf, g_elemValue.id.iface)) { + if (!HdfSbufWriteInt32(sBuf, elemValue.id.iface)) { LOG_FUN_ERR("RenderSetVolumeSBuf iface Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemValue.id.cardServiceName)) { + if (!HdfSbufWriteString(sBuf, elemValue.id.cardServiceName)) { LOG_FUN_ERR("RenderSetVolumeSBuf cardServiceName Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemValue.id.itemName)) { + if (!HdfSbufWriteString(sBuf, elemValue.id.itemName)) { LOG_FUN_ERR("RenderSetVolumeSBuf itemName Write Fail!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlRenderGetVolumeSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderGetVolumeSBuf(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData) { if (handleData == NULL || sBuf == NULL) { LOG_FUN_ERR("RenderGetVolumeSBuf handleData or sBuf is NULL!"); return HDF_FAILURE; } - memset_s(&g_elemValue, sizeof(struct AudioCtlElemValue), 0, sizeof(struct AudioCtlElemValue)); uint32_t card = handleData->renderMode.hwInfo.card; - if (card < 0 || card >= AUDIO_SERVICE_MAX) { + if (card >= AUDIO_SERVICE_MAX) { LOG_FUN_ERR("RenderGetVolumeSBuf card is Error!"); return HDF_FAILURE; } - g_elemValue.id.cardServiceName = g_audioService[card]; - g_elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC; - g_elemValue.id.itemName = "Master Playback Volume"; - if (!HdfSbufWriteInt32(sBuf, g_elemValue.id.iface)) { + struct AudioCtlElemValue elemValue; + elemValue.id.cardServiceName = g_audioLibRenderService[card]; + elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC; + elemValue.id.itemName = "Master Playback Volume"; + if (!HdfSbufWriteInt32(sBuf, elemValue.id.iface)) { LOG_FUN_ERR("RenderGetVolumeSBuf iface Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemValue.id.cardServiceName)) { + if (!HdfSbufWriteString(sBuf, elemValue.id.cardServiceName)) { LOG_FUN_ERR("RenderGetVolumeSBuf cardServiceName Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemValue.id.itemName)) { + if (!HdfSbufWriteString(sBuf, elemValue.id.itemName)) { LOG_FUN_ERR("RenderGetVolumeSBuf itemName Write Fail!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlRenderSetVolume(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderSetVolume(const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { int32_t ret; - LOG_FUN_INFO(); + if (handle == NULL || handle->object == NULL || handleData == NULL) { LOG_FUN_ERR("RenderSetVolume parameter is empty!"); return HDF_FAILURE; } struct HdfIoService *service = NULL; struct HdfSBuf *reply = NULL; - struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); if (sBuf == NULL) { LOG_FUN_ERR("Failed to obtain sBuf"); return HDF_FAILURE; @@ -222,113 +147,112 @@ int32_t AudioCtlRenderSetVolume(struct DevHandle *handle, int cmdId, struct Audi ret = AudioCtlRenderSetVolumeSBuf(sBuf, handleData); if (ret < 0) { LOG_FUN_ERR("Failed to Set Volume sBuf!"); - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return ret; } - cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE - CTRL_NUM; // ADM Ctrl Num Begin zero; service = (struct HdfIoService *)handle->object; - ret = AudioServiceRenderDispatch(service, cmdId, sBuf, reply); + cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE - CTRL_NUM; + ret = AudioServiceDispatch(service, cmdId, sBuf, reply); if (ret != HDF_SUCCESS) { - AudioRenderBufReplyRecycle(sBuf, NULL); - return HDF_FAILURE; + LOG_FUN_ERR("Failed to AudioServiceDispatch!"); } - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return ret; } -int32_t AudioCtlRenderGetVolume(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderGetVolume(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) { int32_t ret; - LOG_FUN_INFO(); + if (handle == NULL || handle->object == NULL || handleData == NULL) { LOG_FUN_ERR("RenderGetVolume parameter is empty!"); return HDF_FAILURE; } struct HdfIoService *service = NULL; struct HdfSBuf *reply = NULL; - struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); if (sBuf == NULL) { LOG_FUN_ERR("RenderGetVolume Failed to obtain sBuf"); return HDF_FAILURE; } - reply = AudioRenderObtainHdfSBuf(); + reply = AudioObtainHdfSBuf(); if (reply == NULL) { LOG_FUN_ERR("RenderGetVolume Failed to obtain reply"); - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } ret = AudioCtlRenderGetVolumeSBuf(sBuf, handleData); if (ret < 0) { LOG_FUN_ERR("RenderGetVolume Failed to Get Volume sBuf!"); - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return ret; } - cmdId = AUDIODRV_CTL_IOCTL_ELEM_READ - CTRL_NUM; // ADM Ctrl Num Begin zero service = (struct HdfIoService *)handle->object; - ret = AudioServiceRenderDispatch(service, cmdId, sBuf, reply); + cmdId = AUDIODRV_CTL_IOCTL_ELEM_READ - CTRL_NUM; + ret = AudioServiceDispatch(service, cmdId, sBuf, reply); if (ret != HDF_SUCCESS) { LOG_FUN_ERR("RenderGetVolume RenderDispatch Failed!"); - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } struct AudioCtlElemValue elemValue; - memset_s(&elemValue, sizeof(struct AudioCtlElemValue), 0, sizeof(struct AudioCtlElemValue)); if (!HdfSbufReadInt32(reply, &elemValue.value[0])) { LOG_FUN_ERR("RenderGetVolume Failed to Get Volume sBuf!"); - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } handleData->renderMode.ctlParam.volume = elemValue.value[0]; - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return ret; } -int32_t AudioCtlRenderSetPauseBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderSetPauseBuf(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData) { if (handleData == NULL || sBuf == NULL) { LOG_FUN_ERR("RenderSetPauseBuf handleData or sBuf is NULL!"); return HDF_FAILURE; } - memset_s(&g_elemValue, sizeof(struct AudioCtlElemValue), 0, sizeof(struct AudioCtlElemValue)); uint32_t card = handleData->renderMode.hwInfo.card; - if (card < 0 || card >= AUDIO_SERVICE_MAX) { + if (card >= AUDIO_SERVICE_MAX) { LOG_FUN_ERR("RenderSetPauseBuf card is Error!"); return HDF_FAILURE; } - g_elemValue.id.cardServiceName = g_audioService[card]; - g_elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER; - g_elemValue.id.itemName = "Master Playback Pause"; - g_elemValue.value[0] = (int32_t)handleData->renderMode.ctlParam.pause; - if (!HdfSbufWriteInt32(sBuf, g_elemValue.value[0])) { + struct AudioCtlElemValue elemValue; + elemValue.id.cardServiceName = g_audioLibRenderService[card]; + elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER; + elemValue.id.itemName = "Master Playback Pause"; + elemValue.value[0] = (int32_t)handleData->renderMode.ctlParam.pause; + if (!HdfSbufWriteInt32(sBuf, elemValue.value[0])) { LOG_FUN_ERR("RenderSetPauseBuf pause Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteInt32(sBuf, g_elemValue.id.iface)) { + if (!HdfSbufWriteInt32(sBuf, elemValue.id.iface)) { LOG_FUN_ERR("RenderSetPauseBuf iface Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemValue.id.cardServiceName)) { + if (!HdfSbufWriteString(sBuf, elemValue.id.cardServiceName)) { LOG_FUN_ERR("RenderSetPauseBuf cardServiceName Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemValue.id.itemName)) { + if (!HdfSbufWriteString(sBuf, elemValue.id.itemName)) { LOG_FUN_ERR("RenderSetPauseBuf itemName Write Fail!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlRenderSetPauseStu(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderSetPauseStu(const struct DevHandle *handle, + int cmdId, const struct AudioHwRenderParam *handleData) { int32_t ret; - LOG_FUN_INFO(); + if (handle == NULL || handle->object == NULL || handleData == NULL) { LOG_FUN_ERR("RenderSetPauseStu parameter is empty!"); return HDF_FAILURE; } struct HdfIoService *service = NULL; struct HdfSBuf *reply = NULL; - struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); if (sBuf == NULL) { LOG_FUN_ERR("RenderSetPauseStu Failed to obtain sBuf"); return HDF_FAILURE; @@ -336,76 +260,71 @@ int32_t AudioCtlRenderSetPauseStu(struct DevHandle *handle, int cmdId, struct Au ret = AudioCtlRenderSetPauseBuf(sBuf, handleData); if (ret < 0) { LOG_FUN_ERR("RenderSetPauseStu Failed to Set Pause sBuf!"); - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return ret; } - if (handleData->renderMode.ctlParam.pause) { - cmdId = AUDIO_DRV_PCM_IOCTRL_PAUSE; - } else { - cmdId = AUDIO_DRV_PCM_IOCTRL_RESUME; - } service = (struct HdfIoService *)handle->object; if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { LOG_FUN_ERR("RenderSetPauseStu Service is NULL!"); - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } + cmdId = handleData->renderMode.ctlParam.pause ? + AUDIO_DRV_PCM_IOCTRL_PAUSE : AUDIO_DRV_PCM_IOCTRL_RESUME; ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, reply); if (ret != HDF_SUCCESS) { LOG_FUN_ERR("RenderSetPauseStu Failed to send service call!"); - AudioRenderBufReplyRecycle(sBuf, NULL); - return ret; } - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return ret; } -int32_t AudioCtlRenderSetMuteBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderSetMuteBuf(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData) { if (handleData == NULL || sBuf == NULL) { LOG_FUN_ERR("RenderSetMuteBuf handleData or sBuf is NULL!"); return HDF_FAILURE; } - memset_s(&g_elemValue, sizeof(struct AudioCtlElemValue), 0, sizeof(struct AudioCtlElemValue)); uint32_t card = handleData->renderMode.hwInfo.card; if (card < 0 || card >= AUDIO_SERVICE_MAX) { LOG_FUN_ERR("RenderSetMuteBuf card is Error!"); return HDF_FAILURE; } - g_elemValue.id.cardServiceName = g_audioService[card]; - g_elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC; - g_elemValue.id.itemName = "Playback Mute"; - g_elemValue.value[0] = (int32_t)handleData->renderMode.ctlParam.mute; - if (!HdfSbufWriteInt32(sBuf, g_elemValue.value[0])) { + struct AudioCtlElemValue elemValue; + elemValue.id.cardServiceName = g_audioLibRenderService[card]; + elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC; + elemValue.id.itemName = "Playback Mute"; + elemValue.value[0] = (int32_t)handleData->renderMode.ctlParam.mute; + if (!HdfSbufWriteInt32(sBuf, elemValue.value[0])) { LOG_FUN_ERR("RenderSetMuteBuf value[0] Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteInt32(sBuf, g_elemValue.id.iface)) { + if (!HdfSbufWriteInt32(sBuf, elemValue.id.iface)) { LOG_FUN_ERR("RenderSetMuteBuf iface Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemValue.id.cardServiceName)) { + if (!HdfSbufWriteString(sBuf, elemValue.id.cardServiceName)) { LOG_FUN_ERR("RenderSetMuteBuf cardServiceName Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemValue.id.itemName)) { + if (!HdfSbufWriteString(sBuf, elemValue.id.itemName)) { LOG_FUN_ERR("RenderSetMuteBuf itemName Write Fail!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlRenderSetMuteStu(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderSetMuteStu(const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { int32_t ret; - LOG_FUN_INFO(); + if (handle == NULL || handle->object == NULL || handleData == NULL) { LOG_FUN_ERR("RenderSetMuteStu paras is NULL!"); return HDF_FAILURE; } struct HdfIoService *service = NULL; struct HdfSBuf *reply = NULL; - struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); if (sBuf == NULL) { LOG_FUN_ERR("RenderSetMuteStu Failed to obtain sBuf"); return HDF_FAILURE; @@ -413,150 +332,147 @@ int32_t AudioCtlRenderSetMuteStu(struct DevHandle *handle, int cmdId, struct Aud ret = AudioCtlRenderSetMuteBuf(sBuf, handleData); if (ret < 0) { LOG_FUN_ERR("RenderSetMuteStu Failed to Set Mute sBuf!"); - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return ret; } - cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE; - cmdId -= CTRL_NUM; // ADM Ctrl Num Begin zero service = (struct HdfIoService *)handle->object; if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { LOG_FUN_ERR("RenderSetMuteStu Service is NULL!"); - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } + cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE - CTRL_NUM; ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, reply); if (ret != HDF_SUCCESS) { LOG_FUN_ERR("RenderSetMuteStu Failed to send service call!"); - AudioRenderBufReplyRecycle(sBuf, NULL); - return ret; } - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return ret; } -int32_t AudioCtlRenderGetMuteSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderGetMuteSBuf(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData) { if (handleData == NULL || sBuf == NULL) { LOG_FUN_ERR("RenderGetMuteSBuf handleData or sBuf is NULL!"); return HDF_FAILURE; } - memset_s(&g_elemValue, sizeof(struct AudioCtlElemValue), 0, sizeof(struct AudioCtlElemValue)); uint32_t card = handleData->renderMode.hwInfo.card; - if (card < 0 || card >= AUDIO_SERVICE_MAX) { + if (card >= AUDIO_SERVICE_MAX) { LOG_FUN_ERR("RenderGetMuteSBuf card is Error!"); return HDF_FAILURE; } - g_elemValue.id.cardServiceName = g_audioService[card]; - g_elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC; - g_elemValue.id.itemName = "Playback Mute"; - if (!HdfSbufWriteInt32(sBuf, g_elemValue.id.iface)) { + struct AudioCtlElemValue elemValue; + elemValue.id.cardServiceName = g_audioLibRenderService[card]; + elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC; + elemValue.id.itemName = "Playback Mute"; + if (!HdfSbufWriteInt32(sBuf, elemValue.id.iface)) { LOG_FUN_ERR("RenderGetMuteSBuf iface Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemValue.id.cardServiceName)) { + if (!HdfSbufWriteString(sBuf, elemValue.id.cardServiceName)) { LOG_FUN_ERR("RenderGetMuteSBuf cardServiceName Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemValue.id.itemName)) { + if (!HdfSbufWriteString(sBuf, elemValue.id.itemName)) { LOG_FUN_ERR("RenderGetMuteSBuf itemName Write Fail!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlRenderGetMuteStu(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderGetMuteStu(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) { int32_t ret; - LOG_FUN_INFO(); + if (handle == NULL || handle->object == NULL || handleData == NULL) { LOG_FUN_ERR("RenderGetMuteStu paras is NULL!"); return HDF_FAILURE; } struct HdfIoService *service = NULL; struct HdfSBuf *reply = NULL; - struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); if (sBuf == NULL) { LOG_FUN_ERR("RenderGetMuteStu Failed to obtain sBuf"); return HDF_FAILURE; } - reply = AudioRenderObtainHdfSBuf(); + reply = AudioObtainHdfSBuf(); if (reply == NULL) { LOG_FUN_ERR("RenderGetMuteStu Failed to obtain reply"); - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } ret = AudioCtlRenderGetMuteSBuf(sBuf, handleData); if (ret < 0) { LOG_FUN_ERR("RenderGetMuteStu Failed to Get Mute sBuf!"); - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return ret; } - cmdId = AUDIODRV_CTL_IOCTL_ELEM_READ - CTRL_NUM; // ADM Ctrl Num Begin zero service = (struct HdfIoService *)handle->object; - ret = AudioServiceRenderDispatch(service, cmdId, sBuf, reply); + cmdId = AUDIODRV_CTL_IOCTL_ELEM_READ - CTRL_NUM; + ret = AudioServiceDispatch(service, cmdId, sBuf, reply); if (ret != HDF_SUCCESS) { LOG_FUN_ERR("RenderGetMuteStu RenderDispatch Failed!"); - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } struct AudioCtlElemValue muteValueStu; - memset_s(&muteValueStu, sizeof(struct AudioCtlElemValue), 0, sizeof(struct AudioCtlElemValue)); if (!HdfSbufReadInt32(reply, &muteValueStu.value[0])) { LOG_FUN_ERR("RenderGetMuteStu Failed to Get Volume sBuf!"); - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } handleData->renderMode.ctlParam.mute = muteValueStu.value[0]; - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return ret; } -int32_t AudioCtlRenderSetGainBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderSetGainBuf(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData) { if (handleData == NULL || sBuf == NULL) { LOG_FUN_ERR("RenderSetGainBuf handleData or sBuf is NULL!"); return HDF_FAILURE; } - memset_s(&g_elemValue, sizeof(struct AudioCtlElemValue), 0, sizeof(struct AudioCtlElemValue)); uint32_t card = handleData->renderMode.hwInfo.card; - if (card < 0 || card >= AUDIO_SERVICE_MAX) { + if (card >= AUDIO_SERVICE_MAX) { LOG_FUN_ERR("RenderSetGainBuf card is Error!"); return HDF_FAILURE; } - g_elemValue.id.cardServiceName = g_audioService[card]; - g_elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_GAIN; - g_elemValue.id.itemName = "Mic Left Gain"; - g_elemValue.value[0] = (int32_t)handleData->renderMode.ctlParam.audioGain.gain; - if (!HdfSbufWriteInt32(sBuf, g_elemValue.value[0])) { + struct AudioCtlElemValue elemValue; + elemValue.id.cardServiceName = g_audioLibRenderService[card]; + elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_GAIN; + elemValue.id.itemName = "Mic Left Gain"; + elemValue.value[0] = (int32_t)handleData->renderMode.ctlParam.audioGain.gain; + if (!HdfSbufWriteInt32(sBuf, elemValue.value[0])) { LOG_FUN_ERR("RenderSetGainBuf value[0] Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteInt32(sBuf, g_elemValue.id.iface)) { + if (!HdfSbufWriteInt32(sBuf, elemValue.id.iface)) { LOG_FUN_ERR("RenderSetGainBuf iface Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemValue.id.cardServiceName)) { + if (!HdfSbufWriteString(sBuf, elemValue.id.cardServiceName)) { LOG_FUN_ERR("RenderSetGainBuf cardServiceName Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemValue.id.itemName)) { + if (!HdfSbufWriteString(sBuf, elemValue.id.itemName)) { LOG_FUN_ERR("RenderSetGainBuf itemName Write Fail!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlRenderSetGainStu(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderSetGainStu(const struct DevHandle *handle, + int cmdId, const struct AudioHwRenderParam *handleData) { int32_t ret; - LOG_FUN_INFO(); + if (handle == NULL || handle->object == NULL || handleData == NULL) { LOG_FUN_ERR("RenderSetGainStu paras is NULL!"); return HDF_FAILURE; } struct HdfIoService *service = NULL; struct HdfSBuf *reply = NULL; - struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); if (sBuf == NULL) { LOG_FUN_ERR("RenderSetGainStu Failed to obtain sBuf"); return HDF_FAILURE; @@ -564,107 +480,104 @@ int32_t AudioCtlRenderSetGainStu(struct DevHandle *handle, int cmdId, struct Aud ret = AudioCtlRenderSetGainBuf(sBuf, handleData); if (ret < 0) { LOG_FUN_ERR("RenderSetGainStu Failed to Set Gain sBuf!"); - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return ret; } - cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE; - cmdId -= CTRL_NUM; // ADM Ctrl Num Begin zero service = (struct HdfIoService *)handle->object; if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { LOG_FUN_ERR("RenderSetGainStu Service is NULL!"); - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } + cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE - CTRL_NUM; ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, reply); if (ret != HDF_SUCCESS) { LOG_FUN_ERR("RenderSetGainStu Failed to send service call!"); - AudioRenderBufReplyRecycle(sBuf, NULL); - return HDF_FAILURE; } - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return ret; } -int32_t AudioCtlRenderGetGainSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderGetGainSBuf(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData) { if (handleData == NULL || sBuf == NULL) { LOG_FUN_ERR("RenderGetGainSBuf handleData or sBuf is NULL!"); return HDF_FAILURE; } - memset_s(&g_elemValue, sizeof(struct AudioCtlElemValue), 0, sizeof(struct AudioCtlElemValue)); uint32_t card = handleData->renderMode.hwInfo.card; - if (card < 0 || card >= AUDIO_SERVICE_MAX) { + if (card >= AUDIO_SERVICE_MAX) { LOG_FUN_ERR("RenderGetGainSBuf card is invalid!"); return HDF_FAILURE; } - g_elemValue.id.cardServiceName = g_audioService[card]; - g_elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_GAIN; - g_elemValue.id.itemName = "Mic Left Gain"; - if (!HdfSbufWriteInt32(sBuf, g_elemValue.id.iface)) { + struct AudioCtlElemValue elemValue; + elemValue.id.cardServiceName = g_audioLibRenderService[card]; + elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_GAIN; + elemValue.id.itemName = "Mic Left Gain"; + if (!HdfSbufWriteInt32(sBuf, elemValue.id.iface)) { LOG_FUN_ERR("RenderGetGainSBuf iface Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemValue.id.cardServiceName)) { + if (!HdfSbufWriteString(sBuf, elemValue.id.cardServiceName)) { LOG_FUN_ERR("RenderGetGainSBuf cardServiceName Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemValue.id.itemName)) { + if (!HdfSbufWriteString(sBuf, elemValue.id.itemName)) { LOG_FUN_ERR("RenderGetGainSBuf itemName Write Fail!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlRenderGetGainStu(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderGetGainStu(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) { int32_t ret; - LOG_FUN_INFO(); + if (handle == NULL || handle->object == NULL || handleData == NULL) { LOG_FUN_ERR("RenderGetGainStu paras is NULL!"); return HDF_FAILURE; } struct HdfIoService *service = NULL; struct HdfSBuf *reply = NULL; - struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); if (sBuf == NULL) { LOG_FUN_ERR("RenderGetGainStu Failed to obtain sBuf"); return HDF_FAILURE; } - reply = AudioRenderObtainHdfSBuf(); + reply = AudioObtainHdfSBuf(); if (reply == NULL) { LOG_FUN_ERR("RenderGetGainStu Failed to obtain reply"); - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } ret = AudioCtlRenderGetGainSBuf(sBuf, handleData); if (ret < 0) { LOG_FUN_ERR("RenderGetGainStu ailed to Get Gain sBuf!"); - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return ret; } - cmdId = AUDIODRV_CTL_IOCTL_ELEM_READ - CTRL_NUM; // ADM Ctrl Num Begin zero service = (struct HdfIoService *)handle->object; - ret = AudioServiceRenderDispatch(service, cmdId, sBuf, reply); + cmdId = AUDIODRV_CTL_IOCTL_ELEM_READ - CTRL_NUM; + ret = AudioServiceDispatch(service, cmdId, sBuf, reply); if (ret != HDF_SUCCESS) { LOG_FUN_ERR("Dispatch Fail!"); - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } struct AudioCtlElemValue gainValueStu; - memset_s(&gainValueStu, sizeof(struct AudioCtlElemValue), 0, sizeof(struct AudioCtlElemValue)); if (!HdfSbufReadInt32(reply, &gainValueStu.value[0])) { LOG_FUN_ERR("Failed to Get Gain sBuf!"); - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } handleData->renderMode.ctlParam.audioGain.gain = gainValueStu.value[0]; - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return ret; } -int32_t AudioCtlRenderSceneSelectSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData, int32_t deviceIndex) +int32_t AudioCtlRenderSceneSelectSBuf(struct HdfSBuf *sBuf, + const struct AudioHwRenderParam *handleData, + const int32_t deviceIndex) { - LOG_FUN_INFO(); if (handleData == NULL || sBuf == NULL) { LOG_FUN_ERR("RenderSceneSelectSBuf handleData or sBuf is NULL!"); return HDF_FAILURE; @@ -673,40 +586,40 @@ int32_t AudioCtlRenderSceneSelectSBuf(struct HdfSBuf *sBuf, struct AudioHwRender LOG_FUN_ERR("deviceIndex is error!"); return HDF_FAILURE; } - memset_s(&g_elemValue, sizeof(struct AudioCtlElemValue), 0, sizeof(struct AudioCtlElemValue)); uint32_t card = handleData->renderMode.hwInfo.card; - if (card < 0 || card >= AUDIO_SERVICE_MAX) { + if (card >= AUDIO_SERVICE_MAX) { LOG_FUN_ERR("card is invalid!"); return HDF_FAILURE; } - g_elemValue.id.cardServiceName = g_audioService[card]; - g_elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC; - g_elemValue.id.itemName = + struct AudioCtlElemValue elemValue; + elemValue.id.cardServiceName = g_audioLibRenderService[card]; + elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC; + elemValue.id.itemName = handleData->renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[deviceIndex].deviceSwitch; - g_elemValue.value[0] = + elemValue.value[0] = handleData->renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[deviceIndex].value; - if (!HdfSbufWriteInt32(sBuf, g_elemValue.value[0])) { + if (!HdfSbufWriteInt32(sBuf, elemValue.value[0])) { LOG_FUN_ERR("RenderSceneSelectSBuf Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteInt32(sBuf, g_elemValue.id.iface)) { + if (!HdfSbufWriteInt32(sBuf, elemValue.id.iface)) { LOG_FUN_ERR("RenderSceneSelectSBuf iface Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemValue.id.cardServiceName)) { + if (!HdfSbufWriteString(sBuf, elemValue.id.cardServiceName)) { LOG_FUN_ERR("RenderSceneSelectSBuf cardServiceName Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemValue.id.itemName)) { + if (!HdfSbufWriteString(sBuf, elemValue.id.itemName)) { LOG_FUN_ERR("RenderSceneSelectSBuf itemName Write Fail!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlRenderSceneSelect(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderSceneSelect(const struct DevHandle *handle, + int cmdId, const struct AudioHwRenderParam *handleData) { - LOG_FUN_INFO(); int32_t index; if (handle == NULL || handle->object == NULL || handleData == NULL) { LOG_FUN_ERR("RenderSceneSelect paras is NULL!"); @@ -714,251 +627,240 @@ int32_t AudioCtlRenderSceneSelect(struct DevHandle *handle, int cmdId, struct Au } struct HdfIoService *service = NULL; struct HdfSBuf *reply = NULL; - struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); if (sBuf == NULL) { LOG_FUN_ERR("RenderSceneSelect Failed to obtain sBuf"); return HDF_FAILURE; } - cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE - CTRL_NUM; // ADM Ctrl Num Begin zero service = (struct HdfIoService *)handle->object; int32_t deviceNum = handleData->renderMode.hwInfo.pathSelect.deviceInfo.deviceNum; if (deviceNum < AUDIO_MIN_DEVICENUM) { LOG_FUN_ERR("AUDIO_MIN_ADAPTERNUM Failed!"); - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } + cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE - CTRL_NUM; for (index = 0; index < deviceNum; index++) { HdfSbufFlush(sBuf); if (AudioCtlRenderSceneSelectSBuf(sBuf, handleData, index) < 0) { LOG_FUN_ERR("AudioCtlRenderSceneSelectSBuf Failed!"); - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { LOG_FUN_ERR("Service is NULL!"); - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } if (service->dispatcher->Dispatch(&service->object, cmdId, sBuf, reply) < 0) { LOG_FUN_ERR("Failed to send service call!"); - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } } - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_SUCCESS; } -int32_t AudioCtlRenderGetVolThresholdSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderGetVolThresholdSBuf(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData) { if (handleData == NULL || sBuf == NULL) { LOG_FUN_ERR("RenderGetVolThresholdSBuf paras is NULL!"); return HDF_FAILURE; } - memset_s(&g_elemInfo, sizeof(struct AudioCtrlElemInfo), 0, sizeof(struct AudioCtrlElemInfo)); uint32_t card = handleData->renderMode.hwInfo.card; - if (card < 0 || card >= AUDIO_SERVICE_MAX) { + if (card >= AUDIO_SERVICE_MAX) { LOG_FUN_ERR("RenderGetVolThresholdSBuf card is Invalid!"); return HDF_FAILURE; } - g_elemInfo.id.cardServiceName = g_audioService[card]; - g_elemInfo.id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC; - g_elemInfo.id.itemName = "Master Playback Volume"; - if (!HdfSbufWriteInt32(sBuf, g_elemInfo.id.iface)) { + struct AudioCtrlElemInfo elemInfo; + elemInfo.id.cardServiceName = g_audioLibRenderService[card]; + elemInfo.id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC; + elemInfo.id.itemName = "Master Playback Volume"; + if (!HdfSbufWriteInt32(sBuf, elemInfo.id.iface)) { LOG_FUN_ERR("RenderGetVolThresholdSBuf iface Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemInfo.id.cardServiceName)) { + if (!HdfSbufWriteString(sBuf, elemInfo.id.cardServiceName)) { LOG_FUN_ERR("RenderGetVolThresholdSBuf cardServiceName Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemInfo.id.itemName)) { + if (!HdfSbufWriteString(sBuf, elemInfo.id.itemName)) { LOG_FUN_ERR("RenderGetVolThresholdSBuf itemName Write Fail!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlRenderSceneGetGainThresholdSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderSceneGetGainThresholdSBuf(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData) { if (handleData == NULL || sBuf == NULL) { LOG_FUN_ERR("RenderSceneGetGainThresholdSBuf paras is NULL!"); return HDF_FAILURE; } - memset_s(&g_elemInfo, sizeof(struct AudioCtrlElemInfo), 0, sizeof(struct AudioCtrlElemInfo)); uint32_t card = handleData->renderMode.hwInfo.card; - if (card < 0 || card >= AUDIO_SERVICE_MAX) { + if (card >= AUDIO_SERVICE_MAX) { LOG_FUN_ERR("RenderSceneGetGainThresholdSBuf card is Invalid!"); return HDF_FAILURE; } - g_elemInfo.id.cardServiceName = g_audioService[card]; - g_elemInfo.id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER; - g_elemInfo.id.itemName = "Mic Left Gain"; - if (!HdfSbufWriteInt32(sBuf, g_elemInfo.id.iface)) { + struct AudioCtrlElemInfo elemInfo; + elemInfo.id.cardServiceName = g_audioLibRenderService[card]; + elemInfo.id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER; + elemInfo.id.itemName = "Mic Left Gain"; + if (!HdfSbufWriteInt32(sBuf, elemInfo.id.iface)) { LOG_FUN_ERR("RenderSceneGetGainThresholdSBuf iface Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemInfo.id.cardServiceName)) { + if (!HdfSbufWriteString(sBuf, elemInfo.id.cardServiceName)) { LOG_FUN_ERR("RenderSceneGetGainThresholdSBuf cardServiceName Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemInfo.id.itemName)) { + if (!HdfSbufWriteString(sBuf, elemInfo.id.itemName)) { LOG_FUN_ERR("RenderSceneGetGainThresholdSBuf itemName Write Fail!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlRenderSceneGetGainThreshold(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderSceneGetGainThreshold(const struct DevHandle *handle, + int cmdId, struct AudioHwRenderParam *handleData) { - LOG_FUN_INFO(); int32_t ret; + if (handle == NULL || handle->object == NULL || handleData == NULL) { LOG_FUN_ERR("RenderSceneGetGainThreshold paras is NULL!"); return HDF_FAILURE; } struct HdfIoService *service = NULL; struct HdfSBuf *reply = NULL; - struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); if (sBuf == NULL) { LOG_FUN_ERR("RenderSceneGetGainThreshold Failed to obtain sBuf"); return HDF_FAILURE; } - reply = AudioRenderObtainHdfSBuf(); + reply = AudioObtainHdfSBuf(); if (reply == NULL) { LOG_FUN_ERR("RenderSceneGetGainThreshold reply is NULL"); - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } ret = AudioCtlRenderSceneGetGainThresholdSBuf(sBuf, handleData); if (ret < 0) { LOG_FUN_ERR("RenderSceneGetGainThreshold Get Threshold sBuf Fail!"); - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return ret; } - cmdId = AUDIODRV_CTL_IOCTL_ELEM_INFO - CTRL_NUM; // ADM Ctrl Num Begin zero service = (struct HdfIoService *)handle->object; - ret = AudioServiceRenderDispatch(service, cmdId, sBuf, reply); + cmdId = AUDIODRV_CTL_IOCTL_ELEM_INFO - CTRL_NUM; + ret = AudioServiceDispatch(service, cmdId, sBuf, reply); if (ret != HDF_SUCCESS) { - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } struct AudioCtrlElemInfo gainThreshold; - memset_s(&gainThreshold, sizeof(struct AudioCtrlElemInfo), 0, sizeof(struct AudioCtrlElemInfo)); if (!HdfSbufReadInt32(reply, &gainThreshold.type)) { LOG_FUN_ERR("RenderSceneGetGainThreshold Failed to Get Volume sBuf!"); - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } if (!HdfSbufReadInt32(reply, &gainThreshold.max)) { LOG_FUN_ERR("RenderSceneGetGainThreshold Failed to Get Volume sBuf!"); - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } handleData->renderMode.ctlParam.audioGain.gainMax = gainThreshold.max; handleData->renderMode.ctlParam.audioGain.gainMin = 0; - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return ret; } -int32_t AudioCtlRenderGetVolThreshold(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderGetVolThreshold(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) { - LOG_FUN_INFO(); if (handle == NULL || handle->object == NULL || handleData == NULL) { LOG_FUN_ERR("paras is NULL!"); return HDF_FAILURE; } - struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); if (sBuf == NULL) { LOG_FUN_ERR("Failed to obtain sBuf"); return HDF_FAILURE; } - struct HdfSBuf *reply = AudioRenderObtainHdfSBuf(); + struct HdfSBuf *reply = AudioObtainHdfSBuf(); if (reply == NULL) { - LOG_FUN_ERR("reply is NULL"); - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } int32_t ret = AudioCtlRenderGetVolThresholdSBuf(sBuf, handleData); if (ret < 0) { LOG_FUN_ERR("Get Threshold sBuf Fail!"); - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return ret; } - cmdId = AUDIODRV_CTL_IOCTL_ELEM_INFO - CTRL_NUM; // ADM Ctrl Num Begin zero struct HdfIoService *service = (struct HdfIoService *)handle->object; - ret = AudioServiceRenderDispatch(service, cmdId, sBuf, reply); + cmdId = AUDIODRV_CTL_IOCTL_ELEM_INFO - CTRL_NUM; + ret = AudioServiceDispatch(service, cmdId, sBuf, reply); if (ret != HDF_SUCCESS) { - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } struct AudioCtrlElemInfo volThreshold; - memset_s(&volThreshold, sizeof(struct AudioCtrlElemInfo), 0, sizeof(struct AudioCtrlElemInfo)); - if (!HdfSbufReadInt32(reply, &volThreshold.type)) { - LOG_FUN_ERR("Failed to Get Volume sBuf!"); - AudioRenderBufReplyRecycle(sBuf, reply); - return HDF_FAILURE; - } - if (!HdfSbufReadInt32(reply, &volThreshold.max)) { - AudioRenderBufReplyRecycle(sBuf, reply); - return HDF_FAILURE; - } - if (!HdfSbufReadInt32(reply, &volThreshold.min)) { - AudioRenderBufReplyRecycle(sBuf, reply); + if (AudioCtlGetVolThresholdRead(reply, &volThreshold) < 0) { + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } handleData->renderMode.ctlParam.volThreshold.volMax = volThreshold.max; handleData->renderMode.ctlParam.volThreshold.volMin = volThreshold.min; - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return ret; } -int32_t AudioCtlRenderSetChannelModeBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderSetChannelModeBuf(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData) { if (handleData == NULL || sBuf == NULL) { LOG_FUN_ERR("RenderSetChannelModeBuf parameter is empty!"); return HDF_FAILURE; } - memset_s(&g_elemValue, sizeof(struct AudioCtlElemValue), 0, sizeof(struct AudioCtlElemValue)); uint32_t card = handleData->renderMode.hwInfo.card; - if (card < 0 || card >= AUDIO_SERVICE_MAX) { + if (card >= AUDIO_SERVICE_MAX) { LOG_FUN_ERR("RenderSetChannelModeBuf card is Error!"); return HDF_FAILURE; } - g_elemValue.id.cardServiceName = g_audioService[card]; - g_elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_AIAO; - g_elemValue.id.itemName = "Render Channel Mode"; - g_elemValue.value[0] = handleData->frameRenderMode.mode; - if (!HdfSbufWriteInt32(sBuf, g_elemValue.value[0])) { + struct AudioCtlElemValue elemValue; + elemValue.id.cardServiceName = g_audioLibRenderService[card]; + elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_AIAO; + elemValue.id.itemName = "Render Channel Mode"; + elemValue.value[0] = handleData->frameRenderMode.mode; + if (!HdfSbufWriteInt32(sBuf, elemValue.value[0])) { LOG_FUN_ERR("RenderSetChannelModeBuf mode Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteInt32(sBuf, g_elemValue.id.iface)) { + if (!HdfSbufWriteInt32(sBuf, elemValue.id.iface)) { LOG_FUN_ERR("RenderSetChannelModeBuf iface Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemValue.id.cardServiceName)) { + if (!HdfSbufWriteString(sBuf, elemValue.id.cardServiceName)) { LOG_FUN_ERR("RenderSetChannelModeBuf cardServiceName Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemValue.id.itemName)) { + if (!HdfSbufWriteString(sBuf, elemValue.id.itemName)) { LOG_FUN_ERR("RenderSetChannelModeBuf itemName Write Fail!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlRenderSetChannelMode(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderSetChannelMode(const struct DevHandle *handle, + int cmdId, const struct AudioHwRenderParam *handleData) { int32_t ret; - LOG_FUN_INFO(); + if (handle == NULL || handle->object == NULL || handleData == NULL) { LOG_FUN_ERR("RenderSetChannelMode paras is NULL!"); return HDF_FAILURE; } struct HdfIoService *service = NULL; struct HdfSBuf *reply = NULL; - struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); if (sBuf == NULL) { LOG_FUN_ERR("RenderSetChannelMode Failed to obtain sBuf"); return HDF_FAILURE; @@ -966,100 +868,97 @@ int32_t AudioCtlRenderSetChannelMode(struct DevHandle *handle, int cmdId, struct ret = AudioCtlRenderSetChannelModeBuf(sBuf, handleData); if (ret < 0) { LOG_FUN_ERR("RenderSetChannelMode Failed to Set ChannelMode sBuf!"); - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return ret; } - cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE; - cmdId -= CTRL_NUM; // ADM Ctrl Num Begin zero service = (struct HdfIoService *)handle->object; if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { LOG_FUN_ERR("RenderSetChannelMode Service is NULL!"); - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } + cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE - CTRL_NUM; ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, reply); if (ret != HDF_SUCCESS) { LOG_FUN_ERR("RenderSetChannelMode Failed to send service call!"); - AudioRenderBufReplyRecycle(sBuf, NULL); - return ret; } - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return ret; } -int32_t AudioCtlRenderGetChannelModeSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderGetChannelModeSBuf(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData) { if (handleData == NULL || sBuf == NULL) { LOG_FUN_ERR("RenderGetChannelModeSBuf parameter is empty!"); return HDF_FAILURE; } - memset_s(&g_elemValue, sizeof(struct AudioCtlElemValue), 0, sizeof(struct AudioCtlElemValue)); uint32_t card = handleData->renderMode.hwInfo.card; - if (card < 0 || card >= AUDIO_SERVICE_MAX) { + if (card >= AUDIO_SERVICE_MAX) { LOG_FUN_ERR("RenderGetChannelModeSBuf card is Error!"); return HDF_FAILURE; } - g_elemValue.id.cardServiceName = g_audioService[card]; - g_elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_AIAO; - g_elemValue.id.itemName = "Render Channel Mode"; - if (!HdfSbufWriteInt32(sBuf, g_elemValue.id.iface)) { + struct AudioCtlElemValue elemValue; + elemValue.id.cardServiceName = g_audioLibRenderService[card]; + elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_AIAO; + elemValue.id.itemName = "Render Channel Mode"; + if (!HdfSbufWriteInt32(sBuf, elemValue.id.iface)) { LOG_FUN_ERR("RenderGetChannelModeSBuf iface Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemValue.id.cardServiceName)) { + if (!HdfSbufWriteString(sBuf, elemValue.id.cardServiceName)) { LOG_FUN_ERR("RenderGetChannelModeSBuf cardServiceName Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemValue.id.itemName)) { + if (!HdfSbufWriteString(sBuf, elemValue.id.itemName)) { LOG_FUN_ERR("RenderGetChannelModeSBuf itemName Write Fail!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlRenderGetChannelMode(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderGetChannelMode(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) { int32_t ret; - LOG_FUN_INFO(); + if (handle == NULL || handle->object == NULL || handleData == NULL) { LOG_FUN_ERR("RenderGetChannelMode paras is NULL!"); return HDF_FAILURE; } struct HdfIoService *service = NULL; struct HdfSBuf *reply = NULL; - struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); if (sBuf == NULL) { LOG_FUN_ERR("RenderGetChannelMode Failed to obtain sBuf"); return HDF_FAILURE; } - reply = AudioRenderObtainHdfSBuf(); + reply = AudioObtainHdfSBuf(); if (reply == NULL) { LOG_FUN_ERR("RenderGetChannelMode Failed to obtain reply"); - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } ret = AudioCtlRenderGetChannelModeSBuf(sBuf, handleData); if (ret < 0) { LOG_FUN_ERR("RenderGetChannelMode Failed to Get Channel Mode sBuf!"); - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return ret; } - cmdId = AUDIODRV_CTL_IOCTL_ELEM_READ - CTRL_NUM; // ADM Ctrl Num Begin zero service = (struct HdfIoService *)handle->object; handleData->frameRenderMode.mode = 1; - ret = AudioServiceRenderDispatch(service, cmdId, sBuf, reply); + cmdId = AUDIODRV_CTL_IOCTL_ELEM_READ - CTRL_NUM; + ret = AudioServiceDispatch(service, cmdId, sBuf, reply); if (ret != HDF_SUCCESS) { - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } struct AudioCtlElemValue elemValue; if (!HdfSbufReadInt32(reply, &elemValue.value[0])) { LOG_FUN_ERR("Failed to Get ChannelMode sBuf!"); - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } handleData->frameRenderMode.mode = (enum AudioChannelMode)elemValue.value[0]; - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return ret; } @@ -1069,24 +968,24 @@ int32_t AudioCtlRenderSetAcodecSBuf(struct HdfSBuf *sBuf, const char *codec, int LOG_FUN_ERR("handleData or sBuf is NULL!"); return HDF_FAILURE; } - memset_s(&g_elemValue, sizeof(struct AudioCtlElemValue), 0, sizeof(struct AudioCtlElemValue)); - g_elemValue.id.cardServiceName = g_audioService[0]; - g_elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_ACODEC; - g_elemValue.id.itemName = codec; - g_elemValue.value[0] = enable; - if (!HdfSbufWriteInt32(sBuf, g_elemValue.value[0])) { + struct AudioCtlElemValue elemValue; + elemValue.id.cardServiceName = g_audioLibRenderService[0]; + elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_ACODEC; + elemValue.id.itemName = codec; + elemValue.value[0] = enable; + if (!HdfSbufWriteInt32(sBuf, elemValue.value[0])) { LOG_FUN_ERR("RenderSetAcodecSBuf value Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteInt32(sBuf, g_elemValue.id.iface)) { + if (!HdfSbufWriteInt32(sBuf, elemValue.id.iface)) { LOG_FUN_ERR("RenderSetAcodecSBuf iface Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemValue.id.cardServiceName)) { + if (!HdfSbufWriteString(sBuf, elemValue.id.cardServiceName)) { LOG_FUN_ERR("RenderSetAcodecSBuf cardServiceName Write Fail!"); return HDF_FAILURE; } - if (!HdfSbufWriteString(sBuf, g_elemValue.id.itemName)) { + if (!HdfSbufWriteString(sBuf, elemValue.id.itemName)) { LOG_FUN_ERR("RenderSetAcodecSBuf itemName Write Fail!"); return HDF_FAILURE; } @@ -1094,12 +993,8 @@ int32_t AudioCtlRenderSetAcodecSBuf(struct HdfSBuf *sBuf, const char *codec, int } int32_t AudioCtlRenderChangeInAcodec(struct HdfIoService *service, - const char *codecName, - struct HdfSBuf *sBuf, - int32_t status, - int cmdId) + const char *codecName, struct HdfSBuf *sBuf, const int32_t status, int cmdId) { - LOG_FUN_INFO(); if (service == NULL || sBuf == NULL) { LOG_FUN_ERR("service or sBuf is NULL!"); return HDF_FAILURE; @@ -1108,18 +1003,18 @@ int32_t AudioCtlRenderChangeInAcodec(struct HdfIoService *service, return HDF_FAILURE; } cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE - CTRL_NUM; - return (AudioServiceRenderDispatch(service, cmdId, sBuf, NULL)); + return (AudioServiceDispatch(service, cmdId, sBuf, NULL)); } -int32_t AudioCtlRenderSetAcodecMode(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderSetAcodecMode(const struct DevHandle *handle, + const int cmdId, const struct AudioHwRenderParam *handleData) { - LOG_FUN_INFO(); if (handle == NULL || handle->object == NULL || handleData == NULL) { LOG_FUN_ERR("paras is NULL!"); return HDF_FAILURE; } struct HdfIoService *service = NULL; - struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); if (sBuf == NULL) { LOG_FUN_ERR("Failed to obtain sBuf"); return HDF_FAILURE; @@ -1130,14 +1025,14 @@ int32_t AudioCtlRenderSetAcodecMode(struct DevHandle *handle, int cmdId, struct /* disable External Codec */ if (AudioCtlRenderChangeInAcodec(service, AUDIODRV_CTL_EXTERN_CODEC_STR, sBuf, AUDIODRV_CTL_ACODEC_DISABLE, cmdId)) { - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } /* enable Internally Codec */ HdfSbufFlush(sBuf); if (AudioCtlRenderChangeInAcodec(service, AUDIODRV_CTL_INTERNAL_CODEC_STR, sBuf, AUDIODRV_CTL_ACODEC_ENABLE, cmdId)) { - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } } else if (cmdId == AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_OUT) { @@ -1145,26 +1040,26 @@ int32_t AudioCtlRenderSetAcodecMode(struct DevHandle *handle, int cmdId, struct /* disable Internally Codec */ if (AudioCtlRenderChangeInAcodec(service, AUDIODRV_CTL_INTERNAL_CODEC_STR, sBuf, AUDIODRV_CTL_ACODEC_DISABLE, cmdId)) { - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } /* enable External Codec */ HdfSbufFlush(sBuf); if (AudioCtlRenderChangeInAcodec(service, AUDIODRV_CTL_EXTERN_CODEC_STR, sBuf, AUDIODRV_CTL_ACODEC_ENABLE, cmdId)) { - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } } else { + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_SUCCESS; } -int32_t AudioInterfaceLibCtlRender(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioInterfaceLibCtlRender(struct DevHandle *handle, const int cmdId, struct AudioHwRenderParam *handleData) { - LOG_FUN_INFO(); if (handle == NULL || handle->object == NULL || handleData == NULL) { LOG_FUN_ERR("paras is NULL!"); return HDF_FAILURE; @@ -1255,8 +1150,7 @@ int32_t ParamsSbufWriteBuffer(struct HdfSBuf *sBuf) int32_t FrameSbufWriteBuffer(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData) { - LOG_FUN_INFO(); - if (sBuf == NULL || handleData == NULL) { + if (sBuf == NULL || handleData == NULL || handleData->frameRenderMode.buffer == NULL) { return HDF_FAILURE; } if (!HdfSbufWriteUint32(sBuf, (uint32_t)(handleData->frameRenderMode.bufferFrameSize))) { @@ -1268,75 +1162,73 @@ int32_t FrameSbufWriteBuffer(struct HdfSBuf *sBuf, const struct AudioHwRenderPar return HDF_SUCCESS; } -int32_t AudioOutputRenderHwParams(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioOutputRenderHwParams(const struct DevHandle *handle, + const int cmdId, const struct AudioHwRenderParam *handleData) { - LOG_FUN_INFO(); if (handle == NULL || handle->object == NULL || handleData == NULL) { + LOG_FUN_ERR("The parameter is empty"); return HDF_FAILURE; } - int32_t ret; struct HdfIoService *service = NULL; - struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); if (sBuf == NULL) { return HDF_FAILURE; } if (SetHwParams(handleData) < 0) { - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } if (ParamsSbufWriteBuffer(sBuf)) { - AudioRenderBufReplyRecycle(sBuf, NULL); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } service = (struct HdfIoService *)handle->object; if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { - LOG_FUN_ERR("Service is NULL!"); - AudioRenderBufReplyRecycle(sBuf, NULL); + LOG_FUN_ERR("The pointer is null!"); + AudioBufReplyRecycle(sBuf, NULL); return HDF_FAILURE; } - ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, NULL); + int32_t ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, NULL); if (ret != HDF_SUCCESS) { LOG_FUN_ERR("Failed to send service call!"); - AudioRenderBufReplyRecycle(sBuf, NULL); - return ret; } - AudioRenderBufReplyRecycle(sBuf, NULL); - return HDF_SUCCESS; + AudioBufReplyRecycle(sBuf, NULL); + return ret; } int32_t AudioOutputRenderWriteFrame(struct HdfIoService *service, - int cmdId, - struct HdfSBuf *sBuf, - struct HdfSBuf *reply) + const int cmdId, struct HdfSBuf *sBuf, struct HdfSBuf *reply) { - LOG_FUN_INFO(); int32_t ret; + int32_t tryNum = 50; // try send sBuf 50 count uint32_t buffStatus = 0; - int32_t tryNum = 50; // try send sBuf count if (service == NULL || sBuf == NULL || reply == NULL) { return HDF_FAILURE; } + if (service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { + return HDF_FAILURE; + } do { ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, reply); if (ret != HDF_SUCCESS) { LOG_FUN_ERR("Failed to send service call!"); - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return ret; } if (!HdfSbufReadUint32(reply, &buffStatus)) { LOG_FUN_ERR("Failed to Get buffStatus!"); - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } if (buffStatus == CIR_BUFF_FULL) { LOG_PARA_INFO("Cir buff fulled wait 10ms"); tryNum--; - usleep(10000); // wait 10ms + usleep(AUDIO_WAIT_DELAY); continue; } break; } while (tryNum > 0); - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); if (tryNum > 0) { return HDF_SUCCESS; } else { @@ -1345,9 +1237,9 @@ int32_t AudioOutputRenderWriteFrame(struct HdfIoService *service, } } -int32_t AudioOutputRenderWrite(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioOutputRenderWrite(const struct DevHandle *handle, + const int cmdId, const struct AudioHwRenderParam *handleData) { - LOG_FUN_INFO(); if (handle == NULL || handle->object == NULL || handleData == NULL) { return HDF_FAILURE; } @@ -1358,20 +1250,20 @@ int32_t AudioOutputRenderWrite(struct DevHandle *handle, int cmdId, struct Audio LOG_FUN_ERR("Get sBuf Fail"); return HDF_FAILURE; } - struct HdfSBuf *reply = AudioRenderObtainHdfSBuf(); + struct HdfSBuf *reply = AudioObtainHdfSBuf(); if (reply == NULL) { LOG_FUN_ERR("reply is empty"); HdfSBufRecycle(sBuf); return HDF_FAILURE; } if (FrameSbufWriteBuffer(sBuf, handleData)) { - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } service = (struct HdfIoService *)handle->object; if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { LOG_FUN_ERR("Service is NULL!"); - AudioRenderBufReplyRecycle(sBuf, reply); + AudioBufReplyRecycle(sBuf, reply); return HDF_FAILURE; } int32_t ret = AudioOutputRenderWriteFrame(service, cmdId, sBuf, reply); @@ -1382,9 +1274,9 @@ int32_t AudioOutputRenderWrite(struct DevHandle *handle, int cmdId, struct Audio return HDF_SUCCESS; } -int32_t AudioOutputRenderStartPrepare(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioOutputRenderStartPrepare(struct DevHandle *handle, + const int cmdId, const struct AudioHwRenderParam *handleData) { - LOG_FUN_INFO(); if (handle == NULL || handle->object == NULL || handleData == NULL) { return HDF_FAILURE; } @@ -1403,20 +1295,19 @@ int32_t AudioOutputRenderStartPrepare(struct DevHandle *handle, int cmdId, struc return HDF_SUCCESS; } -int32_t AudioOutputRenderStop(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioOutputRenderStop(const struct DevHandle *handle, + const int cmdId, const struct AudioHwRenderParam *handleData) { - LOG_FUN_INFO(); if (handle == NULL || handle->object == NULL || handleData == NULL) { return HDF_FAILURE; } - int32_t ret; struct HdfIoService *service = NULL; service = (struct HdfIoService *)handle->object; if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { LOG_FUN_ERR("RenderStop Service is NULL!"); return HDF_FAILURE; } - ret = service->dispatcher->Dispatch(&service->object, cmdId, NULL, NULL); + int32_t ret = service->dispatcher->Dispatch(&service->object, cmdId, NULL, NULL); if (ret != HDF_SUCCESS) { LOG_FUN_ERR("RenderStop Failed to send service call!"); return ret; @@ -1424,9 +1315,99 @@ int32_t AudioOutputRenderStop(struct DevHandle *handle, int cmdId, struct AudioH return HDF_SUCCESS; } -int32_t AudioInterfaceLibOutputRender(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +int32_t MmapDescWriteBuffer(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData) +{ + if (sBuf == NULL || handleData == NULL) { + return HDF_FAILURE; + } + uint64_t mmapAddr = (uint64_t)(handleData->frameRenderMode.mmapBufDesc.memoryAddress); + if (!HdfSbufWriteUint64(sBuf, mmapAddr)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(sBuf, handleData->frameRenderMode.mmapBufDesc.memoryFd)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(sBuf, handleData->frameRenderMode.mmapBufDesc.totalBufferFrames)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(sBuf, handleData->frameRenderMode.mmapBufDesc.transferFrameSize)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(sBuf, handleData->frameRenderMode.mmapBufDesc.isShareable)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, handleData->frameRenderMode.mmapBufDesc.offset)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioOutputRenderReqMmapBuffer(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +{ + if (handle == NULL || handle->object == NULL || handleData == NULL) { + return HDF_FAILURE; + } + struct HdfIoService *service = NULL; + int32_t ret; + struct HdfSBuf *sBuf = AudioObtainHdfSBuf(); + if (sBuf == NULL) { + return HDF_FAILURE; + } + if (MmapDescWriteBuffer(sBuf, handleData)) { + AudioBufReplyRecycle(sBuf, NULL); + return HDF_FAILURE; + } + service = (struct HdfIoService *)handle->object; + if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { + AudioBufReplyRecycle(sBuf, NULL); + LOG_FUN_ERR("Failed to send service call!"); + return HDF_FAILURE; + } + ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, NULL); + if (ret != HDF_SUCCESS) { + AudioBufReplyRecycle(sBuf, NULL); + return HDF_FAILURE; + } + AudioBufReplyRecycle(sBuf, NULL); + return HDF_SUCCESS; +} + +int32_t AudioOutputRenderGetMmapPosition(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +{ + if (handle == NULL || handle->object == NULL || handleData == NULL) { + return HDF_FAILURE; + } + struct HdfIoService *service = NULL; + struct HdfSBuf *reply = NULL; + int32_t ret; + service = (struct HdfIoService *)handle->object; + if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { + LOG_FUN_ERR("Failed to send service call!"); + return HDF_FAILURE; + } + reply = AudioObtainHdfSBuf(); + if (reply == NULL) { + LOG_FUN_ERR("RenderGetMmapPosition Failed to obtain reply"); + return HDF_FAILURE; + } + ret = service->dispatcher->Dispatch(&service->object, cmdId, NULL, reply); + if (ret != HDF_SUCCESS) { + AudioBufReplyRecycle(NULL, reply); + return HDF_FAILURE; + } + uint64_t frames = 0; + if (!HdfSbufReadUint64(reply, &frames)) { + LOG_FUN_ERR("Failed to Get Mmap Position sBuf!"); + AudioBufReplyRecycle(NULL, reply); + return HDF_FAILURE; + } + handleData->frameRenderMode.frames = frames; + AudioBufReplyRecycle(NULL, reply); + return HDF_SUCCESS; +} + +int32_t AudioInterfaceLibOutputRender(struct DevHandle *handle, const int cmdId, struct AudioHwRenderParam *handleData) { - LOG_FUN_INFO(); if (handle == NULL) { LOG_FUN_ERR("Input Render handle is NULL!"); return HDF_FAILURE; @@ -1439,23 +1420,25 @@ int32_t AudioInterfaceLibOutputRender(struct DevHandle *handle, int cmdId, struc case AUDIO_DRV_PCM_IOCTL_HW_PARAMS: ret = AudioOutputRenderHwParams(handle, cmdId, handleData); break; - case AUDIO_DRV_PCM_IOCTL_WRITE: ret = AudioOutputRenderWrite(handle, cmdId, handleData); break; - case AUDIO_DRV_PCM_IOCTRL_STOP: ret = AudioOutputRenderStop(handle, cmdId, handleData); break; - case AUDIO_DRV_PCM_IOCTRL_START: case AUDIO_DRV_PCM_IOCTL_PREPARE: ret = AudioOutputRenderStartPrepare(handle, cmdId, handleData); break; - case AUDIODRV_CTL_IOCTL_PAUSE_WRITE: - return (AudioCtlRenderSetPauseStu(handle, cmdId, handleData)); - + ret = AudioCtlRenderSetPauseStu(handle, cmdId, handleData); + break; + case AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER: + ret = AudioOutputRenderReqMmapBuffer(handle, cmdId, handleData); + break; + case AUDIO_DRV_PCM_IOCTL_MMAP_POSITION: + ret = (AudioOutputRenderGetMmapPosition(handle, cmdId, handleData)); + break; default: LOG_FUN_ERR("Output Mode not support!"); ret = HDF_FAILURE; @@ -1466,7 +1449,6 @@ int32_t AudioInterfaceLibOutputRender(struct DevHandle *handle, int cmdId, struc int32_t AudioBindServiceRenderObject(struct DevHandle *handle, const char *name) { - LOG_FUN_INFO(); if (handle == NULL || name == NULL) { LOG_FUN_ERR("service name or handle is NULL!"); return HDF_FAILURE; @@ -1488,7 +1470,6 @@ int32_t AudioBindServiceRenderObject(struct DevHandle *handle, const char *name) AudioMemFree((void **)&serviceName); return HDF_FAILURE; } - LOG_PARA_INFO("serviceName = %s", serviceName); AudioMemFree((void **)&serviceName); handle->object = service; return HDF_SUCCESS; @@ -1497,7 +1478,6 @@ int32_t AudioBindServiceRenderObject(struct DevHandle *handle, const char *name) /* CreatRender for Bind handle */ struct DevHandle *AudioBindServiceRender(const char *name) { - LOG_FUN_INFO(); struct DevHandle *handle = NULL; if (name == NULL) { LOG_FUN_ERR("service name NULL!"); @@ -1518,9 +1498,8 @@ struct DevHandle *AudioBindServiceRender(const char *name) return handle; } -void AudioCloseServiceRender(struct DevHandle *handle) +void AudioCloseServiceRender(const struct DevHandle *handle) { - LOG_FUN_INFO(); if (handle == NULL || handle->object == NULL) { LOG_FUN_ERR("Render handle or handle->object is NULL"); return; @@ -1533,7 +1512,6 @@ void AudioCloseServiceRender(struct DevHandle *handle) int32_t AudioInterfaceLibModeRender(struct DevHandle *handle, struct AudioHwRenderParam *handleData, int cmdId) { - LOG_FUN_INFO(); if (handle == NULL || handle->object == NULL || handleData == NULL) { LOG_FUN_ERR("paras is NULL!"); return HDF_FAILURE; @@ -1545,6 +1523,8 @@ int32_t AudioInterfaceLibModeRender(struct DevHandle *handle, struct AudioHwRend case AUDIO_DRV_PCM_IOCTRL_START: case AUDIO_DRV_PCM_IOCTL_PREPARE: case AUDIODRV_CTL_IOCTL_PAUSE_WRITE: + case AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER: + case AUDIO_DRV_PCM_IOCTL_MMAP_POSITION: return (AudioInterfaceLibOutputRender(handle, cmdId, handleData)); case AUDIODRV_CTL_IOCTL_ELEM_WRITE: case AUDIODRV_CTL_IOCTL_ELEM_READ: diff --git a/audio/hal/pathselect/src/BUILD.gn b/audio/test/hdf/BUILD.gn similarity index 32% rename from audio/hal/pathselect/src/BUILD.gn rename to audio/test/hdf/BUILD.gn index fef400147c..1e81f2b36b 100755 --- a/audio/hal/pathselect/src/BUILD.gn +++ b/audio/test/hdf/BUILD.gn @@ -11,84 +11,59 @@ # See the License for the specific language governing permissions and # limitations under the License. -if (defined(ohos_lite)) { - import("//build/lite/config/component/lite_component.gni") -} else { - import("//build/ohos.gni") -} -import("//drivers/adapter/uhdf2/uhdf.gni") +import("//build/test.gni") -config("pathseltct_config") { - visibility = [ ":*" ] +module_output_path = "hdf/audio/unittest/adm" +ohos_unittest("hdf_audio_adm_test") { + module_out_path = module_output_path - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-DGST_DISABLE_DEPRECATED", - "-DHAVE_CONFIG_H", - "-fno-strict-aliasing", - "-Wno-sign-compare", - "-Wno-builtin-requires-header", - "-Wno-implicit-function-declaration", - "-Wno-format", - "-Wno-int-conversion", - "-Wno-unused-function", - "-Wno-unused-parameter", - "-Wno-thread-safety-attributes", - "-Wno-inconsistent-missing-override", - "-fno-rtti", - "-fno-exceptions", - "-ffunction-sections", - "-fdata-sections", + include_dirs = [ + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/include/platform", + "//drivers/framework/include/core", + "//drivers/framework/include/osal", + "//drivers/adapter/uhdf/posix/include", + "//drivers/framework/include/utils", + "//drivers/framework/include/config", + "//drivers/framework/include", + "//drivers/framework/test/unittest/include", + "//drivers/framework/test/unittest/osal", + "//drivers/framework/test/unittest/model/audio/include", + "//drivers/framework/model/audio/core/test/unittest/common" ] - ldflags = [ "-Wl" ] -} - -ohos_shared_library("hdi_audio_path_select") { + defines = [ "__USER__" ] sources = [ - "//third_party/cJSON/cJSON.c", - "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_common.c", - "audio_pathselect.c", - ] - - include_dirs = [ - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/hal/pathselect/include", - "//third_party/cJSON", - "//drivers/peripheral/audio/interfaces/include", - "$hdf_framework_path/include/core", - "$hdf_framework_path/include/utils", - "$hdf_framework_path/include/osal", - "$hdf_framework_path/include", - "//third_party/bounds_checking_function/include", - "$hdf_framework_path/ability/sbuf/include", - "$hdf_framework_path/utils/include", - "$hdf_framework_path/ability/sbuf/include", - "$hdf_uhdf_path/osal/include" + "//drivers/framework/model/audio/core/test/unittest/common/audio_host_test.cpp", + "//drivers/framework/model/audio/core/test/unittest/common/audio_parse_test.cpp", + "//drivers/framework/model/audio/core/test/unittest/common/audio_core_test.cpp", + "//drivers/framework/model/audio/sapm/test/unittest/common/audio_sapm_test.cpp", + "//drivers/framework/model/audio/dispatch/test/unittest/common/audio_stream_dispatch_test.cpp", ] - deps = [ - "$hdf_uhdf_path/osal:libhdf_utils", - "$hdf_uhdf_path/manager:hdf_devmgr", - "$hdf_uhdf_path/manager:hdf_devmgr.rc", + "//drivers/adapter/uhdf2/osal:libhdf_utils", + "//drivers/adapter/uhdf2/test/unittest/common:libhdf_test_common", "//utils/native/base:utils", - "$hdf_uhdf_path/hdi:libhdi", - "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", - "$hdf_uhdf_path/host:hdf_devhost", - "$hdf_uhdf_path/host:libhdf_host", - "$hdf_uhdf_path/config:libhdf_hcs", - "$hdf_uhdf_path/hcs:hdf_default.hcb", ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] if (is_standard_system) { external_deps = [ "hiviewdfx_hilog_native:libhilog" ] } else { external_deps = [ "hilog:libhilog" ] } +} - public_configs = [ ":pathseltct_config" ] - - subsystem_name = "hdf" -} \ No newline at end of file +group("hdf_test_audio") { + testonly = true + deps = [ + ":hdf_audio_adm_test" + ] +} diff --git a/audio/test/systemtest/BUILD.gn b/audio/test/systemtest/BUILD.gn index b9b506989e..9a1734f404 100755 --- a/audio/test/systemtest/BUILD.gn +++ b/audio/test/systemtest/BUILD.gn @@ -11,13 +11,18 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build/test.gni") -import("//drivers/adapter/uhdf2/uhdf.gni") +if (defined(ohos_lite)) { + import("//build/lite/config/test.gni") +} else { + import("//build/test.gni") + import("//drivers/adapter/uhdf2/uhdf.gni") +} #################################group######################################### group("systemtest") { - if(is_standard_system) { + if (!defined(ohos_lite)) { testonly = true + } deps = [] deps += [ @@ -26,6 +31,5 @@ group("systemtest") { "hdi:hdi", "adm:adm", ] - } } ############################################################################### diff --git a/audio/test/systemtest/adm/BUILD.gn b/audio/test/systemtest/adm/BUILD.gn index d105384fb8..af403e310f 100755 --- a/audio/test/systemtest/adm/BUILD.gn +++ b/audio/test/systemtest/adm/BUILD.gn @@ -11,14 +11,20 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build/test.gni") -import("//drivers/adapter/uhdf2/uhdf.gni") +if (defined(ohos_lite)) { + import("//build/lite/config/test.gni") +} else { + import("//build/test.gni") + import("//drivers/adapter/uhdf2/uhdf.gni") +} ###########################end########################### group("adm") { - testonly = true + if (!defined(ohos_lite)) { + testonly = true + } deps = [] deps += [ - "audio_adm_interface:AudioAdmInterfaceTest", + "audio_adm_interface:hdf_audio_adm_interface_test", ] } diff --git a/audio/test/systemtest/adm/audio_adm_interface/BUILD.gn b/audio/test/systemtest/adm/audio_adm_interface/BUILD.gn index 5ba2b320d5..d9d5bb367b 100755 --- a/audio/test/systemtest/adm/audio_adm_interface/BUILD.gn +++ b/audio/test/systemtest/adm/audio_adm_interface/BUILD.gn @@ -11,57 +11,131 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build/test.gni") -import("//drivers/adapter/uhdf2/uhdf.gni") +if (defined(ohos_lite)) { + import("//build/lite/config/test.gni") +} else { + import("//build/test.gni") + import("//drivers/adapter/uhdf2/uhdf.gni") + import("//drivers/peripheral/audio/audio.gni") +} + +if (defined(ohos_lite)) { +###########################-LITEOS-############################################ +###########################hdf_audio_adm_interface_test########################### + unittest("hdf_audio_adm_interface_test") { + sources = [ + "src/audio_adm_interface_test.cpp", + "../../common/adm_common/src/audio_adm_common.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp", + ] + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/include", + "//drivers/framework/core/sec/include", + "//drivers/framework/core/shared/include", + "//drivers/framework/core/host/include", + "//drivers/framework/core/manager/include", + "//drivers/framework/core/common/include/host/", + "//third_party/bounds_checking_function/include", + "//drivers/adapter/khdf/liteos/osal/include", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/adapter/uhdf2/include/hdi/", + "//drivers/peripheral/audio/test/systemtest/common/adm_common/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/adm/audio_adm_interface/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + "-std=c++11" + ] -module_output_path = "hdf/audio/systemtest/adm" -###########################systemtest############################## -###########################AudioAdmInterfaceTest########################### -ohos_systemtest("AudioAdmInterfaceTest") { - module_out_path = module_output_path - sources = [ - "src/audio_adm_interface_test.cpp", - "../../common/adm_common/src/audio_adm_common.cpp" - ] + deps = [ + "//third_party/bounds_checking_function:libsec_shared", + "//base/hiviewdfx/hilog_lite/frameworks/featured:hilog_shared", + "//drivers/adapter/uhdf/manager:hdf_core", + "//drivers/adapter/uhdf/posix:hdf_posix_osal" + ] + } +} else { + module_output_path = "hdf/audio" + ###########################hdf_audio_adm_interface_test########################### + ohos_systemtest("hdf_audio_adm_interface_test") { + module_out_path = module_output_path + sources = [ + "src/audio_adm_interface_test.cpp", + "../../common/adm_common/src/audio_adm_common.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp", + ] - include_dirs = [ - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/interfaces/include", - "//drivers/framework/include/core", - "//drivers/framework/include/utils", - "//drivers/framework/include/osal", - "//drivers/framework/include", - "//third_party/bounds_checking_function/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/framework/utils/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/adapter/uhdf2/osal/include", - "//drivers/peripheral/audio/test/systemtest/common/adm_common/include", - "//third_party/googletest/googletest/include/gtest", - "//drivers/peripheral/audio/test/systemtest/adm/audio_adm_interface/include", - ] - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - ] - deps = [ - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - "//utils/native/base:utils", - "//drivers/adapter/uhdf2/hdi:libhdi", - "//drivers/adapter/uhdf2/manager:hdf_devmgr", - "//drivers/adapter/uhdf2/manager:hdf_devmgr.rc", - "//drivers/adapter/uhdf2/ipc:libhdf_ipc_adapter", - "//drivers/adapter/uhdf2/osal:libhdf_utils", - "//drivers/adapter/uhdf2/host:hdf_devhost", - "//drivers/adapter/uhdf2/host:libhdf_host", - "//drivers/adapter/uhdf2/config:libhdf_hcs", - "//drivers/adapter/uhdf2/hcs:hdf_default.hcb", - ] + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/include", + "//third_party/bounds_checking_function/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/adapter/uhdf2/osal/include", + "//drivers/peripheral/audio/test/systemtest/common/adm_common/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/adm/audio_adm_interface/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + deps = [ + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + "//utils/native/base:utils", + "//drivers/adapter/uhdf2/hdi:libhdi", + "//drivers/adapter/uhdf2/manager:hdf_devmgr", + "//drivers/adapter/uhdf2/manager:hdf_devmgr.rc", + "//drivers/adapter/uhdf2/ipc:libhdf_ipc_adapter", + "//drivers/adapter/uhdf2/osal:libhdf_utils", + "//drivers/adapter/uhdf2/host:hdf_devhost", + "//drivers/adapter/uhdf2/host:libhdf_host", + "//drivers/adapter/uhdf2/config:libhdf_hcs", + "//drivers/adapter/uhdf2/hcs:hdf_default.hcb", + ] + defines = [] + if (enable_audio_adm_so) { + defines += [ "AUDIO_ADM_SO" ] + } + if (enable_audio_mpi_so) { + defines += [ "AUDIO_MPI_SO" ] + } + if (enable_audio_adm_service) { + defines += [ "AUDIO_ADM_SERVICE" ] + } + if (enable_audio_mpi_service) { + defines += [ "AUDIO_MPI_SERVICE" ] + } + } } ###########################end########################### diff --git a/audio/test/systemtest/adm/audio_adm_interface/src/audio_adm_interface_test.cpp b/audio/test/systemtest/adm/audio_adm_interface/src/audio_adm_interface_test.cpp index 7474cbc1a0..e4b8f7515b 100755 --- a/audio/test/systemtest/adm/audio_adm_interface/src/audio_adm_interface_test.cpp +++ b/audio/test/systemtest/adm/audio_adm_interface/src/audio_adm_interface_test.cpp @@ -36,7 +36,6 @@ namespace { const int MAX_GAIN_VALUE = 15; const int MIN_GAIN_VALUE = 0; const int ERROR_GAIN_VALUE = MAX_GAIN_VALUE + 1; - const string AUDIO_FILE_PATH = "//bin/audiorendertest.wav"; class AudioAdmInterfaceTest : public testing::Test { public: @@ -55,9 +54,9 @@ void AudioAdmInterfaceTest::SetUp(void) {}; void AudioAdmInterfaceTest::TearDown(void) {}; /** -* @tc.name Test the ADM ctrl data analysis function via setting the incoming parameter cmid is illegal +* @tc.name Test the ADM ctrl data analysis function via setting the incoming parameter cmdid is illegal * @tc.number SUB_Audio_ControlDispatch_0001 -* @tc.desc Test the ADM ctrl data analysis function,return -1 when setting the incoming parameter cmid is illegal +* @tc.desc Test the ADM ctrl data analysis function,return -1 when setting the incoming parameter cmdid is illegal * @tc.author: liweiming */ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlDispatch_0001, TestSize.Level1) @@ -108,7 +107,7 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlDispatch_0002, TestSize.Level1) .id.cardServiceName = "hdf_audio_codec_dev0", .id.iface = AUDIODRV_CTL_ELEM_IFACE_GAIN, .id.itemName = "Mic Left Gain", - .value[0] = 5, + .value[0] = 6, }; service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); @@ -124,15 +123,15 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlDispatch_0002, TestSize.Level1) ret = WriteEleValueToBuf(writeBuf, writeElemValue); EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(objectNull, AUDIODRV_CTL_IOCTL_ELEM_WRITE, writeBuf, writeReply); + ret = service->dispatcher->Dispatch(objectNull, AUDIODRV_CTRL_IOCTRL_ELEM_WRITE, writeBuf, writeReply); EXPECT_EQ(HDF_FAILURE, ret); HdfSBufRecycle(writeBuf); HdfIoServiceRecycle(service); } /** -* @tc.name Test the ADM stream data analysis function via setting the incoming parameter cmid is illegal +* @tc.name Test the ADM stream data analysis function via setting the incoming parameter cmdid is illegal * @tc.number SUB_Audio_StreamDispatch_0001 -* @tc.desc Test the ADM stream data analysis function,return -1 when setting the incoming parameter cmid is illegal +* @tc.desc Test the ADM stream data analysis function,return -1 when setting the incoming parameter cmdid is illegal * @tc.author: liweiming */ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamDispatch_0001, TestSize.Level1) @@ -211,41 +210,19 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_Read_0001, TestSi int32_t ret = -1; int32_t expectValue = 5; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *readBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; - struct HdfSBuf *readReply = nullptr; - struct AudioCtlElemValue writeElemValue = { + service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); + ASSERT_NE(nullptr, service); + ASSERT_NE(nullptr, service->dispatcher); + struct AudioCtlElemValue elemValue = { .id.cardServiceName = "hdf_audio_codec_dev0", .id.iface = AUDIODRV_CTL_ELEM_IFACE_GAIN, .id.itemName = "Mic Left Gain", .value[0] = 5, }; - struct AudioCtlElemValue readElemValue = {}; - service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - - ret = ObtainBuf(writeBuf, readBuf, readReply); - if (ret < 0) { - HdfIoServiceRecycle(service); - ASSERT_NE(HDF_SUCCESS, ret); - } - ret = WriteEleValueToBuf(writeBuf, writeElemValue); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = WriteIdToBuf(readBuf, writeElemValue.id); - EXPECT_EQ(HDF_SUCCESS, ret); - - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_WRITE, writeBuf, writeReply); + ret = WriteCtrlInfo(service, elemValue); EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_READ, readBuf, readReply); + ret = ReadCtrlInfo(service, elemValue.id, expectValue); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSbufReadInt32(readReply, &readElemValue.value[0]); - EXPECT_EQ(expectValue, readElemValue.value[0]); - - HdfSBufRecycle(writeBuf); - HdfSBufRecycle(readBuf); - HdfSBufRecycle(readReply); HdfIoServiceRecycle(service); } /** @@ -257,42 +234,21 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_Read_0001, TestSi HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_Read_0002, TestSize.Level1) { int32_t ret = -1; - int32_t expectMinValue = MIN_GAIN_VALUE; + int32_t expectValue = MIN_GAIN_VALUE; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *readBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; - struct HdfSBuf *readReply = nullptr; - struct AudioCtlElemValue writeElemValue = { + service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); + ASSERT_NE(nullptr, service); + ASSERT_NE(nullptr, service->dispatcher); + struct AudioCtlElemValue elemValue = { .id.cardServiceName = "hdf_audio_codec_dev0", .id.iface = AUDIODRV_CTL_ELEM_IFACE_GAIN, .id.itemName = "Mic Left Gain", .value[0] = MIN_GAIN_VALUE, }; - struct AudioCtlElemValue readElemValue = {}; - service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - - ret = ObtainBuf(writeBuf, readBuf, readReply); - if (ret < 0) { - HdfIoServiceRecycle(service); - ASSERT_NE(HDF_SUCCESS, ret); - } - ret = WriteEleValueToBuf(writeBuf, writeElemValue); + ret = WriteCtrlInfo(service, elemValue); EXPECT_EQ(HDF_SUCCESS, ret); - ret = WriteIdToBuf(readBuf, writeElemValue.id); + ret = ReadCtrlInfo(service, elemValue.id, expectValue); EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_WRITE, writeBuf, writeReply); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_READ, readBuf, readReply); - EXPECT_EQ(HDF_SUCCESS, ret); - HdfSbufReadInt32(readReply, &readElemValue.value[0]); - EXPECT_EQ(expectMinValue, readElemValue.value[0]); - - HdfSBufRecycle(writeBuf); - HdfSBufRecycle(readBuf); - HdfSBufRecycle(readReply); HdfIoServiceRecycle(service); } /** @@ -304,42 +260,21 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_Read_0002, TestSi HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_Read_0003, TestSize.Level1) { int32_t ret = -1; - int32_t expectMaxValue = MAX_GAIN_VALUE; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *readBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; - struct HdfSBuf *readReply = nullptr; - struct AudioCtlElemValue writeElemValue = { + int32_t expectValue = MAX_GAIN_VALUE; + service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); + ASSERT_NE(nullptr, service); + ASSERT_NE(nullptr, service->dispatcher); + struct AudioCtlElemValue elemValue = { .id.cardServiceName = "hdf_audio_codec_dev0", .id.iface = AUDIODRV_CTL_ELEM_IFACE_GAIN, .id.itemName = "Mic Left Gain", .value[0] = MAX_GAIN_VALUE, }; - struct AudioCtlElemValue readElemValue = {}; - service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - - ret = ObtainBuf(writeBuf, readBuf, readReply); - if (ret < 0) { - HdfIoServiceRecycle(service); - ASSERT_NE(HDF_SUCCESS, ret); - } - ret = WriteEleValueToBuf(writeBuf, writeElemValue); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = WriteIdToBuf(readBuf, writeElemValue.id); + ret = WriteCtrlInfo(service, elemValue); EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_WRITE, writeBuf, writeReply); + ret = ReadCtrlInfo(service, elemValue.id, expectValue); EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_READ, readBuf, readReply); - EXPECT_EQ(HDF_SUCCESS, ret); - HdfSbufReadInt32(readReply, &readElemValue.value[0]); - EXPECT_EQ(expectMaxValue, readElemValue.value[0]); - - HdfSBufRecycle(writeBuf); - HdfSBufRecycle(readBuf); - HdfSBufRecycle(readReply); HdfIoServiceRecycle(service); } /** @@ -352,29 +287,17 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_Read_0004, TestSi { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; - struct AudioCtlElemValue writeElemValue = { + service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); + ASSERT_NE(nullptr, service); + ASSERT_NE(nullptr, service->dispatcher); + struct AudioCtlElemValue elemValue = { .id.cardServiceName = "hdf_audio_codec_dev0", .id.iface = AUDIODRV_CTL_ELEM_IFACE_GAIN, .id.itemName = "Mic Left Gain", .value[0] = ERROR_GAIN_VALUE, }; - service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - - writeBuf = HdfSBufObtainDefaultSize(); - if (writeBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, writeBuf); - } - ret = WriteEleValueToBuf(writeBuf, writeElemValue); - EXPECT_EQ(HDF_SUCCESS, ret); - - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_WRITE, writeBuf, writeReply); + ret = WriteCtrlInfo(service, elemValue); EXPECT_EQ(HDF_FAILURE, ret); - HdfSBufRecycle(writeBuf); HdfIoServiceRecycle(service); } /** @@ -388,40 +311,19 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0005, TestSi int32_t ret = -1; int32_t expectValue = AUDIO_CHANNEL_NORMAL; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *readBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; - struct HdfSBuf *readReply = nullptr; - struct AudioCtlElemValue writeElemValue = { + service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); + ASSERT_NE(nullptr, service); + ASSERT_NE(nullptr, service->dispatcher); + struct AudioCtlElemValue elemValue = { .id.cardServiceName = "hdf_audio_codec_dev0", .id.iface = AUDIODRV_CTL_ELEM_IFACE_AIAO, .id.itemName = "Render Channel Mode", .value[0] = AUDIO_CHANNEL_NORMAL, }; - struct AudioCtlElemValue readElemValue = {}; - service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - - ret = ObtainBuf(writeBuf, readBuf, readReply); - if (ret < 0) { - HdfIoServiceRecycle(service); - ASSERT_NE(HDF_SUCCESS, ret); - } - ret = WriteEleValueToBuf(writeBuf, writeElemValue); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = WriteIdToBuf(readBuf, writeElemValue.id); - EXPECT_EQ(HDF_SUCCESS, ret); - - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_WRITE, writeBuf, writeReply); + ret = WriteCtrlInfo(service, elemValue); EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_READ, readBuf, readReply); + ret = ReadCtrlInfo(service, elemValue.id, expectValue); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSbufReadInt32(readReply, &readElemValue.value[0]); - EXPECT_EQ(expectValue, readElemValue.value[0]); - HdfSBufRecycle(writeBuf); - HdfSBufRecycle(readBuf); - HdfSBufRecycle(readReply); HdfIoServiceRecycle(service); } /** @@ -435,40 +337,19 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0006, TestSi int32_t ret = -1; int32_t expectValue = AUDIO_CHANNEL_BOTH_LEFT; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *readBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; - struct HdfSBuf *readReply = nullptr; - struct AudioCtlElemValue writeElemValue = { + service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); + ASSERT_NE(nullptr, service); + ASSERT_NE(nullptr, service->dispatcher); + struct AudioCtlElemValue elemValue = { .id.cardServiceName = "hdf_audio_codec_dev0", .id.iface = AUDIODRV_CTL_ELEM_IFACE_AIAO, .id.itemName = "Render Channel Mode", .value[0] = AUDIO_CHANNEL_BOTH_LEFT, }; - struct AudioCtlElemValue readElemValue = {}; - service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - - ret = ObtainBuf(writeBuf, readBuf, readReply); - if (ret < 0) { - HdfIoServiceRecycle(service); - ASSERT_NE(HDF_SUCCESS, ret); - } - ret = WriteEleValueToBuf(writeBuf, writeElemValue); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = WriteIdToBuf(readBuf, writeElemValue.id); - EXPECT_EQ(HDF_SUCCESS, ret); - - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_WRITE, writeBuf, writeReply); + ret = WriteCtrlInfo(service, elemValue); EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_READ, readBuf, readReply); + ret = ReadCtrlInfo(service, elemValue.id, expectValue); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSbufReadInt32(readReply, &readElemValue.value[0]); - EXPECT_EQ(expectValue, readElemValue.value[0]); - HdfSBufRecycle(writeBuf); - HdfSBufRecycle(readBuf); - HdfSBufRecycle(readReply); HdfIoServiceRecycle(service); } /** @@ -482,40 +363,19 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0007, TestSi int32_t ret = -1; int32_t expectValue = AUDIO_CHANNEL_BOTH_RIGHT; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *readBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; - struct HdfSBuf *readReply = nullptr; - struct AudioCtlElemValue writeElemValue = { + service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); + ASSERT_NE(nullptr, service); + ASSERT_NE(nullptr, service->dispatcher); + struct AudioCtlElemValue elemValue = { .id.cardServiceName = "hdf_audio_codec_dev0", .id.iface = AUDIODRV_CTL_ELEM_IFACE_AIAO, .id.itemName = "Render Channel Mode", .value[0] = AUDIO_CHANNEL_BOTH_RIGHT, }; - struct AudioCtlElemValue readElemValue = {}; - service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - - ret = ObtainBuf(writeBuf, readBuf, readReply); - if (ret < 0) { - HdfIoServiceRecycle(service); - ASSERT_NE(HDF_SUCCESS, ret); - } - ret = WriteEleValueToBuf(writeBuf, writeElemValue); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = WriteIdToBuf(readBuf, writeElemValue.id); - EXPECT_EQ(HDF_SUCCESS, ret); - - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_WRITE, writeBuf, writeReply); + ret = WriteCtrlInfo(service, elemValue); EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_READ, readBuf, readReply); + ret = ReadCtrlInfo(service, elemValue.id, expectValue); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSbufReadInt32(readReply, &readElemValue.value[0]); - EXPECT_EQ(expectValue, readElemValue.value[0]); - HdfSBufRecycle(writeBuf); - HdfSBufRecycle(readBuf); - HdfSBufRecycle(readReply); HdfIoServiceRecycle(service); } /** @@ -529,40 +389,19 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0008, TestSi int32_t ret = -1; int32_t expectValue = AUDIO_CHANNEL_EXCHANGE; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *readBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; - struct HdfSBuf *readReply = nullptr; - struct AudioCtlElemValue writeElemValue = { + service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); + ASSERT_NE(nullptr, service); + ASSERT_NE(nullptr, service->dispatcher); + struct AudioCtlElemValue elemValue = { .id.cardServiceName = "hdf_audio_codec_dev0", .id.iface = AUDIODRV_CTL_ELEM_IFACE_AIAO, .id.itemName = "Render Channel Mode", .value[0] = AUDIO_CHANNEL_EXCHANGE, }; - struct AudioCtlElemValue readElemValue = {}; - service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - - ret = ObtainBuf(writeBuf, readBuf, readReply); - if (ret < 0) { - HdfIoServiceRecycle(service); - ASSERT_NE(HDF_SUCCESS, ret); - } - ret = WriteEleValueToBuf(writeBuf, writeElemValue); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = WriteIdToBuf(readBuf, writeElemValue.id); - EXPECT_EQ(HDF_SUCCESS, ret); - - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_WRITE, writeBuf, writeReply); + ret = WriteCtrlInfo(service, elemValue); EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_READ, readBuf, readReply); + ret = ReadCtrlInfo(service, elemValue.id, expectValue); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSbufReadInt32(readReply, &readElemValue.value[0]); - EXPECT_EQ(expectValue, readElemValue.value[0]); - HdfSBufRecycle(writeBuf); - HdfSBufRecycle(readBuf); - HdfSBufRecycle(readReply); HdfIoServiceRecycle(service); } /** @@ -576,40 +415,19 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0009, TestSi int32_t ret = -1; int32_t expectValue = AUDIO_CHANNEL_MIX; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *readBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; - struct HdfSBuf *readReply = nullptr; - struct AudioCtlElemValue writeElemValue = { + service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); + ASSERT_NE(nullptr, service); + ASSERT_NE(nullptr, service->dispatcher); + struct AudioCtlElemValue elemValue = { .id.cardServiceName = "hdf_audio_codec_dev0", .id.iface = AUDIODRV_CTL_ELEM_IFACE_AIAO, .id.itemName = "Render Channel Mode", .value[0] = AUDIO_CHANNEL_MIX, }; - struct AudioCtlElemValue readElemValue = {}; - service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - - ret = ObtainBuf(writeBuf, readBuf, readReply); - if (ret < 0) { - HdfIoServiceRecycle(service); - ASSERT_NE(HDF_SUCCESS, ret); - } - ret = WriteEleValueToBuf(writeBuf, writeElemValue); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = WriteIdToBuf(readBuf, writeElemValue.id); - EXPECT_EQ(HDF_SUCCESS, ret); - - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_WRITE, writeBuf, writeReply); + ret = WriteCtrlInfo(service, elemValue); EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_READ, readBuf, readReply); + ret = ReadCtrlInfo(service, elemValue.id, expectValue); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSbufReadInt32(readReply, &readElemValue.value[0]); - EXPECT_EQ(expectValue, readElemValue.value[0]); - HdfSBufRecycle(writeBuf); - HdfSBufRecycle(readBuf); - HdfSBufRecycle(readReply); HdfIoServiceRecycle(service); } /** @@ -623,40 +441,19 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0010, TestSi int32_t ret = -1; int32_t expectValue = AUDIO_CHANNEL_LEFT_MUTE; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *readBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; - struct HdfSBuf *readReply = nullptr; - struct AudioCtlElemValue writeElemValue = { + service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); + ASSERT_NE(nullptr, service); + ASSERT_NE(nullptr, service->dispatcher); + struct AudioCtlElemValue elemValue = { .id.cardServiceName = "hdf_audio_codec_dev0", .id.iface = AUDIODRV_CTL_ELEM_IFACE_AIAO, .id.itemName = "Render Channel Mode", .value[0] = AUDIO_CHANNEL_LEFT_MUTE, }; - struct AudioCtlElemValue readElemValue = {}; - service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - - ret = ObtainBuf(writeBuf, readBuf, readReply); - if (ret < 0) { - HdfIoServiceRecycle(service); - ASSERT_NE(HDF_SUCCESS, ret); - } - ret = WriteEleValueToBuf(writeBuf, writeElemValue); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = WriteIdToBuf(readBuf, writeElemValue.id); - EXPECT_EQ(HDF_SUCCESS, ret); - - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_WRITE, writeBuf, writeReply); + ret = WriteCtrlInfo(service, elemValue); EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_READ, readBuf, readReply); + ret = ReadCtrlInfo(service, elemValue.id, expectValue); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSbufReadInt32(readReply, &readElemValue.value[0]); - EXPECT_EQ(expectValue, readElemValue.value[0]); - HdfSBufRecycle(writeBuf); - HdfSBufRecycle(readBuf); - HdfSBufRecycle(readReply); HdfIoServiceRecycle(service); } /** @@ -670,40 +467,19 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0011, TestSi int32_t ret = -1; int32_t expectValue = AUDIO_CHANNEL_RIGHT_MUTE; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *readBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; - struct HdfSBuf *readReply = nullptr; - struct AudioCtlElemValue writeElemValue = { + service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); + ASSERT_NE(nullptr, service); + ASSERT_NE(nullptr, service->dispatcher); + struct AudioCtlElemValue elemValue = { .id.cardServiceName = "hdf_audio_codec_dev0", .id.iface = AUDIODRV_CTL_ELEM_IFACE_AIAO, .id.itemName = "Render Channel Mode", .value[0] = AUDIO_CHANNEL_RIGHT_MUTE, }; - struct AudioCtlElemValue readElemValue = {}; - service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - - ret = ObtainBuf(writeBuf, readBuf, readReply); - if (ret < 0) { - HdfIoServiceRecycle(service); - ASSERT_NE(HDF_SUCCESS, ret); - } - ret = WriteEleValueToBuf(writeBuf, writeElemValue); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = WriteIdToBuf(readBuf, writeElemValue.id); - EXPECT_EQ(HDF_SUCCESS, ret); - - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_WRITE, writeBuf, writeReply); + ret = WriteCtrlInfo(service, elemValue); EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_READ, readBuf, readReply); + ret = ReadCtrlInfo(service, elemValue.id, expectValue); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSbufReadInt32(readReply, &readElemValue.value[0]); - EXPECT_EQ(expectValue, readElemValue.value[0]); - HdfSBufRecycle(writeBuf); - HdfSBufRecycle(readBuf); - HdfSBufRecycle(readReply); HdfIoServiceRecycle(service); } /** @@ -717,40 +493,19 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0012, TestSi int32_t ret = -1; int32_t expectValue = AUDIO_CHANNEL_BOTH_MUTE; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *readBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; - struct HdfSBuf *readReply = nullptr; - struct AudioCtlElemValue writeElemValue = { + service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); + ASSERT_NE(nullptr, service); + ASSERT_NE(nullptr, service->dispatcher); + struct AudioCtlElemValue elemValue = { .id.cardServiceName = "hdf_audio_codec_dev0", .id.iface = AUDIODRV_CTL_ELEM_IFACE_AIAO, .id.itemName = "Render Channel Mode", .value[0] = AUDIO_CHANNEL_BOTH_MUTE, }; - struct AudioCtlElemValue readElemValue = {}; - service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - - ret = ObtainBuf(writeBuf, readBuf, readReply); - if (ret < 0) { - HdfIoServiceRecycle(service); - ASSERT_NE(HDF_SUCCESS, ret); - } - ret = WriteEleValueToBuf(writeBuf, writeElemValue); + ret = WriteCtrlInfo(service, elemValue); EXPECT_EQ(HDF_SUCCESS, ret); - ret = WriteIdToBuf(readBuf, writeElemValue.id); + ret = ReadCtrlInfo(service, elemValue.id, expectValue); EXPECT_EQ(HDF_SUCCESS, ret); - - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_WRITE, writeBuf, writeReply); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_READ, readBuf, readReply); - EXPECT_EQ(HDF_SUCCESS, ret); - HdfSbufReadInt32(readReply, &readElemValue.value[0]); - EXPECT_EQ(expectValue, readElemValue.value[0]); - HdfSBufRecycle(writeBuf); - HdfSBufRecycle(readBuf); - HdfSBufRecycle(readReply); HdfIoServiceRecycle(service); } /** @@ -763,9 +518,7 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0013, TestSi { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; - struct AudioCtlElemValue writeElemValue = { + struct AudioCtlElemValue elemValue = { .id.cardServiceName = "hdf_audio_codec_dev0", .id.iface = AUDIODRV_CTL_ELEM_IFACE_AIAO, .id.itemName = "Render Channel Mode", @@ -774,18 +527,8 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0013, TestSi service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); ASSERT_NE(nullptr, service); ASSERT_NE(nullptr, service->dispatcher); - - writeBuf = HdfSBufObtainDefaultSize(); - if (writeBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, writeBuf); - } - ret = WriteEleValueToBuf(writeBuf, writeElemValue); - EXPECT_EQ(HDF_SUCCESS, ret); - - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_WRITE, writeBuf, writeReply); + ret = WriteCtrlInfo(service, elemValue); EXPECT_EQ(HDF_FAILURE, ret); - HdfSBufRecycle(writeBuf); HdfIoServiceRecycle(service); } /** @@ -826,7 +569,7 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_Read_0014, TestSi ret = WriteIdToBuf(readBuf, id); EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_READ, readBuf, readReply); + ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTRL_IOCTRL_ELEM_READ, readBuf, readReply); EXPECT_EQ(HDF_SUCCESS, ret); HdfSbufReadInt32(readReply, &readElemValue.value[0]); EXPECT_EQ(expectMaxValue, readElemValue.value[0]); @@ -838,282 +581,177 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_Read_0014, TestSi HdfIoServiceRecycle(service); } /** -* @tc.name Test the ADM control data which is writing normal value of volume and reading voulme. +* @tc.name Test the ADM control data which is writing normal value of volume and reading volume. * @tc.number SUB_Audio_ControlHostElemWrite_read_0015 -* @tc.desc Test the ADM control data,cmdid is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ. +* @tc.desc Test the ADM control data,cmdid is AUDIODRV_CTRL_IOCTRL_ELEM_WRITE and AUDIODRV_CTRL_IOCTRL_ELEM_READ. * @tc.author: zhouyongxiao */ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0015, TestSize.Level1) { int32_t ret = -1; - int32_t readElemExpectValue = 100; + int32_t expectValue = 100; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *readBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; - struct HdfSBuf *readReply = nullptr; - struct AudioCtlElemValue writeElemValue = {.id.cardServiceName = "hdf_audio_codec_dev0", - .id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC, .id.itemName = "Master Playback Volume", .value[0] = 100 - }; - struct AudioCtlElemValue readElemValue = {}; service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); ASSERT_NE(nullptr, service); ASSERT_NE(nullptr, service->dispatcher); - ret = ObtainBuf(writeBuf, readBuf, readReply); - if (ret < 0) { - HdfIoServiceRecycle(service); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = WriteEleValueToBuf(writeBuf, writeElemValue); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = WriteIdToBuf(readBuf, writeElemValue.id); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_WRITE, writeBuf, writeReply); + struct AudioCtlElemValue elemValue = { + .id.cardServiceName = "hdf_audio_codec_dev0", + .id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC, + .id.itemName = "Master Playback Volume", + .value[0] = 100, + }; + ret = WriteCtrlInfo(service, elemValue); EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_READ, readBuf, readReply); + ret = ReadCtrlInfo(service, elemValue.id, expectValue); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSbufReadInt32(readReply, &readElemValue.value[0]); - EXPECT_EQ(readElemExpectValue, readElemValue.value[0]); - HdfSBufRecycle(writeBuf); - HdfSBufRecycle(readBuf); - HdfSBufRecycle(readReply); HdfIoServiceRecycle(service); } + /** -* @tc.name Test the ADM control data which is writing max value of volume and reading voulme. +* @tc.name Test the ADM control data which is writing mix value of volume and reading volume. * @tc.number SUB_Audio_ControlHostElemWrite_read_0016 -* @tc.desc Test the ADM control data,cmdid is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ. +* @tc.desc Test the ADM control data,cmdid is AUDIODRV_CTRL_IOCTRL_ELEM_WRITE and AUDIODRV_CTRL_IOCTRL_ELEM_READ. * @tc.author: zhouyongxiao */ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0016, TestSize.Level1) { int32_t ret = -1; - int32_t readElemExpectMaxValue = 127; + int32_t expectValue = 40; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *readBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; - struct HdfSBuf *readReply = nullptr; - struct AudioCtlElemValue writeElemValue = {.id.cardServiceName = "hdf_audio_codec_dev0", - .id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC, .id.itemName = "Master Playback Volume", .value[0] = 127 - }; - struct AudioCtlElemValue readElemValue = {}; service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); ASSERT_NE(nullptr, service); ASSERT_NE(nullptr, service->dispatcher); - ret = ObtainBuf(writeBuf, readBuf, readReply); - if (ret < 0) { - HdfIoServiceRecycle(service); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = WriteEleValueToBuf(writeBuf, writeElemValue); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = WriteIdToBuf(readBuf, writeElemValue.id); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_WRITE, writeBuf, writeReply); + struct AudioCtlElemValue elemValue = { + .id.cardServiceName = "hdf_audio_codec_dev0", + .id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC, + .id.itemName = "Master Playback Volume", + .value[0] = 40, + }; + ret = WriteCtrlInfo(service, elemValue); EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_READ, readBuf, readReply); + ret = ReadCtrlInfo(service, elemValue.id, expectValue); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSbufReadInt32(readReply, &readElemValue.value[0]); - EXPECT_EQ(readElemExpectMaxValue, readElemValue.value[0]); - HdfSBufRecycle(writeBuf); - HdfSBufRecycle(readBuf); - HdfSBufRecycle(readReply); HdfIoServiceRecycle(service); } /** -* @tc.name Test the ADM control data which is writing mix value of volume and reading voulme. -* @tc.number SUB_Audio_ControlHostElemWrite_read_0016 -* @tc.desc Test the ADM control data,cmdid is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ. +* @tc.name Test the ADM control data which is writing max value of volume and reading volume. +* @tc.number SUB_Audio_ControlHostElemWrite_read_0017 +* @tc.desc Test the ADM control data,cmdid is AUDIODRV_CTRL_IOCTRL_ELEM_WRITE and AUDIODRV_CTRL_IOCTRL_ELEM_READ. * @tc.author: zhouyongxiao */ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0017, TestSize.Level1) { int32_t ret = -1; - int32_t readElemExpectMinValue = 40; + int32_t expectValue = 127; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *readBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; - struct HdfSBuf *readReply = nullptr; - struct AudioCtlElemValue writeElemValue = {.id.cardServiceName = "hdf_audio_codec_dev0", - .id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC, .id.itemName = "Master Playback Volume", .value[0] = 40 - }; - struct AudioCtlElemValue readElemValue = {}; service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); ASSERT_NE(nullptr, service); ASSERT_NE(nullptr, service->dispatcher); - ret = ObtainBuf(writeBuf, readBuf, readReply); - if (ret < 0) { - HdfIoServiceRecycle(service); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = WriteEleValueToBuf(writeBuf, writeElemValue); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = WriteIdToBuf(readBuf, writeElemValue.id); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_WRITE, writeBuf, writeReply); + struct AudioCtlElemValue elemValue = { + .id.cardServiceName = "hdf_audio_codec_dev0", + .id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC, + .id.itemName = "Master Playback Volume", + .value[0] = 127, + }; + ret = WriteCtrlInfo(service, elemValue); EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_READ, readBuf, readReply); + ret = ReadCtrlInfo(service, elemValue.id, expectValue); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSbufReadInt32(readReply, &readElemValue.value[0]); - EXPECT_EQ(readElemExpectMinValue, readElemValue.value[0]); - HdfSBufRecycle(writeBuf); - HdfSBufRecycle(readBuf); - HdfSBufRecycle(readReply); HdfIoServiceRecycle(service); } /** * @tc.name Test the ADM control data which is writing invlaid value of volume. * @tc.number SUB_Audio_ControlHostElemWrite_read_0018 -* @tc.desc Test the ADM control data,cmdid is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ. +* @tc.desc Test the ADM control data,cmdid is AUDIODRV_CTRL_IOCTRL_ELEM_WRITE and AUDIODRV_CTRL_IOCTRL_ELEM_READ. * @tc.author: zhouyongxiao */ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0018, TestSize.Level1) { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *readBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; - struct HdfSBuf *readReply = nullptr; - struct AudioCtlElemValue writeElemValue = {.id.cardServiceName = "hdf_audio_codec_dev0", - .id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC, .id.itemName = "Master Playback Volume", .value[0] = 128 + struct AudioCtlElemValue elemValue = { + .id.cardServiceName = "hdf_audio_codec_dev0", + .id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC, + .id.itemName = "Master Playback Volume", + .value[0] = 128, }; - service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); ASSERT_NE(nullptr, service); ASSERT_NE(nullptr, service->dispatcher); - ret = ObtainBuf(writeBuf, readBuf, readReply); - if (ret < 0) { - HdfIoServiceRecycle(service); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = WriteEleValueToBuf(writeBuf, writeElemValue); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = WriteIdToBuf(readBuf, writeElemValue.id); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_WRITE, writeBuf, writeReply); + ret = WriteCtrlInfo(service, elemValue); EXPECT_EQ(HDF_FAILURE, ret); - - HdfSBufRecycle(writeBuf); - HdfSBufRecycle(readBuf); - HdfSBufRecycle(readReply); HdfIoServiceRecycle(service); } /** * @tc.name Test the ADM control data which is writing invlaid value of volume. * @tc.number SUB_Audio_ControlHostElemWrite_read_0019 -* @tc.desc Test the ADM control data,cmdid is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ. +* @tc.desc Test the ADM control data,cmdid is AUDIODRV_CTRL_IOCTRL_ELEM_WRITE and AUDIODRV_CTRL_IOCTRL_ELEM_READ. * @tc.author: zhouyongxiao */ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0019, TestSize.Level1) { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *readBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; - struct HdfSBuf *readReply = nullptr; - struct AudioCtlElemValue writeElemValue = {.id.cardServiceName = "hdf_audio_codec_dev0", - .id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC, .id.itemName = "Master Playback Volume", .value[0] = 39 + struct AudioCtlElemValue elemValue = { + .id.cardServiceName = "hdf_audio_codec_dev0", + .id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC, + .id.itemName = "Master Playback Volume", + .value[0] = 39, }; - service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); ASSERT_NE(nullptr, service); ASSERT_NE(nullptr, service->dispatcher); - ret = ObtainBuf(writeBuf, readBuf, readReply); - if (ret < 0) { - HdfIoServiceRecycle(service); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = WriteEleValueToBuf(writeBuf, writeElemValue); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = WriteIdToBuf(readBuf, writeElemValue.id); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_WRITE, writeBuf, writeReply); + ret = WriteCtrlInfo(service, elemValue); EXPECT_EQ(HDF_FAILURE, ret); - - HdfSBufRecycle(writeBuf); - HdfSBufRecycle(readBuf); - HdfSBufRecycle(readReply); HdfIoServiceRecycle(service); } /** * @tc.name Test the ADM control data which is writing normal value of mute and reading mute. * @tc.number SUB_Audio_ControlHostElemWrite_read_0020 -* @tc.desc Test the ADM control data,cmdid is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ. +* @tc.desc Test the ADM control data,cmdid is AUDIODRV_CTRL_IOCTRL_ELEM_WRITE and AUDIODRV_CTRL_IOCTRL_ELEM_READ. * @tc.author: zhouyongxiao */ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0020, TestSize.Level1) { int32_t ret = -1; + int32_t expectValue = 0; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *readBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; - struct HdfSBuf *readReply = nullptr; - struct AudioCtlElemValue writeElemValue = {.id.cardServiceName = "hdf_audio_codec_dev0", - .id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC, .id.itemName = "Playback Mute", .value[0] = 0 - }; - struct AudioCtlElemValue readElemValue = {}; service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); ASSERT_NE(nullptr, service); ASSERT_NE(nullptr, service->dispatcher); - ret = ObtainBuf(writeBuf, readBuf, readReply); - if (ret < 0) { - HdfIoServiceRecycle(service); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = WriteEleValueToBuf(writeBuf, writeElemValue); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = WriteIdToBuf(readBuf, writeElemValue.id); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_WRITE, writeBuf, writeReply); + struct AudioCtlElemValue elemValue = { + .id.cardServiceName = "hdf_audio_codec_dev0", + .id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC, + .id.itemName = "Playback Mute", + .value[0] = 0, + }; + ret = WriteCtrlInfo(service, elemValue); EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_READ, readBuf, readReply); + ret = ReadCtrlInfo(service, elemValue.id, expectValue); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSbufReadInt32(readReply, &readElemValue.value[0]); - EXPECT_EQ(REGISTER_STATUS_ON, readElemValue.value[0]); - HdfSBufRecycle(writeBuf); - HdfSBufRecycle(readBuf); - HdfSBufRecycle(readReply); HdfIoServiceRecycle(service); } /** * @tc.name Test the ADM control data which is writing invalid value of mute,so return -1. * @tc.number SUB_Audio_ControlHostElemWrite_read_0021 -* @tc.desc Test the ADM control data,cmdid is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ. +* @tc.desc Test the ADM control data,cmdid is AUDIODRV_CTRL_IOCTRL_ELEM_WRITE and AUDIODRV_CTRL_IOCTRL_ELEM_READ. * @tc.author: zhouyongxiao */ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0021, TestSize.Level1) { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *readBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; - struct HdfSBuf *readReply = nullptr; - struct AudioCtlElemValue writeElemValue = {.id.cardServiceName = "hdf_audio_codec_dev0", - .id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC, .id.itemName = "Playback Mute", .value[0] = 2, + struct AudioCtlElemValue elemValue = { + .id.cardServiceName = "hdf_audio_codec_dev0", + .id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC, + .id.itemName = "Playback Mute", + .value[0] = 2, }; service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); ASSERT_NE(nullptr, service); ASSERT_NE(nullptr, service->dispatcher); - ret = ObtainBuf(writeBuf, readBuf, readReply); - if (ret < 0) { - HdfIoServiceRecycle(service); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = WriteEleValueToBuf(writeBuf, writeElemValue); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = WriteIdToBuf(readBuf, writeElemValue.id); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTL_IOCTL_ELEM_WRITE, writeBuf, writeReply); + ret = WriteCtrlInfo(service, elemValue); EXPECT_EQ(HDF_FAILURE, ret); - HdfSBufRecycle(writeBuf); - HdfSBufRecycle(readBuf); - HdfSBufRecycle(readReply); HdfIoServiceRecycle(service); } /** @@ -1128,26 +766,13 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0001, TestSize.Leve { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_RENDER_STREAM, .channels = 2, .periodSize = 4096, .rate = 11025, .periodCount = 8, .format = AUDIO_FORMAT_PCM_8_BIT, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .startThreshold = 8190 }; - service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - writeBuf = HdfSBufObtainDefaultSize(); - if (writeBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, writeBuf); - } - ret = WriteHwParamsToBuf(writeBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, writeBuf, writeReply); + ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams); EXPECT_EQ(HDF_FAILURE, ret); - HdfSBufRecycle(writeBuf); HdfIoServiceRecycle(service); } /** @@ -1162,26 +787,13 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0002, TestSize.Leve { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_RENDER_STREAM, .channels = 2, .periodSize = 4096, .rate = 22050, .periodCount = 8, .format = AUDIO_FORMAT_PCM_16_BIT, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .startThreshold = 8190 }; - service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - writeBuf = HdfSBufObtainDefaultSize(); - if (writeBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, writeBuf); - } - ret = WriteHwParamsToBuf(writeBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, writeBuf, writeReply); + ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSBufRecycle(writeBuf); HdfIoServiceRecycle(service); } /** @@ -1196,26 +808,13 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0003, TestSize.Leve { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_RENDER_STREAM, .channels = 2, .periodSize = 16384, .rate = 24000, .periodCount = 16, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .startThreshold = 162140 }; - service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - writeBuf = HdfSBufObtainDefaultSize(); - if (writeBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, writeBuf); - } - ret = WriteHwParamsToBuf(writeBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, writeBuf, writeReply); + ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSBufRecycle(writeBuf); HdfIoServiceRecycle(service); } /** @@ -1230,26 +829,13 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0004, TestSize.Leve { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_RENDER_STREAM, .channels = 2, .periodSize = 4096, .rate = 48190, .periodCount = 8, .format = AUDIO_FORMAT_PCM_32_BIT, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .startThreshold = 8190 }; - service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - writeBuf = HdfSBufObtainDefaultSize(); - if (writeBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, writeBuf); - } - ret = WriteHwParamsToBuf(writeBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, writeBuf, writeReply); + ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams); EXPECT_EQ(HDF_FAILURE, ret); - HdfSBufRecycle(writeBuf); HdfIoServiceRecycle(service); } /** @@ -1264,26 +850,13 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0005, TestSize.Leve { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_RENDER_STREAM, .channels = 2, .periodSize = 4096, .rate = 44100, .periodCount = 8, .format = AUDIO_FORMAT_AAC_MAIN, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .startThreshold = 8190 }; - service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - writeBuf = HdfSBufObtainDefaultSize(); - if (writeBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, writeBuf); - } - ret = WriteHwParamsToBuf(writeBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, writeBuf, writeReply); + ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams); EXPECT_EQ(HDF_FAILURE, ret); - HdfSBufRecycle(writeBuf); HdfIoServiceRecycle(service); } /** @@ -1298,26 +871,13 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0006, TestSize.Leve { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_RENDER_STREAM, .channels = 2, .periodSize = 4096, .rate = 8190, .periodCount = 8, .format = AUDIO_FORMAT_AAC_LC, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .startThreshold = 8190 }; - service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - writeBuf = HdfSBufObtainDefaultSize(); - if (writeBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, writeBuf); - } - ret = WriteHwParamsToBuf(writeBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, writeBuf, writeReply); + ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams); EXPECT_EQ(HDF_FAILURE, ret); - HdfSBufRecycle(writeBuf); HdfIoServiceRecycle(service); } /** @@ -1332,26 +892,13 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0007, TestSize.Leve { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_RENDER_STREAM, .channels = 2, .periodSize = 4096, .rate = 32000, .periodCount = 8, .format = AUDIO_FORMAT_AAC_LD, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .startThreshold = 8190 }; - service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - writeBuf = HdfSBufObtainDefaultSize(); - if (writeBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, writeBuf); - } - ret = WriteHwParamsToBuf(writeBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, writeBuf, writeReply); + ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams); EXPECT_EQ(HDF_FAILURE, ret); - HdfSBufRecycle(writeBuf); HdfIoServiceRecycle(service); } /** @@ -1366,26 +913,13 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0008, TestSize.Leve { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_RENDER_STREAM, .channels = 2, .periodSize = 4096, .rate = 50000, .periodCount = 8, .format = AUDIO_FORMAT_AAC_ELD, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .startThreshold = 8190 }; - service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - writeBuf = HdfSBufObtainDefaultSize(); - if (writeBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, writeBuf); - } - ret = WriteHwParamsToBuf(writeBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, writeBuf, writeReply); + ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams); EXPECT_EQ(HDF_FAILURE, ret); - HdfSBufRecycle(writeBuf); HdfIoServiceRecycle(service); } /** @@ -1400,26 +934,13 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0009, TestSize.Leve { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_RENDER_STREAM, .channels = 2, .periodSize = 4096, .rate = 47250, .periodCount = 8, .format = AUDIO_FORMAT_AAC_HE_V1, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .startThreshold = 8190 }; - service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - writeBuf = HdfSBufObtainDefaultSize(); - if (writeBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, writeBuf); - } - ret = WriteHwParamsToBuf(writeBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, writeBuf, writeReply); + ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams); EXPECT_EQ(HDF_FAILURE, ret); - HdfSBufRecycle(writeBuf); HdfIoServiceRecycle(service); } /** @@ -1434,428 +955,238 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0010, TestSize.Leve { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_RENDER_STREAM, .channels = 2, .periodSize = 4096, .rate = 47250, .periodCount = 8, .format = AUDIO_FORMAT_AAC_HE_V2, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .startThreshold = 8190 }; - service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - writeBuf = HdfSBufObtainDefaultSize(); - if (writeBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, writeBuf); - } - ret = WriteHwParamsToBuf(writeBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, writeBuf, writeReply); + ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams); EXPECT_EQ(HDF_FAILURE, ret); - HdfSBufRecycle(writeBuf); - HdfIoServiceRecycle(service); -} -/** -* @tc.name Test the ADM render stream data,cmdid is AUDIO_DRV_PCM_IOCTRL_HW_PARAMS that -* cardServiceName is hdf_audio_smartpa_dev0. -* @tc.number SUB_Audio_StreamHostHwParams_0011 -* @tc.desc Test the ADM render stream data which is issuing hardware parameters that -* format is AUDIO_FORMAT_PCM_16_BIT 、channels is 2、cardServiceName is hdf_audio_smartpa_dev0. -* @tc.author: zhouyongxiao -*/ -HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0011, TestSize.Level1) -{ - int32_t ret = -1; - struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; - struct AudioPcmHwParams hwParams { - .streamType = AUDIO_RENDER_STREAM, .channels = 2, .periodSize = 4096, .rate = 48000, - .periodCount = 32, .format = AUDIO_FORMAT_PCM_16_BIT, .cardServiceName = "hdf_audio_smartpa_dev0", - .isBigEndian = 0, .isSignedData = 1, .startThreshold = 32767 - }; - service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - writeBuf = HdfSBufObtainDefaultSize(); - if (writeBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, writeBuf); - } - ret = WriteHwParamsToBuf(writeBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, writeBuf, writeReply); - EXPECT_EQ(HDF_SUCCESS, ret); - HdfSBufRecycle(writeBuf); HdfIoServiceRecycle(service); } /** * @tc.name Test the ADM capture stream data,cmdid is AUDIO_DRV_PCM_IOCTRL_HW_PARAMS that * format is AUDIO_FORMAT_PCM_24_BIT. -* @tc.number SUB_Audio_StreamHostHwParams_0012 +* @tc.number SUB_Audio_StreamHostHwParams_0011 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that * format is AUDIO_FORMAT_PCM_24_BIT 、channels is 2、cardServiceName is hdf_audio_codec_dev0. * @tc.author: zhouyongxiao */ -HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0012, TestSize.Level1) +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0011, TestSize.Level1) { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_CAPTURE_STREAM, .channels = 2, .periodSize = 8192, .rate = 11025, .periodCount = 32, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384 }; - service = HdfIoServiceBind(HDF_CAPTURE_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - writeBuf = HdfSBufObtainDefaultSize(); - if (writeBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, writeBuf); - } - ret = WriteHwParamsToBuf(writeBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, writeBuf, writeReply); + ret = WriteHwParams(HDF_CAPTURE_SERVICE, service, hwParams); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSBufRecycle(writeBuf); HdfIoServiceRecycle(service); } /** * @tc.name Test the ADM render stream data,cmdid is AUDIO_DRV_PCM_IOCTRL_HW_PARAMS * that format is channels is 1. -* @tc.number SUB_Audio_StreamHostHwParams_0013 +* @tc.number SUB_Audio_StreamHostHwParams_0012 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that * format is AUDIO_FORMAT_PCM_24_BIT 、channels is 2、cardServiceName is hdf_audio_codec_dev0. * @tc.author: zhouyongxiao */ -HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0013, TestSize.Level1) +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0012, TestSize.Level1) { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_RENDER_STREAM, .channels = 1, .periodSize = 4096, .rate = 24000, .periodCount = 16, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .startThreshold = 16384 }; - service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - writeBuf = HdfSBufObtainDefaultSize(); - if (writeBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, writeBuf); - } - ret = WriteHwParamsToBuf(writeBuf, hwParams); + ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams); EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, writeBuf, writeReply); - EXPECT_EQ(HDF_SUCCESS, ret); - HdfSBufRecycle(writeBuf); HdfIoServiceRecycle(service); } /** * @tc.name Test the ADM render stream data,cmdid is AUDIO_DRV_PCM_IOCTRL_HW_PARAMS that format is channels is 8. -* @tc.number SUB_Audio_StreamHostHwParams_0014 +* @tc.number SUB_Audio_StreamHostHwParams_0013 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that * format is AUDIO_FORMAT_PCM_8_BIT 、channels is 8、cardServiceName is hdf_audio_codec_dev0. * @tc.author: zhouyongxiao */ -HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0014, TestSize.Level1) +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0013, TestSize.Level1) { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_RENDER_STREAM, .channels = 8, .periodSize = 4096, .rate = 48000, .periodCount = 8, .format = AUDIO_FORMAT_PCM_8_BIT, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .startThreshold = 32766 }; - service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - writeBuf = HdfSBufObtainDefaultSize(); - if (writeBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, writeBuf); - } - ret = WriteHwParamsToBuf(writeBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, writeBuf, writeReply); + ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams); EXPECT_EQ(HDF_FAILURE, ret); - HdfSBufRecycle(writeBuf); HdfIoServiceRecycle(service); } /** * @tc.name Test the ADM render stream data,cmdid is AUDIO_DRV_PCM_IOCTRL_HW_PARAMS that format is periodSize is 4095. -* @tc.number SUB_Audio_StreamHostHwParams_0015 +* @tc.number SUB_Audio_StreamHostHwParams_0014 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that * format is AUDIO_FORMAT_PCM_8_BIT 、channels is 8、cardServiceName is hdf_audio_codec_dev0. * @tc.author: zhouyongxiao */ -HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0015, TestSize.Level1) +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0014, TestSize.Level1) { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_RENDER_STREAM, .channels = 2, .periodSize = 4095, .rate = 48000, .periodCount = 8, .format = AUDIO_FORMAT_PCM_8_BIT, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .startThreshold = 32766 }; - service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - writeBuf = HdfSBufObtainDefaultSize(); - if (writeBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, writeBuf); - } - ret = WriteHwParamsToBuf(writeBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, writeBuf, writeReply); + ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams); EXPECT_EQ(HDF_FAILURE, ret); - HdfSBufRecycle(writeBuf); HdfIoServiceRecycle(service); } /** * @tc.name Test the ADM render stream data,cmdid is AUDIO_DRV_PCM_IOCTRL_HW_PARAMS that format is periodSize is 16385(16 * 1024) -* @tc.number SUB_Audio_StreamHostHwParams_0016 +* @tc.number SUB_Audio_StreamHostHwParams_0015 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that * format is AUDIO_FORMAT_PCM_8_BIT 、channels is 8、cardServiceName is hdf_audio_codec_dev0. * @tc.author: zhouyongxiao */ -HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0016, TestSize.Level1) +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0015, TestSize.Level1) { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_RENDER_STREAM, .channels = 2, .periodSize = 16384, .rate = 48000, .periodCount = 8, .format = AUDIO_FORMAT_PCM_8_BIT, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .startThreshold = 32766 }; - service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - writeBuf = HdfSBufObtainDefaultSize(); - if (writeBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, writeBuf); - } - ret = WriteHwParamsToBuf(writeBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, writeBuf, writeReply); + ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams); EXPECT_EQ(HDF_FAILURE, ret); - HdfSBufRecycle(writeBuf); HdfIoServiceRecycle(service); } /** * @tc.name Test the ADM render stream data,cmdid is AUDIO_DRV_PCM_IOCTRL_HW_PARAMS that format is periodCount is 7. -* @tc.number SUB_Audio_StreamHostHwParams_0017 +* @tc.number SUB_Audio_StreamHostHwParams_0016 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that * format is AUDIO_FORMAT_PCM_8_BIT 、channels is 8、cardServiceName is hdf_audio_codec_dev0. * @tc.author: zhouyongxiao */ -HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0017, TestSize.Level1) +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0016, TestSize.Level1) { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_RENDER_STREAM, .channels = 2, .periodSize = 4096, .rate = 24000, .periodCount = 7, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .startThreshold = 16384 }; - service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - writeBuf = HdfSBufObtainDefaultSize(); - if (writeBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, writeBuf); - } - ret = WriteHwParamsToBuf(writeBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, writeBuf, writeReply); + ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams); EXPECT_EQ(HDF_FAILURE, ret); - HdfSBufRecycle(writeBuf); HdfIoServiceRecycle(service); } /** * @tc.name Test the ADM render stream data,cmdid is AUDIO_DRV_PCM_IOCTRL_HW_PARAMS that periodCount is 33. -* @tc.number SUB_Audio_StreamHostHwParams_0018 +* @tc.number SUB_Audio_StreamHostHwParams_0017 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that * format is AUDIO_FORMAT_PCM_8_BIT 、channels is 8、cardServiceName is hdf_audio_codec_dev0. * @tc.author: zhouyongxiao */ -HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0018, TestSize.Level1) +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0017, TestSize.Level1) { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_RENDER_STREAM, .channels = 2, .periodSize = 4096, .rate = 24000, .periodCount = 33, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .startThreshold = 16384 }; - service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - writeBuf = HdfSBufObtainDefaultSize(); - if (writeBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, writeBuf); - } - ret = WriteHwParamsToBuf(writeBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, writeBuf, writeReply); + ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams); EXPECT_EQ(HDF_FAILURE, ret); - HdfSBufRecycle(writeBuf); HdfIoServiceRecycle(service); } /** * @tc.name Test the ADM render stream data,cmdid is AUDIO_DRV_PCM_IOCTRL_HW_PARAMS that startThreshold is Over value. -* @tc.number SUB_Audio_StreamHostHwParams_0019 +* @tc.number SUB_Audio_StreamHostHwParams_0018 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that * format is AUDIO_FORMAT_PCM_8_BIT 、channels is 8、cardServiceName is hdf_audio_codec_dev0. * @tc.author: zhouyongxiao */ -HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0019, TestSize.Level1) +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0018, TestSize.Level1) { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_RENDER_STREAM, .channels = 2, .periodSize = 4096, .rate = 24000, .periodCount = 8, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .startThreshold = 8193 }; - service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - writeBuf = HdfSBufObtainDefaultSize(); - if (writeBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, writeBuf); - } - ret = WriteHwParamsToBuf(writeBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, writeBuf, writeReply); + ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSBufRecycle(writeBuf); HdfIoServiceRecycle(service); } /** * @tc.name Test the ADM render stream data,cmdid is AUDIO_DRV_PCM_IOCTRL_HW_PARAMS that startThreshold is 0. -* @tc.number SUB_Audio_StreamHostHwParams_0020 +* @tc.number SUB_Audio_StreamHostHwParams_0019 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that * format is AUDIO_FORMAT_PCM_8_BIT 、channels is 8、cardServiceName is hdf_audio_codec_dev0. * @tc.author: zhouyongxiao */ -HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0020, TestSize.Level1) +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0019, TestSize.Level1) { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_RENDER_STREAM, .channels = 2, .periodSize = 4096, .rate = 24000, - .periodCount = 8, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = "hdf_audio_codec_dev0", - .isBigEndian = 0, .isSignedData = 1, .startThreshold = 0 - }; - service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - writeBuf = HdfSBufObtainDefaultSize(); - if (writeBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, writeBuf); - } - ret = WriteHwParamsToBuf(writeBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, writeBuf, writeReply); + .periodCount = 8, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = "hdf_audio_codec_dev0", + .isBigEndian = 0, .isSignedData = 1, .startThreshold = 0 + }; + ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSBufRecycle(writeBuf); HdfIoServiceRecycle(service); } /** * @tc.name Test the ADM capture stream data,cmdid is AUDIO_DRV_PCM_IOCTRL_HW_PARAMS that * silenceThreshold is Less than minimum. -* @tc.number SUB_Audio_StreamHostHwParams_0021 +* @tc.number SUB_Audio_StreamHostHwParams_0020 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that * format is AUDIO_FORMAT_PCM_24_BIT 、channels is 2、cardServiceName is hdf_audio_codec_dev0. * @tc.author: zhouyongxiao */ -HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0021, TestSize.Level1) +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0020, TestSize.Level1) { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_CAPTURE_STREAM, .channels = 2, .periodSize = 8192, .rate = 11025, .periodCount = 32, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 8191 }; - service = HdfIoServiceBind(HDF_CAPTURE_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - writeBuf = HdfSBufObtainDefaultSize(); - if (writeBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, writeBuf); - } - ret = WriteHwParamsToBuf(writeBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, writeBuf, writeReply); + ret = WriteHwParams(HDF_CAPTURE_SERVICE, service, hwParams); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSBufRecycle(writeBuf); HdfIoServiceRecycle(service); } /** * @tc.name Test the ADM capture stream data,cmdid is AUDIO_DRV_PCM_IOCTRL_HW_PARAMS that * silenceThreshold is Greater than maximum. -* @tc.number SUB_Audio_StreamHostHwParams_0022 +* @tc.number SUB_Audio_StreamHostHwParams_0021 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that * format is AUDIO_FORMAT_PCM_24_BIT 、channels is 2、cardServiceName is hdf_audio_codec_dev0. * @tc.author: zhouyongxiao */ -HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0022, TestSize.Level1) +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0021, TestSize.Level1) { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_CAPTURE_STREAM, .channels = 2, .periodSize = 8192, .rate = 11025, .periodCount = 32, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16385 }; - service = HdfIoServiceBind(HDF_CAPTURE_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - writeBuf = HdfSBufObtainDefaultSize(); - if (writeBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, writeBuf); - } - ret = WriteHwParamsToBuf(writeBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, writeBuf, writeReply); - EXPECT_EQ(HDF_SUCCESS, ret); - HdfSBufRecycle(writeBuf); + ret = WriteHwParams(HDF_CAPTURE_SERVICE, service, hwParams); + EXPECT_EQ(HDF_FAILURE, ret); HdfIoServiceRecycle(service); } /** @@ -1868,37 +1199,29 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostWrite_0001, TestSize.Level1) { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; struct HdfSBuf *sBufT = nullptr; struct HdfSBuf *reply = nullptr; - struct AudioXferi transfer; struct AudioPcmHwParams hwParams { .streamType = AUDIO_RENDER_STREAM, .channels = 2, .periodSize = 8192, .rate = 11025, .periodCount = 8, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384 }; - service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - writeBuf = HdfSBufObtainDefaultSize(); - if (writeBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, writeBuf); - } - ret = WriteHwParamsToBuf(writeBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = WriteFrameToSBuf(sBufT, transfer.buf, transfer.bufsize, transfer.frameSize, AUDIO_FILE_PATH); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, writeBuf, writeReply); + + ret = WriteFrameToSBuf(sBufT, AUDIO_FILE); EXPECT_EQ(HDF_SUCCESS, ret); + ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams); + if (ret < 0) { + HdfSBufRecycle(sBufT); + ASSERT_EQ(HDF_SUCCESS, ret); + } ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PREPARE, nullptr, nullptr); EXPECT_EQ(HDF_SUCCESS, ret); ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_WRITE, sBufT, reply); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSBufRecycle(writeBuf); - HdfIoServiceRecycle(service); + ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, nullptr, nullptr); + EXPECT_EQ(HDF_SUCCESS, ret); HdfSBufRecycle(sBufT); + HdfIoServiceRecycle(service); } /** * @tc.name Test the ADM stream data which is recording data stream. @@ -1910,9 +1233,7 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostRead_0001, TestSize.Level1) { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *writeBuf = nullptr; - struct HdfSBuf *writeReply = nullptr; - struct HdfSBuf *reply = NULL; + struct HdfSBuf *reply = nullptr; uint32_t readSize = 0; struct AudioXferi transfer; struct AudioPcmHwParams hwParams { @@ -1920,37 +1241,25 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostRead_0001, TestSize.Level1) .periodCount = 8, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384 }; - service = HdfIoServiceBind(HDF_CAPTURE_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); reply = HdfSBufObtainDefaultSize(); if (reply == nullptr) { - HdfIoServiceRecycle(service); ASSERT_NE(nullptr, reply); } - writeBuf = HdfSBufObtainDefaultSize(); - if (writeBuf == nullptr) { - HdfSBufRecycle(reply); - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, writeBuf); - } - ret = WriteHwParamsToBuf(writeBuf, hwParams); + ret = WriteHwParams(HDF_CAPTURE_SERVICE, service, hwParams); if (ret < 0) { - HdfIoServiceRecycle(service); - ASSERT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(reply); + ASSERT_EQ(HDF_SUCCESS, ret); } - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, writeBuf, writeReply); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PREPARE, nullptr, nullptr); EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_READ, NULL, reply); + ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_READ, nullptr, reply); EXPECT_EQ(HDF_SUCCESS, ret); ret = HdfSbufReadBuffer(reply, (const void **) & (transfer.buf), &readSize); EXPECT_NE(transfer.buf, nullptr); EXPECT_NE(readSize, (uint32_t)0); + ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, nullptr, nullptr); + EXPECT_EQ(HDF_SUCCESS, ret); HdfSBufRecycle(reply); - HdfSBufRecycle(writeBuf); HdfIoServiceRecycle(service); } /** @@ -1963,33 +1272,16 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostRenderPrepare_0001, TestSize { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *sBuf = nullptr; - struct HdfSBuf *reply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_RENDER_STREAM, .channels = 2, .periodSize = 8192, .rate = 11025, .periodCount = 8, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16385 }; - - service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - - sBuf = HdfSBufObtainDefaultSize(); - if (sBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, sBuf); - } - ret = WriteHwParamsToBuf(sBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, sBuf, reply); + ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams); ASSERT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PREPARE, nullptr, nullptr); - ASSERT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, nullptr, nullptr); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSBufRecycle(sBuf); + ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, nullptr, nullptr); HdfIoServiceRecycle(service); } @@ -2003,33 +1295,17 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostCapturePrepare_0001, TestSiz { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *sBuf = nullptr; - struct HdfSBuf *reply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_CAPTURE_STREAM, .channels = 2, .periodSize = 8192, .rate = 11025, .periodCount = 8, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384 }; - - service = HdfIoServiceBind(HDF_CAPTURE_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - - sBuf = HdfSBufObtainDefaultSize(); - if (sBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, sBuf); - } - ret = WriteHwParamsToBuf(sBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, sBuf, reply); + ret = WriteHwParams(HDF_CAPTURE_SERVICE, service, hwParams); ASSERT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PREPARE, nullptr, nullptr); - ASSERT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_STOP, nullptr, nullptr); + ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PREPARE, nullptr, nullptr); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSBufRecycle(sBuf); + ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, nullptr, nullptr); HdfIoServiceRecycle(service); } /** @@ -2042,36 +1318,19 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_StreamHostRenderStart_0001, TestSize.Level1) { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *sBuf = nullptr; - struct HdfSBuf *reply = nullptr; - struct AudioPcmHwParams hwParams { + struct AudioPcmHwParams hwParams { .streamType = AUDIO_RENDER_STREAM, .channels = 2, .periodSize = 8192, .rate = 11025, .periodCount = 8, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384 }; - - service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - - sBuf = HdfSBufObtainDefaultSize(); - if (sBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, sBuf); - } - ret = WriteHwParamsToBuf(sBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, sBuf, reply); + ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams); ASSERT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PREPARE, nullptr, nullptr); - ASSERT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(HDF_SUCCESS, ret); ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_START, nullptr, nullptr); EXPECT_EQ(HDF_SUCCESS, ret); ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, nullptr, nullptr); EXPECT_EQ(HDF_SUCCESS, ret); - - HdfSBufRecycle(sBuf); HdfIoServiceRecycle(service); } /** @@ -2084,35 +1343,19 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_StreamHostCaptureStart_0001, TestSize.Level1 { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *sBuf = nullptr; - struct HdfSBuf *reply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_CAPTURE_STREAM, .channels = 2, .periodSize = 8192, .rate = 11025, .periodCount = 8, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384 }; - - service = HdfIoServiceBind(HDF_CAPTURE_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - - sBuf = HdfSBufObtainDefaultSize(); - if (sBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, sBuf); - } - ret = WriteHwParamsToBuf(sBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, sBuf, reply); + ret = WriteHwParams(HDF_CAPTURE_SERVICE, service, hwParams); ASSERT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PREPARE, nullptr, nullptr); - ASSERT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(HDF_SUCCESS, ret); ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_START, nullptr, nullptr); EXPECT_EQ(HDF_SUCCESS, ret); ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_STOP, nullptr, nullptr); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSBufRecycle(sBuf); HdfIoServiceRecycle(service); } /** @@ -2125,33 +1368,17 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostRenderStop_0001, TestSize.Le { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *sBuf = nullptr; - struct HdfSBuf *reply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_RENDER_STREAM, .channels = 2, .periodSize = 8192, .rate = 44100, .periodCount = 8, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384 }; - - service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - - sBuf = HdfSBufObtainDefaultSize(); - if (sBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, sBuf); - } - ret = WriteHwParamsToBuf(sBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, sBuf, reply); + ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams); ASSERT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PREPARE, nullptr, nullptr); - ASSERT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(HDF_SUCCESS, ret); ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, nullptr, nullptr); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSBufRecycle(sBuf); HdfIoServiceRecycle(service); } /** @@ -2164,33 +1391,17 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostCaptureStop_0001, TestSize.L { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *sBuf = nullptr; - struct HdfSBuf *reply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_CAPTURE_STREAM, .channels = 2, .periodSize = 8192, .rate = 44100, .periodCount = 8, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384 }; - - service = HdfIoServiceBind(HDF_CAPTURE_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - - sBuf = HdfSBufObtainDefaultSize(); - if (sBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, sBuf); - } - ret = WriteHwParamsToBuf(sBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, sBuf, reply); + ret = WriteHwParams(HDF_CAPTURE_SERVICE, service, hwParams); ASSERT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PREPARE, nullptr, nullptr); - ASSERT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(HDF_SUCCESS, ret); ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_STOP, nullptr, nullptr); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSBufRecycle(sBuf); HdfIoServiceRecycle(service); } /** @@ -2203,37 +1414,21 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostRenderPause_0001, TestSize.L { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *sBuf = nullptr; - struct HdfSBuf *reply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_RENDER_STREAM, .channels = 2, .periodSize = 8192, .rate = 11025, .periodCount = 8, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384 }; - - service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - - sBuf = HdfSBufObtainDefaultSize(); - if (sBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, sBuf); - } - ret = WriteHwParamsToBuf(sBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, sBuf, reply); + ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams); ASSERT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PREPARE, nullptr, nullptr); - ASSERT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(HDF_SUCCESS, ret); ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_START, nullptr, nullptr); EXPECT_EQ(HDF_SUCCESS, ret); ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PAUSE, nullptr, nullptr); EXPECT_EQ(HDF_SUCCESS, ret); ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, nullptr, nullptr); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSBufRecycle(sBuf); HdfIoServiceRecycle(service); } /** @@ -2246,37 +1441,21 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostCapturePause_0001, TestSize. { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *sBuf = nullptr; - struct HdfSBuf *reply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_CAPTURE_STREAM, .channels = 2, .periodSize = 8192, .rate = 11025, .periodCount = 8, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384 }; - - service = HdfIoServiceBind(HDF_CAPTURE_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - - sBuf = HdfSBufObtainDefaultSize(); - if (sBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, sBuf); - } - ret = WriteHwParamsToBuf(sBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, sBuf, reply); + ret = WriteHwParams(HDF_CAPTURE_SERVICE, service, hwParams); ASSERT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PREPARE, nullptr, nullptr); - ASSERT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(HDF_SUCCESS, ret); ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_START, nullptr, nullptr); EXPECT_EQ(HDF_SUCCESS, ret); ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PAUSE, nullptr, nullptr); EXPECT_EQ(HDF_SUCCESS, ret); ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_STOP, nullptr, nullptr); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSBufRecycle(sBuf); HdfIoServiceRecycle(service); } /** @@ -2289,30 +1468,15 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostRenderResume_0001, TestSize. { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *sBuf = nullptr; - struct HdfSBuf *reply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_RENDER_STREAM, .channels = 2, .periodSize = 8192, .rate = 11025, .periodCount = 8, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384 }; - - service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - - sBuf = HdfSBufObtainDefaultSize(); - if (sBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, sBuf); - } - ret = WriteHwParamsToBuf(sBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, sBuf, reply); + ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams); ASSERT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PREPARE, nullptr, nullptr); - ASSERT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(HDF_SUCCESS, ret); ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_START, nullptr, nullptr); EXPECT_EQ(HDF_SUCCESS, ret); ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PAUSE, nullptr, nullptr); @@ -2321,7 +1485,6 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostRenderResume_0001, TestSize. EXPECT_EQ(HDF_SUCCESS, ret); ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, nullptr, nullptr); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSBufRecycle(sBuf); HdfIoServiceRecycle(service); } /** @@ -2334,30 +1497,15 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostCaptureResume_0001, TestSize { int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *sBuf = nullptr; - struct HdfSBuf *reply = nullptr; struct AudioPcmHwParams hwParams { .streamType = AUDIO_CAPTURE_STREAM, .channels = 2, .periodSize = 8192, .rate = 11025, .periodCount = 8, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = "hdf_audio_codec_dev0", .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384 }; - - service = HdfIoServiceBind(HDF_CAPTURE_SERVICE.c_str()); - ASSERT_NE(nullptr, service); - ASSERT_NE(nullptr, service->dispatcher); - - sBuf = HdfSBufObtainDefaultSize(); - if (sBuf == nullptr) { - HdfIoServiceRecycle(service); - ASSERT_NE(nullptr, sBuf); - } - ret = WriteHwParamsToBuf(sBuf, hwParams); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, sBuf, reply); + ret = WriteHwParams(HDF_CAPTURE_SERVICE, service, hwParams); ASSERT_EQ(HDF_SUCCESS, ret); - ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PREPARE, nullptr, nullptr); - ASSERT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(HDF_SUCCESS, ret); ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_START, nullptr, nullptr); EXPECT_EQ(HDF_SUCCESS, ret); ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PAUSE, nullptr, nullptr); @@ -2366,7 +1514,6 @@ HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostCaptureResume_0001, TestSize EXPECT_EQ(HDF_SUCCESS, ret); ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_STOP, nullptr, nullptr); EXPECT_EQ(HDF_SUCCESS, ret); - HdfSBufRecycle(sBuf); HdfIoServiceRecycle(service); } } \ No newline at end of file diff --git a/audio/test/systemtest/adm_interface_lib/BUILD.gn b/audio/test/systemtest/adm_interface_lib/BUILD.gn index 8411bdef0d..87ef6296d0 100755 --- a/audio/test/systemtest/adm_interface_lib/BUILD.gn +++ b/audio/test/systemtest/adm_interface_lib/BUILD.gn @@ -11,15 +11,21 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build/test.gni") -import("//drivers/adapter/uhdf2/uhdf.gni") +if (defined(ohos_lite)) { + import("//build/lite/config/test.gni") +} else { + import("//build/test.gni") + import("//drivers/adapter/uhdf2/uhdf.gni") +} ###########################end########################### group("lib") { - testonly = true + if (!defined(ohos_lite)) { + testonly = true + } deps = [] deps += [ - "render:AudioLibRenderTest", - "capture:AudioLibCaptureTest", + "render:hdf_audio_lib_render_test", + "capture:hdf_audio_lib_capture_test", ] } \ No newline at end of file diff --git a/audio/test/systemtest/adm_interface_lib/capture/BUILD.gn b/audio/test/systemtest/adm_interface_lib/capture/BUILD.gn index 9b51862e10..6433a68b2f 100755 --- a/audio/test/systemtest/adm_interface_lib/capture/BUILD.gn +++ b/audio/test/systemtest/adm_interface_lib/capture/BUILD.gn @@ -11,49 +11,122 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build/test.gni") -import("//drivers/adapter/uhdf2/uhdf.gni") +if (defined(ohos_lite)) { + import("//build/lite/config/test.gni") +} else { + import("//build/test.gni") + import("//drivers/adapter/uhdf2/uhdf.gni") + import("//drivers/peripheral/audio/audio.gni") +} + +if (defined(ohos_lite)) { +###########################LITEOS########################################## +###########################hdf_audio_lib_capture_test########################### + unittest("hdf_audio_lib_capture_test") { + sources = [ + "src/audio_libcapture_test.cpp", + "../../common/lib_common/src/audio_lib_common.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] + + include_dirs = [ + "//drivers/peripheral/audio/supportlibs/adm_adapter/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/include", + "//drivers/framework/core/sec/include", + "//drivers/framework/core/shared/include", + "//drivers/framework/core/host/include", + "//drivers/framework/core/manager/include", + "//drivers/framework/core/common/include/host/", + "//third_party/bounds_checking_function/include", + "//drivers/adapter/khdf/liteos/osal/include", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/adapter/uhdf2/include/hdi/", + "//drivers/peripheral/audio/test/systemtest/common/lib_common/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//drivers/peripheral/audio/test/systemtest/adm_interface_lib/capture/include", + "//third_party/googletest/googletest/include/gtest", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + "-std=c++11" + ] -module_output_path = "hdf/audio/systemtest/lib" -###########################systemtest############################## -###########################AudioLibCaptureTest########################### -ohos_systemtest("AudioLibCaptureTest") { - module_out_path = module_output_path - sources = [ - "src/audio_libcapture_test.cpp", - "../../common/lib_common/src/audio_lib_common.cpp" - ] + deps = [ + "//third_party/bounds_checking_function:libsec_shared" + ] + } +} else { + module_output_path = "hdf/audio" + ###########################hdf_audio_lib_capture_test########################### + ohos_systemtest("hdf_audio_lib_capture_test") { + module_out_path = module_output_path + sources = [ + "src/audio_libcapture_test.cpp", + "../../common/lib_common/src/audio_lib_common.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] - include_dirs = [ - "//drivers/peripheral/audio/supportlibs/adm_adapter/include", - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/interfaces/include", - "//drivers/framework/include/core", - "//drivers/framework/include/utils", - "//drivers/framework/include/osal", - "//drivers/framework/include", - "//utils/native/base/include", - "//third_party/bounds_checking_function/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/framework/utils/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/adapter/uhdf2/osal/include", - "//drivers/peripheral/audio/test/systemtest/common/lib_common/include", - "//drivers/peripheral/audio/test/systemtest/adm_interface_lib/capture/include", - "//third_party/googletest/googletest/include/gtest", - ] - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - ] - deps = [ - "//utils/native/base:utils", - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - ] + include_dirs = [ + "//drivers/peripheral/audio/supportlibs/adm_adapter/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/include", + "//utils/native/base/include", + "//third_party/bounds_checking_function/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/adapter/uhdf2/osal/include", + "//drivers/peripheral/audio/test/systemtest/common/lib_common/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//drivers/peripheral/audio/test/systemtest/adm_interface_lib/capture/include", + "//third_party/googletest/googletest/include/gtest", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + deps = [ + "//utils/native/base:utils", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + defines = [] + if (enable_audio_adm_so) { + defines += [ "AUDIO_ADM_SO" ] + } + if (enable_audio_mpi_so) { + defines += [ "AUDIO_MPI_SO" ] + } + if (enable_audio_adm_service) { + defines += [ "AUDIO_ADM_SERVICE" ] + } + if (enable_audio_mpi_service) { + defines += [ "AUDIO_MPI_SERVICE" ] + } + } } ###########################end########################### \ No newline at end of file diff --git a/audio/test/systemtest/adm_interface_lib/capture/src/audio_libcapture_test.cpp b/audio/test/systemtest/adm_interface_lib/capture/src/audio_libcapture_test.cpp index c0031f34e7..aeea79b4f5 100755 --- a/audio/test/systemtest/adm_interface_lib/capture/src/audio_libcapture_test.cpp +++ b/audio/test/systemtest/adm_interface_lib/capture/src/audio_libcapture_test.cpp @@ -43,8 +43,7 @@ namespace { const string BIND_CONTROL = "control"; const string BIND_CAPTURE = "capture"; const string BIND_NAME_ERROR = "rendeo"; -const string CAPUTRE_PATH = "//bin/ceshi.wav"; -const string ADAPTER_NAME3 = "internal"; +const string ADAPTER_NAME_INTERNAL = "internal"; class AudioLibCaptureTest : public testing::Test { public: @@ -52,24 +51,37 @@ public: static void TearDownTestCase(void); void SetUp(); void TearDown(); - struct DevHandle *(*BindServiceCaptureSo)(const char *) = nullptr; - int32_t (*InterfaceLibOutputCapture)(struct DevHandle *, int, struct AudioHwCaptureParam *) = nullptr; - int32_t (*InterfaceLibCtlCapture)(struct DevHandle *, int, struct AudioHwCaptureParam *) = nullptr; - void (*CloseServiceCaptureSo)(struct DevHandle *) = nullptr; - void *PtrHandle = nullptr; + static struct DevHandle *(*BindServiceCaptureSo)(const char *); + static int32_t (*InterfaceLibOutputCapture)(struct DevHandle *, int, struct AudioHwCaptureParam *); + static int32_t (*InterfaceLibCtlCapture)(struct DevHandle *, int, struct AudioHwCaptureParam *); + static void (*CloseServiceCaptureSo)(struct DevHandle *); +#ifdef AUDIO_MPI_SO + static int32_t (*SdkInit)(); + static void (*SdkExit)(); +#endif + static void *PtrHandle; + int32_t BindServiceAndHwCapture(struct AudioHwCapture *&hwCapture, const std::string BindName, + const std::string adapterNameCase, struct DevHandle *&handle) const; }; -void AudioLibCaptureTest::SetUpTestCase(void) -{ -} +struct DevHandle *(*AudioLibCaptureTest::BindServiceCaptureSo)(const char *) = nullptr; +int32_t (*AudioLibCaptureTest::InterfaceLibOutputCapture)(struct DevHandle *, int, + struct AudioHwCaptureParam *) = nullptr; +int32_t (*AudioLibCaptureTest::InterfaceLibCtlCapture)(struct DevHandle *, int, struct AudioHwCaptureParam *) = nullptr; +void (*AudioLibCaptureTest::CloseServiceCaptureSo)(struct DevHandle *) = nullptr; +#ifdef AUDIO_MPI_SO + int32_t (*AudioLibCaptureTest::SdkInit)() = nullptr; + void (*AudioLibCaptureTest::SdkExit)() = nullptr; +#endif +void *AudioLibCaptureTest::PtrHandle = nullptr; -void AudioLibCaptureTest::TearDownTestCase(void) -{ -} - -void AudioLibCaptureTest::SetUp(void) +void AudioLibCaptureTest::SetUpTestCase(void) { +#ifdef __LITEOS__ + char resolvedPath[] = "/usr/lib/libhdi_audio_interface_lib_capture.so"; +#else char resolvedPath[] = "//system/lib/libhdi_audio_interface_lib_capture.z.so"; +#endif PtrHandle = dlopen(resolvedPath, RTLD_LAZY); if (PtrHandle == nullptr) { return; @@ -85,14 +97,21 @@ void AudioLibCaptureTest::SetUp(void) dlclose(PtrHandle); return; } +#ifdef AUDIO_MPI_SO + SdkInit = (int32_t (*)())(dlsym(PtrHandle, "MpiSdkInit")); + if (SdkInit == nullptr) { + return; + } + SdkExit = (void (*)())(dlsym(PtrHandle, "MpiSdkExit")); + if (SdkExit == nullptr) { + return; + } + SdkInit(); +#endif } -void AudioLibCaptureTest::TearDown(void) +void AudioLibCaptureTest::TearDownTestCase(void) { - if (PtrHandle != nullptr) { - dlclose(PtrHandle); - PtrHandle = nullptr; - } if (BindServiceCaptureSo != nullptr) { BindServiceCaptureSo = nullptr; } @@ -105,6 +124,44 @@ void AudioLibCaptureTest::TearDown(void) if (InterfaceLibOutputCapture != nullptr) { InterfaceLibOutputCapture = nullptr; } +#ifdef AUDIO_MPI_SO + SdkExit(); + if (SdkInit != nullptr) { + SdkInit = nullptr; + } + if (SdkExit != nullptr) { + SdkExit = nullptr; + } +#endif + if (PtrHandle != nullptr) { + dlclose(PtrHandle); + PtrHandle = nullptr; + } +} + +void AudioLibCaptureTest::SetUp(void) {} + +void AudioLibCaptureTest::TearDown(void) {} + +int32_t AudioLibCaptureTest::BindServiceAndHwCapture(struct AudioHwCapture *&hwCapture, + const std::string BindName, const std::string adapterNameCase, struct DevHandle *&handle) const +{ + handle = BindServiceCaptureSo(BindName.c_str()); + if (handle == nullptr) { + return HDF_FAILURE; + } + hwCapture = (struct AudioHwCapture *)calloc(1, sizeof(*hwCapture)); + if (hwCapture == nullptr) { + CloseServiceCaptureSo(handle); + return HDF_FAILURE; + } + if (InitHwCapture(hwCapture, adapterNameCase)) { + free(hwCapture); + hwCapture = nullptr; + CloseServiceCaptureSo(handle); + return HDF_FAILURE; + } + return HDF_SUCCESS; } /** @@ -201,18 +258,11 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_MuteWrite_Read_00 bool wishValue = 0; bool expectedValue = 1; struct DevHandle *handle = nullptr; - handle = BindServiceCaptureSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)calloc(1, sizeof(*hwCapture)); - if (hwCapture == nullptr) { - CloseServiceCaptureSo(handle); - ASSERT_NE(nullptr, hwCapture); - } - ret = InitHwCaptureMode(hwCapture->captureParam.captureMode); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = strcpy_s(hwCapture->captureParam.captureMode.hwInfo.adapterName, - NAME_LEN, ADAPTER_NAME3.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); + struct AudioHwCapture *hwCapture = nullptr; + + ret = BindServiceAndHwCapture(hwCapture, BIND_CONTROL.c_str(), ADAPTER_NAME_INTERNAL, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + hwCapture->captureParam.captureMode.ctlParam.mute = 0; ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_MUTE_WRITE_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); @@ -228,6 +278,7 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_MuteWrite_Read_00 muteValue = hwCapture->captureParam.captureMode.ctlParam.mute; EXPECT_EQ(expectedValue, muteValue); free(hwCapture); + hwCapture = nullptr; CloseServiceCaptureSo(handle); } /** @@ -241,20 +292,13 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_MuteWrite_Read_00 { int32_t ret = -1; bool muteValue = 0; + bool wishValue = 0; bool expectedValue = 1; struct DevHandle *handle = nullptr; - handle = BindServiceCaptureSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)calloc(1, sizeof(*hwCapture)); - if (hwCapture == nullptr) { - CloseServiceCaptureSo(handle); - ASSERT_NE(nullptr, hwCapture); - } - ret = InitHwCaptureMode(hwCapture->captureParam.captureMode); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = strcpy_s(hwCapture->captureParam.captureMode.hwInfo.adapterName, - NAME_LEN, ADAPTER_NAME3.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); + struct AudioHwCapture *hwCapture = nullptr; + ret = BindServiceAndHwCapture(hwCapture, BIND_CONTROL.c_str(), ADAPTER_NAME_INTERNAL, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + hwCapture->captureParam.captureMode.ctlParam.mute = 2; ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_MUTE_WRITE_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); @@ -262,7 +306,15 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_MuteWrite_Read_00 EXPECT_EQ(HDF_SUCCESS, ret); muteValue = hwCapture->captureParam.captureMode.ctlParam.mute; EXPECT_EQ(expectedValue, muteValue); + hwCapture->captureParam.captureMode.ctlParam.mute = 0; + ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_MUTE_WRITE_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_MUTE_READ_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + muteValue = hwCapture->captureParam.captureMode.ctlParam.mute; + EXPECT_EQ(wishValue, muteValue); free(hwCapture); + hwCapture = nullptr; CloseServiceCaptureSo(handle); } /** @@ -281,17 +333,9 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_VolumeWrite_Read_ float volumeThresholdValueMax = 0; float volumeThresholdValueMin = 0; struct DevHandle *handle = nullptr; - handle = BindServiceCaptureSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)calloc(1, sizeof(*hwCapture)); - if (hwCapture == nullptr) { - CloseServiceCaptureSo(handle); - ASSERT_NE(nullptr, hwCapture); - } - ret = InitHwCaptureMode(hwCapture->captureParam.captureMode); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = strcpy_s(hwCapture->captureParam.captureMode.hwInfo.adapterName, NAME_LEN, ADAPTER_NAME3.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); + struct AudioHwCapture *hwCapture = nullptr; + ret = BindServiceAndHwCapture(hwCapture, BIND_CONTROL.c_str(), ADAPTER_NAME_INTERNAL, handle); + ASSERT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); @@ -304,7 +348,11 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_VolumeWrite_Read_ ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); volumeValue = hwCapture->captureParam.captureMode.ctlParam.volume; - EXPECT_EQ(expectedValue1, volumeValue); + if (IS_ADM == false) { + EXPECT_EQ(126, volumeValue); + } else { + EXPECT_EQ(expectedValue1, volumeValue); + } hwCapture->captureParam.captureMode.ctlParam.volume = volumeThresholdValueMin+1; ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE, &hwCapture->captureParam); @@ -313,7 +361,9 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_VolumeWrite_Read_ EXPECT_EQ(HDF_SUCCESS, ret); volumeValue = hwCapture->captureParam.captureMode.ctlParam.volume; EXPECT_EQ(expectedValue2, volumeValue); + free(hwCapture); + hwCapture = nullptr; CloseServiceCaptureSo(handle); } /** @@ -326,44 +376,43 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_VolumeWrite_Read_ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_VolumeWrite_Read_0002, TestSize.Level1) { int32_t ret = -1; - float volumeValue; + struct DevHandle *handle = nullptr; + struct AudioHwCapture *hwCapture = nullptr; + float volumeValue = 0; float expectedValueMax = 87; float expectedValueMin = 0; float volumeThresholdValueMax = 0; float volumeThresholdValueMin = 0; - struct DevHandle *handle = nullptr; - handle = BindServiceCaptureSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)calloc(1, sizeof(*hwCapture)); - if (hwCapture == nullptr) { - CloseServiceCaptureSo(handle); - ASSERT_NE(nullptr, hwCapture); - } - ret = InitHwCaptureMode(hwCapture->captureParam.captureMode); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = strcpy_s(hwCapture->captureParam.captureMode.hwInfo.adapterName, NAME_LEN, ADAPTER_NAME3.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); + ret = BindServiceAndHwCapture(hwCapture, BIND_CONTROL.c_str(), ADAPTER_NAME_INTERNAL, handle); + ASSERT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); volumeThresholdValueMax = hwCapture->captureParam.captureMode.ctlParam.volThreshold.volMax; volumeThresholdValueMin = hwCapture->captureParam.captureMode.ctlParam.volThreshold.volMin; - hwCapture->captureParam.captureMode.ctlParam.volume = volumeThresholdValueMax; + hwCapture->captureParam.captureMode.ctlParam.volume = volumeThresholdValueMin; ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); volumeValue = hwCapture->captureParam.captureMode.ctlParam.volume; - EXPECT_EQ(expectedValueMax, volumeValue); - hwCapture->captureParam.captureMode.ctlParam.volume = volumeThresholdValueMin; + EXPECT_EQ(expectedValueMin, volumeValue); + + hwCapture->captureParam.captureMode.ctlParam.volume = volumeThresholdValueMax; ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); volumeValue = hwCapture->captureParam.captureMode.ctlParam.volume; - EXPECT_EQ(expectedValueMin, volumeValue); + if (IS_ADM == false) { + EXPECT_EQ(127, volumeValue); + } else { + EXPECT_EQ(expectedValueMax, volumeValue); + } + free(hwCapture); + hwCapture = nullptr; CloseServiceCaptureSo(handle); } /** @@ -377,19 +426,11 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_VolumeWrite_Read_ { int32_t ret = -1; float volumeThresholdValueMax = 0; + struct AudioHwCapture *hwCapture = nullptr; float volumeThresholdValueMin = 0; struct DevHandle *handle = nullptr; - handle = BindServiceCaptureSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)calloc(1, sizeof(*hwCapture)); - if (hwCapture == nullptr) { - CloseServiceCaptureSo(handle); - ASSERT_NE(nullptr, hwCapture); - } - ret = InitHwCaptureMode(hwCapture->captureParam.captureMode); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = strcpy_s(hwCapture->captureParam.captureMode.hwInfo.adapterName, NAME_LEN, ADAPTER_NAME3.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); + ret = BindServiceAndHwCapture(hwCapture, BIND_CONTROL.c_str(), ADAPTER_NAME_INTERNAL, handle); + ASSERT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); @@ -403,6 +444,7 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_VolumeWrite_Read_ ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_FAILURE, ret); free(hwCapture); + hwCapture = nullptr; CloseServiceCaptureSo(handle); } /** @@ -419,26 +461,23 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_GetVolthresholdRe float expMax = 87; float expMix = 0; struct DevHandle *handle = nullptr; - handle = BindServiceCaptureSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)calloc(1, sizeof(*hwCapture)); - if (hwCapture == nullptr) { - CloseServiceCaptureSo(handle); - ASSERT_NE(nullptr, hwCapture); - } - ret = InitHwCaptureMode(hwCapture->captureParam.captureMode); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = strcpy_s(hwCapture->captureParam.captureMode.hwInfo.adapterName, NAME_LEN, ADAPTER_NAME3.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); + struct AudioHwCapture *hwCapture = nullptr; + ret = BindServiceAndHwCapture(hwCapture, BIND_CONTROL.c_str(), ADAPTER_NAME_INTERNAL, handle); + ASSERT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); volumeThresholdValueMax = hwCapture->captureParam.captureMode.ctlParam.volThreshold.volMax; volumeThresholdValueMin = hwCapture->captureParam.captureMode.ctlParam.volThreshold.volMin; - EXPECT_EQ(expMax, volumeThresholdValueMax); + if (IS_ADM == false) { + EXPECT_EQ(127, volumeThresholdValueMax); + } else { + EXPECT_EQ(expMax, volumeThresholdValueMax); + } EXPECT_EQ(expMix, volumeThresholdValueMin); CloseServiceCaptureSo(handle); free(hwCapture); + hwCapture = nullptr; } /** * @tc.name test InterfaceLibCtlCapture API via selecting scene. @@ -450,21 +489,9 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_SelectScene_0001, { int32_t ret = -1; struct DevHandle* handle = nullptr; - - handle = BindServiceCaptureSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - - struct AudioHwCapture* hwCapture = (struct AudioHwCapture*)calloc(1, sizeof(*hwCapture)); - if (hwCapture == nullptr) { - CloseServiceCaptureSo(handle); - ASSERT_NE(nullptr, hwCapture); - } - ret = InitHwCaptureMode(hwCapture->captureParam.captureMode); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InitHwCaptureFramepara(hwCapture->captureParam.frameCaptureMode); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = strcpy_s(hwCapture->captureParam.captureMode.hwInfo.adapterName, NAME_LEN, ADAPTER_NAME3.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); + struct AudioHwCapture *hwCapture = nullptr; + ret = BindServiceAndHwCapture(hwCapture, BIND_CONTROL.c_str(), ADAPTER_NAME_INTERNAL, handle); + ASSERT_EQ(HDF_SUCCESS, ret); struct AudioSceneDescriptor scene = { .scene.id = 0, @@ -482,6 +509,7 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_SelectScene_0001, CloseServiceCaptureSo(handle); free(hwCapture); + hwCapture = nullptr; } /** * @tc.name test InterfaceLibCtlCapture API via writing normal value of gain and reading gain value. @@ -493,20 +521,13 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_SelectScene_0001, HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_GainWrite_Read_0001, TestSize.Level1) { int32_t ret = -1; - float gainValue; - float gainThresholdValueMax, gainThresholdValueMin; + float gainValue = 0; + float gainThresholdValueMax = 0; + float gainThresholdValueMin = 0; struct DevHandle *handle = nullptr; - handle = BindServiceCaptureSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)calloc(1, sizeof(*hwCapture)); - if (hwCapture == nullptr) { - CloseServiceCaptureSo(handle); - ASSERT_NE(nullptr, hwCapture); - } - ret = InitHwCaptureMode(hwCapture->captureParam.captureMode); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = strcpy_s(hwCapture->captureParam.captureMode.hwInfo.adapterName, NAME_LEN, ADAPTER_NAME3.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); + struct AudioHwCapture *hwCapture = nullptr; + ret = BindServiceAndHwCapture(hwCapture, BIND_CONTROL.c_str(), ADAPTER_NAME_INTERNAL, handle); + ASSERT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); @@ -538,6 +559,7 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_GainWrite_Read_00 EXPECT_EQ(2, gainValue); CloseServiceCaptureSo(handle); free(hwCapture); + hwCapture = nullptr; } /** * @tc.name test InterfaceLibCtlCapture API via writing boundary value of gain and reading gain value. @@ -549,20 +571,13 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_GainWrite_Read_00 HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_GainWrite_Read_0002, TestSize.Level1) { int32_t ret = -1; - float gainValue; - float gainThresholdValueMax, gainThresholdValueMin; struct DevHandle *handle = nullptr; - handle = BindServiceCaptureSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)calloc(1, sizeof(*hwCapture)); - if (hwCapture == nullptr) { - CloseServiceCaptureSo(handle); - ASSERT_NE(nullptr, hwCapture); - } - ret = InitHwCaptureMode(hwCapture->captureParam.captureMode); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = strcpy_s(hwCapture->captureParam.captureMode.hwInfo.adapterName, NAME_LEN, ADAPTER_NAME3.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); + struct AudioHwCapture *hwCapture = nullptr; + float gainValue = 0; + float gainThresholdValueMax = 0; + float gainThresholdValueMin = 0; + ret = BindServiceAndHwCapture(hwCapture, BIND_CONTROL.c_str(), ADAPTER_NAME_INTERNAL, handle); + ASSERT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); @@ -587,6 +602,7 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_GainWrite_Read_00 EXPECT_EQ(gainThresholdValueMin, gainValue); CloseServiceCaptureSo(handle); free(hwCapture); + hwCapture = nullptr; } /** * @tc.name test InterfaceLibCtlCapture API via writing invalid value of gain. @@ -597,19 +613,12 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_GainWrite_Read_00 HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_GainWrite_Read_0003, TestSize.Level1) { int32_t ret = -1; + float gainThresholdValueMax = 0; + float gainThresholdValueMin = 0; + struct AudioHwCapture *hwCapture = nullptr; struct DevHandle *handle = nullptr; - float gainThresholdValueMax, gainThresholdValueMin; - handle = BindServiceCaptureSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)calloc(1, sizeof(*hwCapture)); - if (hwCapture == nullptr) { - CloseServiceCaptureSo(handle); - ASSERT_NE(nullptr, hwCapture); - } - ret = InitHwCaptureMode(hwCapture->captureParam.captureMode); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = strcpy_s(hwCapture->captureParam.captureMode.hwInfo.adapterName, NAME_LEN, ADAPTER_NAME3.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); + ret = BindServiceAndHwCapture(hwCapture, BIND_CONTROL.c_str(), ADAPTER_NAME_INTERNAL, handle); + ASSERT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); @@ -625,6 +634,7 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_GainWrite_Read_00 EXPECT_EQ(HDF_FAILURE, ret); CloseServiceCaptureSo(handle); free(hwCapture); + hwCapture = nullptr; } /** * @tc.name test InterfaceLibCtlCapture API via writing GetGainthreshold value. @@ -639,17 +649,9 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_GetGainthresholdR float expMax = 10; float expMix = 0; struct DevHandle *handle = nullptr; - handle = BindServiceCaptureSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)calloc(1, sizeof(*hwCapture)); - if (hwCapture == nullptr) { - CloseServiceCaptureSo(handle); - ASSERT_NE(nullptr, hwCapture); - } - ret = InitHwCaptureMode(hwCapture->captureParam.captureMode); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = strcpy_s(hwCapture->captureParam.captureMode.hwInfo.adapterName, NAME_LEN, ADAPTER_NAME3.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); + struct AudioHwCapture *hwCapture = nullptr; + ret = BindServiceAndHwCapture(hwCapture, BIND_CONTROL.c_str(), ADAPTER_NAME_INTERNAL, handle); + ASSERT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); @@ -659,6 +661,7 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_GetGainthresholdR EXPECT_EQ(expMix, gainThresholdValueMin); CloseServiceCaptureSo(handle); free(hwCapture); + hwCapture = nullptr; } /** * @tc.name test InterfaceLibCtlCapture API via inputting cmdid invalid. @@ -670,26 +673,21 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_Abnormal_0001, Te { int32_t ret = -1; struct DevHandle *handle = nullptr; - handle = BindServiceCaptureSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)calloc(1, sizeof(*hwCapture)); - if (hwCapture == nullptr) { - CloseServiceCaptureSo(handle); - ASSERT_NE(nullptr, hwCapture); - } - ret = InitHwCaptureMode(hwCapture->captureParam.captureMode); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = strcpy_s(hwCapture->captureParam.captureMode.hwInfo.adapterName, NAME_LEN, ADAPTER_NAME3.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); + struct AudioHwCapture *hwCapture = nullptr; + ret = BindServiceAndHwCapture(hwCapture, BIND_CONTROL.c_str(), ADAPTER_NAME_INTERNAL, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlCapture(handle, 30, &hwCapture->captureParam); if (ret == 0) { CloseServiceCaptureSo(handle); free(hwCapture); + hwCapture = nullptr; ASSERT_EQ(HDF_FAILURE, ret); } EXPECT_EQ(HDF_FAILURE, ret); CloseServiceCaptureSo(handle); free(hwCapture); + hwCapture = nullptr; } /** * @tc.name test InterfaceLibCtlCapture API via inputting handleData invalid. @@ -708,7 +706,6 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_Abnormal_0002, Te EXPECT_EQ(HDF_FAILURE, ret); CloseServiceCaptureSo(handle); } - /** * @tc.name test InterfaceLibOutputCapture API via cmdid is AUDIO_DRV_PCM_IOCTL_HW_PARAMS. * @tc.number SUB_Audio_InterfaceLibOutputCapture_HwParams_0001 @@ -719,24 +716,15 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_HwParams_0001 { int32_t ret = -1; struct DevHandle *handle = nullptr; - handle = BindServiceCaptureSo(BIND_CAPTURE.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)calloc(1, sizeof(*hwCapture)); - if (hwCapture == nullptr) { - CloseServiceCaptureSo(handle); - ASSERT_NE(nullptr, hwCapture); - } - ret = InitHwCaptureFramepara(hwCapture->captureParam.frameCaptureMode); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InitHwCaptureMode(hwCapture->captureParam.captureMode); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = strcpy_s(hwCapture->captureParam.captureMode.hwInfo.adapterName, NAME_LEN, ADAPTER_NAME3.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); + struct AudioHwCapture *hwCapture = nullptr; + ret = BindServiceAndHwCapture(hwCapture, BIND_CAPTURE.c_str(), ADAPTER_NAME_INTERNAL, handle); + ASSERT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); CloseServiceCaptureSo(handle); free(hwCapture); + hwCapture = nullptr; } /** * @tc.name test InterfaceLibOutputCapture API via cmdid is AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE. @@ -747,20 +735,10 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_HwParams_0001 HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_Prepare_0001, TestSize.Level1) { int32_t ret = -1; + struct AudioHwCapture *hwCapture = nullptr; struct DevHandle *handle = nullptr; - handle = BindServiceCaptureSo(BIND_CAPTURE.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)calloc(1, sizeof(*hwCapture)); - if (hwCapture == nullptr) { - CloseServiceCaptureSo(handle); - ASSERT_NE(nullptr, hwCapture); - } - ret = InitHwCaptureFramepara(hwCapture->captureParam.frameCaptureMode); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InitHwCaptureMode(hwCapture->captureParam.captureMode); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = strcpy_s(hwCapture->captureParam.captureMode.hwInfo.adapterName, NAME_LEN, ADAPTER_NAME3.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); + ret = BindServiceAndHwCapture(hwCapture, BIND_CAPTURE.c_str(), ADAPTER_NAME_INTERNAL, handle); + ASSERT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); @@ -768,6 +746,7 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_Prepare_0001, EXPECT_EQ(HDF_SUCCESS, ret); CloseServiceCaptureSo(handle); free(hwCapture); + hwCapture = nullptr; } /** * @tc.name test InterfaceLibOutputCapture API via cmdid is AUDIO_DRV_PCM_IOCTRL_START_CAPTURE. @@ -777,21 +756,11 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_Prepare_0001, */ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_Start_0001, TestSize.Level1) { - int32_t ret = -1; struct DevHandle *handle = nullptr; - handle = BindServiceCaptureSo(BIND_CAPTURE.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)calloc(1, sizeof(*hwCapture)); - if (hwCapture == nullptr) { - CloseServiceCaptureSo(handle); - ASSERT_NE(nullptr, hwCapture); - } - ret = InitHwCaptureFramepara(hwCapture->captureParam.frameCaptureMode); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InitHwCaptureMode(hwCapture->captureParam.captureMode); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = strcpy_s(hwCapture->captureParam.captureMode.hwInfo.adapterName, NAME_LEN, ADAPTER_NAME3.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); + struct AudioHwCapture *hwCapture = nullptr; + int32_t ret = -1; + ret = BindServiceAndHwCapture(hwCapture, BIND_CAPTURE.c_str(), ADAPTER_NAME_INTERNAL, handle); + ASSERT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); @@ -801,6 +770,7 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_Start_0001, T EXPECT_EQ(HDF_SUCCESS, ret); CloseServiceCaptureSo(handle); free(hwCapture); + hwCapture = nullptr; } /** * @tc.name Test AudioOutputcapture API via cmdid is AUDIO_DRV_PCM_IOCTL_READ. @@ -813,19 +783,9 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_Read_Stop_0001 { int32_t ret = -1; struct DevHandle *handle = nullptr; - handle = BindServiceCaptureSo(BIND_CAPTURE.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)calloc(1, sizeof(*hwCapture)); - if (hwCapture == nullptr) { - CloseServiceCaptureSo(handle); - ASSERT_NE(nullptr, hwCapture); - } - ret = InitHwCaptureFramepara(hwCapture->captureParam.frameCaptureMode); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InitHwCaptureMode(hwCapture->captureParam.captureMode); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = strcpy_s(hwCapture->captureParam.captureMode.hwInfo.adapterName, NAME_LEN, ADAPTER_NAME3.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); + struct AudioHwCapture *hwCapture = nullptr; + ret = BindServiceAndHwCapture(hwCapture, BIND_CAPTURE.c_str(), ADAPTER_NAME_INTERNAL, handle); + ASSERT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); @@ -833,11 +793,12 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_Read_Stop_0001 EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_START_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); - hwCapture->captureParam.frameCaptureMode.buffer = (char *)calloc(1, 1024); + hwCapture->captureParam.frameCaptureMode.buffer = (char *)calloc(1, 16384); if (hwCapture->captureParam.frameCaptureMode.buffer == nullptr) { CloseServiceCaptureSo(handle); free(hwCapture); - ASSERT_NE(nullptr, hwCapture->captureParam.frameCaptureMode.buffer); + hwCapture = nullptr; + ASSERT_NE(nullptr, hwCapture); } ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_READ, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); @@ -845,7 +806,9 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_Read_Stop_0001 EXPECT_EQ(HDF_SUCCESS, ret); CloseServiceCaptureSo(handle); free(hwCapture->captureParam.frameCaptureMode.buffer); + hwCapture->captureParam.frameCaptureMode.buffer = nullptr; free(hwCapture); + hwCapture = nullptr; } /** * @tc.name Test AudioOutputcapture API data flow and control flow are serial. @@ -858,41 +821,37 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_0001, TestSize int32_t ret = -1; struct DevHandle *handle1 = nullptr; struct DevHandle *handle2 = nullptr; - handle1 = BindServiceCaptureSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle1); - struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)calloc(1, sizeof(*hwCapture)); - if (hwCapture == nullptr) { - CloseServiceCaptureSo(handle1); - ASSERT_NE(nullptr, hwCapture); - } - ret = InitHwCaptureMode(hwCapture->captureParam.captureMode); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = strcpy_s(hwCapture->captureParam.captureMode.hwInfo.adapterName, NAME_LEN, ADAPTER_NAME3.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); - hwCapture->captureParam.captureMode.ctlParam.mute = 0; - ret = InterfaceLibCtlCapture(handle1, AUDIODRV_CTL_IOCTL_MUTE_WRITE_CAPTURE, &hwCapture->captureParam); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InterfaceLibCtlCapture(handle1, AUDIODRV_CTL_IOCTL_MUTE_READ_CAPTURE, &hwCapture->captureParam); - EXPECT_EQ(HDF_SUCCESS, ret); + struct AudioHwCapture *hwCapture = nullptr; + ret = BindServiceAndHwCapture(hwCapture, BIND_CONTROL.c_str(), ADAPTER_NAME_INTERNAL, handle1); + ASSERT_EQ(HDF_SUCCESS, ret); + handle2 = BindServiceCaptureSo(BIND_CAPTURE.c_str()); if (handle2 == nullptr) { CloseServiceCaptureSo(handle1); + free(hwCapture->captureParam.frameCaptureMode.buffer); + hwCapture->captureParam.frameCaptureMode.buffer = nullptr; free(hwCapture); + hwCapture = nullptr; ASSERT_NE(nullptr, handle2); } - ret = InitHwCaptureFramepara(hwCapture->captureParam.frameCaptureMode); + hwCapture->captureParam.captureMode.ctlParam.mute = 0; + ret = InterfaceLibCtlCapture(handle1, AUDIODRV_CTL_IOCTL_MUTE_WRITE_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlCapture(handle1, AUDIODRV_CTL_IOCTL_MUTE_READ_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputCapture(handle2, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibOutputCapture(handle2, AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibOutputCapture(handle2, AUDIO_DRV_PCM_IOCTRL_START_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); - hwCapture->captureParam.frameCaptureMode.buffer = (char *)calloc(1, 1024); + hwCapture->captureParam.frameCaptureMode.buffer = (char *)calloc(1, 16384); if (hwCapture->captureParam.frameCaptureMode.buffer == nullptr) { CloseServiceCaptureSo(handle1); CloseServiceCaptureSo(handle2); free(hwCapture); + hwCapture = nullptr; ASSERT_NE(nullptr, hwCapture->captureParam.frameCaptureMode.buffer); } ret = InterfaceLibOutputCapture(handle2, AUDIO_DRV_PCM_IOCTL_READ, &hwCapture->captureParam); @@ -902,7 +861,9 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_0001, TestSize CloseServiceCaptureSo(handle1); CloseServiceCaptureSo(handle2); free(hwCapture->captureParam.frameCaptureMode.buffer); + hwCapture->captureParam.frameCaptureMode.buffer = nullptr; free(hwCapture); + hwCapture = nullptr; } /** * @tc.name test InterfaceLibOutputCapture API via pause. @@ -914,22 +875,21 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_Pause_0001, Te { int32_t ret = -1; struct DevHandle *handle = {}; - handle = BindServiceCaptureSo(BIND_CAPTURE.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)calloc(1, sizeof(*hwCapture)); - if (hwCapture == nullptr) { - CloseServiceCaptureSo(handle); - ASSERT_NE(nullptr, hwCapture); - } - ret = InitHwCaptureMode(hwCapture->captureParam.captureMode); + struct AudioHwCapture *hwCapture = nullptr; + ret = BindServiceAndHwCapture(hwCapture, BIND_CAPTURE.c_str(), ADAPTER_NAME_INTERNAL, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); - ret = strcpy_s(hwCapture->captureParam.captureMode.hwInfo.adapterName, NAME_LEN, ADAPTER_NAME3.c_str()); + ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_START_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); hwCapture->captureParam.captureMode.ctlParam.pause = 1; ret = InterfaceLibOutputCapture(handle, AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); CloseServiceCaptureSo(handle); free(hwCapture); + hwCapture = nullptr; } /** * @tc.name test InterfaceLibOutputCapture API via resume. @@ -940,23 +900,22 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_Pause_0001, Te HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_Resume_0001, TestSize.Level1) { int32_t ret = -1; + struct AudioHwCapture *hwCapture = nullptr; struct DevHandle *handle = {}; - handle = BindServiceCaptureSo(BIND_CAPTURE.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)calloc(1, sizeof(*hwCapture)); - if (hwCapture == nullptr) { - CloseServiceCaptureSo(handle); - ASSERT_NE(nullptr, hwCapture); - } - ret = InitHwCaptureMode(hwCapture->captureParam.captureMode); + ret = BindServiceAndHwCapture(hwCapture, BIND_CAPTURE.c_str(), ADAPTER_NAME_INTERNAL, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); - ret = strcpy_s(hwCapture->captureParam.captureMode.hwInfo.adapterName, NAME_LEN, ADAPTER_NAME3.c_str()); + ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_START_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); hwCapture->captureParam.captureMode.ctlParam.pause = 0; ret = InterfaceLibOutputCapture(handle, AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE, &hwCapture->captureParam); EXPECT_EQ(HDF_SUCCESS, ret); CloseServiceCaptureSo(handle); free(hwCapture); + hwCapture = nullptr; } /** * @tc.name Test InterfaceLibOutputCapture API via setting the cmdId(30) is invalid @@ -968,19 +927,15 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_Abnormal_0001, { int32_t ret = -1; struct DevHandle *handle = nullptr; - handle = BindServiceCaptureSo(BIND_CAPTURE.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)calloc(1, sizeof(*hwCapture)); - if (hwCapture == nullptr) { - CloseServiceCaptureSo(handle); - ASSERT_NE(nullptr, hwCapture); - } - ret = InitHwCaptureFramepara(hwCapture->captureParam.frameCaptureMode); - EXPECT_EQ(HDF_SUCCESS, ret); + struct AudioHwCapture *hwCapture = nullptr; + ret = BindServiceAndHwCapture(hwCapture, BIND_CAPTURE.c_str(), ADAPTER_NAME_INTERNAL, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputCapture(handle, 30, &hwCapture->captureParam); EXPECT_EQ(HDF_FAILURE, ret); CloseServiceCaptureSo(handle); free(hwCapture); + hwCapture = nullptr; } /** * @tc.name Test Outputcapture API via setting the incoming parameter handleData is empty @@ -993,18 +948,14 @@ HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_Abnormal_0002, int32_t ret = -1; struct DevHandle *handle = nullptr; struct AudioHwCaptureParam *handleData = nullptr; - handle = BindServiceCaptureSo(BIND_CAPTURE.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)calloc(1, sizeof(*hwCapture)); - if (hwCapture == nullptr) { - CloseServiceCaptureSo(handle); - ASSERT_NE(nullptr, hwCapture); - } - ret = InitHwCaptureFramepara(hwCapture->captureParam.frameCaptureMode); - EXPECT_EQ(HDF_SUCCESS, ret); + struct AudioHwCapture *hwCapture = nullptr; + ret = BindServiceAndHwCapture(hwCapture, BIND_CAPTURE.c_str(), ADAPTER_NAME_INTERNAL, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_READ, handleData); EXPECT_EQ(HDF_FAILURE, ret); CloseServiceCaptureSo(handle); free(hwCapture); + hwCapture = nullptr; } -} +} \ No newline at end of file diff --git a/audio/test/systemtest/adm_interface_lib/render/BUILD.gn b/audio/test/systemtest/adm_interface_lib/render/BUILD.gn index c963e1fb82..1736442139 100755 --- a/audio/test/systemtest/adm_interface_lib/render/BUILD.gn +++ b/audio/test/systemtest/adm_interface_lib/render/BUILD.gn @@ -11,49 +11,122 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build/test.gni") -import("//drivers/adapter/uhdf2/uhdf.gni") +if (defined(ohos_lite)) { + import("//build/lite/config/test.gni") +} else { + import("//build/test.gni") + import("//drivers/adapter/uhdf2/uhdf.gni") + import("//drivers/peripheral/audio/audio.gni") +} + +if (defined(ohos_lite)) { +###########################LITEOS########################################## + ###########################hdf_audio_lib_render_test########################### + unittest("hdf_audio_lib_render_test") { + sources = [ + "src/audio_librender_test.cpp", + "../../common/lib_common/src/audio_lib_common.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] + + include_dirs = [ + "//drivers/peripheral/audio/supportlibs/adm_adapter/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/include", + "//drivers/framework/core/sec/include", + "//drivers/framework/core/shared/include", + "//drivers/framework/core/host/include", + "//drivers/framework/core/manager/include", + "//drivers/framework/core/common/include/host/", + "//third_party/bounds_checking_function/include", + "//drivers/adapter/khdf/liteos/osal/include", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/adapter/uhdf2/include/hdi/", + "//drivers/peripheral/audio/test/systemtest/common/lib_common/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//drivers/peripheral/audio/test/systemtest/adm_interface_lib/render/include", + "//third_party/googletest/googletest/include/gtest", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + "-std=c++11" + ] -module_output_path = "hdf/audio/systemtest/lib" -###########################systemtest############################## -###########################AudioLibRenderTest########################### -ohos_systemtest("AudioLibRenderTest") { - module_out_path = module_output_path - sources = [ - "src/audio_librender_test.cpp", - "../../common/lib_common/src/audio_lib_common.cpp" - ] + deps = [ + "//third_party/bounds_checking_function:libsec_shared" + ] + } +} else { + module_output_path = "hdf/audio" + ###########################hdf_audio_lib_render_test########################### + ohos_systemtest("hdf_audio_lib_render_test") { + module_out_path = module_output_path + sources = [ + "src/audio_librender_test.cpp", + "../../common/lib_common/src/audio_lib_common.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] - include_dirs = [ - "//drivers/peripheral/audio/supportlibs/adm_adapter/include", - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/interfaces/include", - "//drivers/framework/include/core", - "//drivers/framework/include/utils", - "//utils/native/base/include", - "//drivers/framework/include/osal", - "//drivers/framework/include", - "//third_party/bounds_checking_function/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/framework/utils/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/adapter/uhdf2/osal/include", - "//drivers/peripheral/audio/test/systemtest/common/lib_common/include", - "//drivers/peripheral/audio/test/systemtest/adm_interface_lib/render/include", - "//third_party/googletest/googletest/include/gtest", - ] - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - ] - deps = [ - "//utils/native/base:utils", - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - ] + include_dirs = [ + "//drivers/peripheral/audio/supportlibs/adm_adapter/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//utils/native/base/include", + "//drivers/framework/include/osal", + "//drivers/framework/include", + "//third_party/bounds_checking_function/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/adapter/uhdf2/osal/include", + "//drivers/peripheral/audio/test/systemtest/common/lib_common/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//drivers/peripheral/audio/test/systemtest/adm_interface_lib/render/include", + "//third_party/googletest/googletest/include/gtest", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + deps = [ + "//utils/native/base:utils", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + defines = [] + if (enable_audio_adm_so) { + defines += [ "AUDIO_ADM_SO" ] + } + if (enable_audio_mpi_so) { + defines += [ "AUDIO_MPI_SO" ] + } + if (enable_audio_adm_service) { + defines += [ "AUDIO_ADM_SERVICE" ] + } + if (enable_audio_mpi_service) { + defines += [ "AUDIO_MPI_SERVICE" ] + } + } } ###########################end########################### \ No newline at end of file diff --git a/audio/test/systemtest/adm_interface_lib/render/src/audio_librender_test.cpp b/audio/test/systemtest/adm_interface_lib/render/src/audio_librender_test.cpp index 6fc304ccdb..83859bd0de 100755 --- a/audio/test/systemtest/adm_interface_lib/render/src/audio_librender_test.cpp +++ b/audio/test/systemtest/adm_interface_lib/render/src/audio_librender_test.cpp @@ -42,12 +42,8 @@ using namespace HMOS::Audio; namespace { const string BIND_CONTROL = "control"; const string BIND_RENDER = "render"; -const string BIND_NAME_ERROR = "rendeo"; -const string AUDIO_FILE_PATH = "//bin/audiorendertest.wav"; -const int G_BUFFERSIZE = 256; -const string ADAPTER_NAME_HDIMI = "hdmi"; +const string BIND_NAME_ERROR = "rendor"; const string ADAPTER_NAME_USB = "usb"; -const string ADAPTER_NAME3 = "internal"; class AudioLibRenderTest : public testing::Test { public: @@ -55,35 +51,42 @@ public: static void TearDownTestCase(void); void SetUp(); void TearDown(); - struct DevHandle *(*BindServiceRenderSo)(const char *) = nullptr; - int32_t (*InterfaceLibOutputRender)(struct DevHandle *, int, struct AudioHwRenderParam *) = nullptr; - int32_t (*InterfaceLibCtlRender)(struct DevHandle *, int, struct AudioHwRenderParam *) = nullptr; - void (*CloseServiceRenderSo)(struct DevHandle *) = nullptr; - void *PtrHandle = nullptr; - uint32_t PcmFormatToBits(enum AudioFormat format) const; - uint32_t PcmFramesToBytes(const struct AudioSampleAttributes attrs) const; + static struct DevHandle *(*BindServiceRenderSo)(const char *); + static int32_t (*InterfaceLibOutputRender)(struct DevHandle *, int, struct AudioHwRenderParam *); + static int32_t (*InterfaceLibCtlRender)(struct DevHandle *, int, struct AudioHwRenderParam *); + static void (*CloseServiceRenderSo)(struct DevHandle *); + static void *PtrHandle; +#ifdef AUDIO_MPI_SO + static int32_t (*SdkInit)(); + static void (*SdkExit)(); +#endif uint32_t PcmBytesToFrames(const struct AudioFrameRenderMode &frameRenderMode, uint64_t bytes) const; - uint32_t FormatToBits(enum AudioFormat format) const; - uint32_t FrameLibStart(FILE *file, struct AudioSampleAttributes attrs, + int32_t FrameLibStart(FILE *file, struct AudioSampleAttributes attrs, struct AudioHeadInfo wavHeadInfo, struct AudioHwRender *hwRender) const; - uint32_t LibStartAndStream(const std::string path, struct AudioSampleAttributes attrs, + int32_t LibStartAndStream(const std::string path, struct AudioSampleAttributes attrs, struct DevHandle *handle, struct AudioHwRender *hwRender, struct AudioHeadInfo wavHeadInfo) const; - uint32_t InitHwRender(struct AudioHwRender *hwRender, struct AudioSampleAttributes attrs, - const std::string adapterNameCase) const; int32_t LibHwOutputRender(struct AudioHwRender *hwRender, struct DevHandle *handlerender) const; + int32_t BindServiceAndHwRender(struct AudioHwRender *&hwRender, + const std::string BindName, const std::string adapterNameCase, struct DevHandle *&handle) const; }; -void AudioLibRenderTest::SetUpTestCase(void) -{ -} - -void AudioLibRenderTest::TearDownTestCase(void) -{ -} +struct DevHandle *(*AudioLibRenderTest::BindServiceRenderSo)(const char *) = nullptr; +int32_t (*AudioLibRenderTest::InterfaceLibOutputRender)(struct DevHandle *, int, struct AudioHwRenderParam *) = nullptr; +int32_t (*AudioLibRenderTest::InterfaceLibCtlRender)(struct DevHandle *, int, struct AudioHwRenderParam *) = nullptr; +void (*AudioLibRenderTest::CloseServiceRenderSo)(struct DevHandle *) = nullptr; +void *AudioLibRenderTest::PtrHandle = nullptr; +#ifdef AUDIO_MPI_SO + int32_t (*AudioLibRenderTest::SdkInit)() = nullptr; + void (*AudioLibRenderTest::SdkExit)() = nullptr; +#endif -void AudioLibRenderTest::SetUp(void) +void AudioLibRenderTest::SetUpTestCase(void) { +#ifdef __LITEOS__ + char resolvedPath[] = "/usr/lib/libhdi_audio_interface_lib_render.so"; +#else char resolvedPath[] = "//system/lib/libhdi_audio_interface_lib_render.z.so"; +#endif PtrHandle = dlopen(resolvedPath, RTLD_LAZY); if (PtrHandle == nullptr) { return; @@ -99,73 +102,57 @@ void AudioLibRenderTest::SetUp(void) dlclose(PtrHandle); return; } +#ifdef AUDIO_MPI_SO + SdkInit = (int32_t (*)())(dlsym(PtrHandle, "MpiSdkInit")); + if (SdkInit == nullptr) { + return; + } + SdkExit = (void (*)())(dlsym(PtrHandle, "MpiSdkExit")); + if (SdkExit == nullptr) { + return; + } + SdkInit(); +#endif } -void AudioLibRenderTest::TearDown(void) +void AudioLibRenderTest::TearDownTestCase(void) { - if (PtrHandle != nullptr) { - dlclose(PtrHandle); - PtrHandle = nullptr; - } if (BindServiceRenderSo != nullptr) { BindServiceRenderSo = nullptr; - } + } if (CloseServiceRenderSo != nullptr) { CloseServiceRenderSo = nullptr; - } + } if (InterfaceLibOutputRender != nullptr) { InterfaceLibOutputRender = nullptr; - } + } if (InterfaceLibCtlRender != nullptr) { InterfaceLibCtlRender = nullptr; } +#ifdef AUDIO_MPI_SO + SdkExit(); + if (SdkInit != nullptr) { + SdkInit = nullptr; + } + if (SdkExit != nullptr) { + SdkExit = nullptr; + } +#endif + if (PtrHandle != nullptr) { + dlclose(PtrHandle); + PtrHandle = nullptr; + } } -uint32_t AudioLibRenderTest::PcmFormatToBits(enum AudioFormat format) const -{ - switch (format) { - case AUDIO_FORMAT_PCM_16_BIT: - return G_PCM16BIT; - case AUDIO_FORMAT_PCM_8_BIT: - return G_PCM8BIT; - default: - return G_PCM16BIT; - }; -} +void AudioLibRenderTest::SetUp(void) {} -uint32_t AudioLibRenderTest::PcmFramesToBytes(const struct AudioSampleAttributes attrs) const -{ - uint32_t ret = 1024 * attrs.channelCount * (PcmFormatToBits(attrs.format) >> 3); - return ret; -} -uint32_t AudioLibRenderTest::FormatToBits(enum AudioFormat format) const -{ - switch (format) { - case AUDIO_FORMAT_PCM_16_BIT: - return G_PCM16BIT; - case AUDIO_FORMAT_PCM_8_BIT: - return G_PCM8BIT; - default: - return G_PCM16BIT; - } -} +void AudioLibRenderTest::TearDown(void) {} uint32_t AudioLibRenderTest::PcmBytesToFrames(const struct AudioFrameRenderMode &frameRenderMode, uint64_t bytes) const { - return bytes / (frameRenderMode.attrs.channelCount * (FormatToBits(frameRenderMode.attrs.format) >> 3)); -} - -int32_t AudioLibRenderTest::LibHwOutputRender(struct AudioHwRender *hwRender, struct DevHandle *handlerender) const -{ - if (hwRender == nullptr || handlerender == nullptr) { - return HDF_FAILURE; - } - if (InterfaceLibOutputRender(handlerender, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam) || - InterfaceLibOutputRender(handlerender, AUDIO_DRV_PCM_IOCTL_PREPARE, &hwRender->renderParam) || - InterfaceLibOutputRender(handlerender, AUDIO_DRV_PCM_IOCTRL_START, &hwRender->renderParam)) { - return HDF_FAILURE; - } - return HDF_SUCCESS; + uint32_t replyByte = static_cast(bytes); + return replyByte / (frameRenderMode.attrs.channelCount * (PcmFormatToBits(frameRenderMode.attrs.format) >> + MOVE_RIGHT_NUM)); } /** @@ -178,49 +165,40 @@ int32_t AudioLibRenderTest::LibHwOutputRender(struct AudioHwRender *hwRender, st * * @return Returns 0 if the initialization is successful; returns a negative value otherwise. */ -uint32_t AudioLibRenderTest::FrameLibStart(FILE *file, struct AudioSampleAttributes attrs, +int32_t AudioLibRenderTest::FrameLibStart(FILE *file, struct AudioSampleAttributes attrs, struct AudioHeadInfo wavHeadInfo, struct AudioHwRender *hwRender) const { - int bufferSize = G_BUFFERSIZE; - int readSize = 0; - int remainingDataSize = 0; int numRead = 0; - uint64_t *replyBytes = nullptr; - remainingDataSize = wavHeadInfo.dataSize; - if (file == nullptr || hwRender == nullptr) { + uint32_t remainingDataSize = wavHeadInfo.dataSize; + uint32_t bufferSize = PcmFramesToBytes(attrs); + if (bufferSize <= 0) { return HDF_FAILURE; } - bufferSize = PcmFramesToBytes(attrs); - char *frame = nullptr; - frame = (char *)calloc(1, bufferSize); - if (frame == nullptr) { + hwRender->renderParam.frameRenderMode.buffer = (char *)calloc(1, bufferSize); + if (hwRender->renderParam.frameRenderMode.buffer == nullptr) { return HDF_FAILURE; } - replyBytes = (uint64_t *)calloc(1, bufferSize); - if (replyBytes == nullptr) { - free(frame); + + uint32_t readSize = (remainingDataSize > bufferSize) ? bufferSize : remainingDataSize; + numRead = fread(hwRender->renderParam.frameRenderMode.buffer, 1, readSize, file); + if (numRead < 0) { + free(hwRender->renderParam.frameRenderMode.buffer); + hwRender->renderParam.frameRenderMode.buffer = nullptr; return HDF_FAILURE; } - do { - readSize = (remainingDataSize > bufferSize) ? bufferSize : remainingDataSize; - numRead = fread(frame, 1, readSize, file); - if (numRead > 0) { - hwRender->renderParam.frameRenderMode.buffer = (char *)frame; - hwRender->renderParam.frameRenderMode.bufferSize = numRead; - hwRender->renderParam.frameRenderMode.bufferFrameSize = - PcmBytesToFrames(hwRender->renderParam.frameRenderMode, numRead); - remainingDataSize -= numRead; - } - } while (0); - free(frame); - free(replyBytes); + hwRender->renderParam.frameRenderMode.bufferSize = numRead; + hwRender->renderParam.frameRenderMode.bufferFrameSize = + PcmBytesToFrames(hwRender->renderParam.frameRenderMode, numRead); return HDF_SUCCESS; } -uint32_t AudioLibRenderTest::LibStartAndStream(const std::string path, struct AudioSampleAttributes attrs, +int32_t AudioLibRenderTest::LibStartAndStream(const std::string path, struct AudioSampleAttributes attrs, struct DevHandle *handle, struct AudioHwRender *hwRender, struct AudioHeadInfo wavHeadInfo) const { int ret = -1; + if (handle == nullptr || hwRender == nullptr) { + return HDF_FAILURE; + } if (InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam) || InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_PREPARE, &hwRender->renderParam) || InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_START, &hwRender->renderParam)) { @@ -246,30 +224,45 @@ uint32_t AudioLibRenderTest::LibStartAndStream(const std::string path, struct Au ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_WRITE, &hwRender->renderParam); if (ret < 0) { fclose(file); + free(hwRender->renderParam.frameRenderMode.buffer); + hwRender->renderParam.frameRenderMode.buffer = nullptr; return HDF_FAILURE; } fclose(file); + free(hwRender->renderParam.frameRenderMode.buffer); + hwRender->renderParam.frameRenderMode.buffer = nullptr; return HDF_SUCCESS; } -uint32_t AudioLibRenderTest::InitHwRender(struct AudioHwRender *hwRender, struct AudioSampleAttributes attrs, - const std::string adapterNameCase) const +int32_t AudioLibRenderTest::LibHwOutputRender(struct AudioHwRender *hwRender, struct DevHandle *handlerender) const { - int ret = -1; - if (hwRender == nullptr) { + if (hwRender == nullptr || handlerender == nullptr) { + return HDF_FAILURE; + } + if (InterfaceLibOutputRender(handlerender, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam) || + InterfaceLibOutputRender(handlerender, AUDIO_DRV_PCM_IOCTL_PREPARE, &hwRender->renderParam) || + InterfaceLibOutputRender(handlerender, AUDIO_DRV_PCM_IOCTRL_START, &hwRender->renderParam)) { return HDF_FAILURE; } - if (InitHwRenderMode(hwRender->renderParam.renderMode) or - InitRenderFramepara(hwRender->renderParam.frameRenderMode)) { + return HDF_SUCCESS; +} + +int32_t AudioLibRenderTest::BindServiceAndHwRender(struct AudioHwRender *&hwRender, + const std::string BindName, const std::string adapterNameCase, struct DevHandle *&handle) const +{ + handle = BindServiceRenderSo(BindName.c_str()); + if (handle == nullptr) { return HDF_FAILURE; } - hwRender->renderParam.renderMode.hwInfo.card = AUDIO_SERVICE_IN; - ret = strcpy_s(hwRender->renderParam.renderMode.hwInfo.adapterName, - NAME_LEN, adapterNameCase.c_str()); - if (ret < 0) { + hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); + if (hwRender == nullptr) { + CloseServiceRenderSo(handle); return HDF_FAILURE; } - if (InitAttrs(attrs)) { + if (InitHwRender(hwRender, adapterNameCase)) { + CloseServiceRenderSo(handle); + free(hwRender); + hwRender = nullptr; return HDF_FAILURE; } return HDF_SUCCESS; @@ -290,7 +283,7 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLib_BindServiceRender_0001, Test /** * @tc.name test BindServiceRenderSo API via invalid input. * @tc.number SUB_Audio_InterfaceLib_BindServiceRender_0002 -* @tc.desc test Binding failed Service which invalid service Name is rendeo. +* @tc.desc test Binding failed service, where the service name is wrong. * @tc.author: zhouyongxiao */ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLib_BindServiceRender_0002, TestSize.Level1) @@ -357,360 +350,149 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLib_BindServiceRender_0005, Test /** * @tc.name test InterfaceLibCtlRender API via writing volume value of AcodecIn is normal value and reading * this value. -* @tc.number SUB_Audio_InterfaceLibCtlRender_Volum_AcodecIn_Write_Read_0001 +* @tc.number SUB_Audio_InterfaceLibCtlRender_Volume_AcodecIn_Write_Read_0001 * @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ. * @tc.author: zhouyongxiao */ -HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_Volum_AcodecIn_Write_Read_0001, TestSize.Level1) +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_Volume_AcodecIn_Write_Read_0001, TestSize.Level1) { int32_t ret = -1; - float volumevalue = 0; - float volumeThresholdValueMax = 0; - float volumeThresholdValueMin = 0; + float volumeValue = 0; + float volumeThresholdValueMaxIn = 0; + float volumeThresholdValueMinIn = 0; + float volumeBoundaryValueIn = 127.9; struct DevHandle *handle = nullptr; - handle = BindServiceRenderSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); - if (hwRender == nullptr) { - CloseServiceRenderSo(handle); - ASSERT_NE(nullptr, handle); - } - ret = InitHwRenderMode(hwRender->renderParam.renderMode); - EXPECT_EQ(HDF_SUCCESS, ret); + struct AudioHwRender *hwRender = nullptr; + ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + hwRender->renderParam.renderMode.hwInfo.card = AUDIO_SERVICE_IN; - ret = strcpy_s(hwRender->renderParam.renderMode.hwInfo.adapterName, - NAME_LEN, ADAPTER_NAME_USB.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); - volumeThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax; - volumeThresholdValueMin = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin; + volumeThresholdValueMaxIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax; + volumeThresholdValueMinIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin; - hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMax-1; + hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMaxIn - 1; ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); - volumevalue = hwRender->renderParam.renderMode.ctlParam.volume; - EXPECT_EQ(126, volumevalue); + volumeValue = hwRender->renderParam.renderMode.ctlParam.volume; + EXPECT_EQ(126, volumeValue); - hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMin+1; + hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMinIn + 1; ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); - volumevalue = hwRender->renderParam.renderMode.ctlParam.volume; - EXPECT_EQ(41, volumevalue); - - hwRender->renderParam.renderMode.ctlParam.volume = 127.9; + volumeValue = hwRender->renderParam.renderMode.ctlParam.volume; + if (IS_ADM) { + EXPECT_EQ(41, volumeValue); + } else { + EXPECT_EQ(1, volumeValue); + } + hwRender->renderParam.renderMode.ctlParam.volume = volumeBoundaryValueIn; ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); - volumevalue = hwRender->renderParam.renderMode.ctlParam.volume; - EXPECT_EQ(127, volumevalue); - + volumeValue = hwRender->renderParam.renderMode.ctlParam.volume; + EXPECT_EQ(127, volumeValue); CloseServiceRenderSo(handle); free(hwRender); + hwRender = nullptr; } /** * @tc.name test InterfaceLibCtlRender API via writing volume value of AcodecIn is boundary value and reading * this value. -* @tc.number SUB_Audio_InterfaceLibCtlRender_Volum_AcodecIn_Write_Read_0002 +* @tc.number SUB_Audio_InterfaceLibCtlRender_Volume_AcodecIn_Write_Read_0002 * @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ. * @tc.author: zhouyongxiao */ -HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_Volum_AcodecIn_Write_Read_0002, TestSize.Level1) +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_Volume_AcodecIn_Write_Read_0002, TestSize.Level1) { int32_t ret = -1; - float volumevalue = 0; - float volumeThresholdValueMax = 0; - float volumeThresholdValueMin = 0; + struct AudioHwRender *hwRender = nullptr; struct DevHandle *handle = nullptr; - handle = BindServiceRenderSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); - if (hwRender == nullptr) { - CloseServiceRenderSo(handle); - ASSERT_NE(nullptr, handle); - } - ret = InitHwRenderMode(hwRender->renderParam.renderMode); - EXPECT_EQ(HDF_SUCCESS, ret); - hwRender->renderParam.renderMode.hwInfo.card = AUDIO_SERVICE_IN; - ret = strcpy_s(hwRender->renderParam.renderMode.hwInfo.adapterName, - NAME_LEN, ADAPTER_NAME_USB.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN, &hwRender->renderParam); - EXPECT_EQ(HDF_SUCCESS, ret); - - ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam); - EXPECT_EQ(HDF_SUCCESS, ret); - volumeThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax; - volumeThresholdValueMin = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin; + float volumeThresholdValueMaxIn = 0; + float volumeThresholdValueMinIn = 0; + float volumeValue = 0; + ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle); + ASSERT_EQ(HDF_SUCCESS, ret); - hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMax; - ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam); - EXPECT_EQ(HDF_SUCCESS, ret); - volumevalue = hwRender->renderParam.renderMode.ctlParam.volume; - EXPECT_EQ(127, volumevalue); - - hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMin; - ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam); - EXPECT_EQ(HDF_SUCCESS, ret); - volumevalue = hwRender->renderParam.renderMode.ctlParam.volume; - EXPECT_EQ(40, volumevalue); - CloseServiceRenderSo(handle); - free(hwRender); -} -/** -* @tc.name test InterfaceLibCtlRender API via writing volume value is invalid value of AcodecIn. -* @tc.number SUB_Audio_InterfaceLibCtlRender_Volum_AcodecIn_Write_Read_0003 -* @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ. -* @tc.author: zhouyongxiao -*/ -HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_Volum_AcodecIn_Write_Read_0003, TestSize.Level1) -{ - int32_t ret = -1; - float volumeThresholdValueMax = 0; - float volumeThresholdValueMin = 0; - struct DevHandle *handle = nullptr; - handle = BindServiceRenderSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); - if (hwRender == nullptr) { - CloseServiceRenderSo(handle); - ASSERT_NE(nullptr, handle); - } - ret = InitHwRenderMode(hwRender->renderParam.renderMode); - EXPECT_EQ(HDF_SUCCESS, ret); hwRender->renderParam.renderMode.hwInfo.card = AUDIO_SERVICE_IN; - ret = strcpy_s(hwRender->renderParam.renderMode.hwInfo.adapterName, - NAME_LEN, ADAPTER_NAME_USB.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); - volumeThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax; - volumeThresholdValueMin = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin; - - hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMax + 1; - ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam); - EXPECT_EQ(HDF_FAILURE, ret); - - hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMin - 1; - ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam); - EXPECT_EQ(HDF_FAILURE, ret); - - CloseServiceRenderSo(handle); - free(hwRender); -} -/** -* @tc.name test InterfaceLibCtlRender API via writing volume value of smartpa is normal value and reading -* this value. -* @tc.number SUB_Audio_InterfaceLibCtlRender_Volum_AcodecOut_Write_Read_0001 -* @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ. -* @tc.author: zhouyongxiao -*/ -HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_Volum_AcodecOut_Write_Read_0001, TestSize.Level1) -{ - int32_t ret = -1; - float volumevalue = 0; - float volumeThresholdValueMax = 0; - float volumeThresholdValueMin = 0; - struct DevHandle *handle = nullptr; - handle = BindServiceRenderSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); - if (hwRender == nullptr) { - CloseServiceRenderSo(handle); - ASSERT_NE(nullptr, handle); - } - ret = InitHwRenderMode(hwRender->renderParam.renderMode); - EXPECT_EQ(HDF_SUCCESS, ret); - hwRender->renderParam.renderMode.hwInfo.card = AUDIO_SERVICE_OUT; - ret = strcpy_s(hwRender->renderParam.renderMode.hwInfo.adapterName, - NAME_LEN, ADAPTER_NAME_HDIMI.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN, &hwRender->renderParam); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam); - EXPECT_EQ(HDF_SUCCESS, ret); - volumeThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax; - volumeThresholdValueMin = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin; - - hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMax-1; - ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam); - EXPECT_EQ(HDF_SUCCESS, ret); - volumevalue = hwRender->renderParam.renderMode.ctlParam.volume; - EXPECT_EQ(187, volumevalue); - - hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMin+1; - ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam); - EXPECT_EQ(HDF_SUCCESS, ret); - volumevalue = hwRender->renderParam.renderMode.ctlParam.volume; - EXPECT_EQ(1, volumevalue); + volumeThresholdValueMaxIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax; + volumeThresholdValueMinIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin; - hwRender->renderParam.renderMode.ctlParam.volume = 127.9; + hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMinIn; ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); - volumevalue = hwRender->renderParam.renderMode.ctlParam.volume; - EXPECT_EQ(127, volumevalue); - - CloseServiceRenderSo(handle); - free(hwRender); -} -/** -* @tc.name test InterfaceLibCtlRender API via writing volume value of smartpa is boundary value and reading -* this value. -* @tc.number SUB_Audio_InterfaceLibCtlRender_Volum_AcodecOut_Write_Read_0002 -* @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ. -* @tc.author: zhouyongxiao -*/ -HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_Volum_AcodecOut_Write_Read_0002, TestSize.Level1) -{ - int32_t ret = -1; - float volumevalue = 0; - float volumeThresholdValueMax = 0; - float volumeThresholdValueMin = 0; - struct DevHandle *handle = nullptr; - handle = BindServiceRenderSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); - if (hwRender == nullptr) { - CloseServiceRenderSo(handle); - ASSERT_NE(nullptr, handle); + volumeValue = hwRender->renderParam.renderMode.ctlParam.volume; + if (IS_ADM == false) { + EXPECT_EQ(0, volumeValue); + } else { + EXPECT_EQ(40, volumeValue); } - ret = InitHwRenderMode(hwRender->renderParam.renderMode); - EXPECT_EQ(HDF_SUCCESS, ret); - hwRender->renderParam.renderMode.hwInfo.card = AUDIO_SERVICE_OUT; - ret = strcpy_s(hwRender->renderParam.renderMode.hwInfo.adapterName, - NAME_LEN, ADAPTER_NAME_HDIMI.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN, &hwRender->renderParam); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam); - EXPECT_EQ(HDF_SUCCESS, ret); - volumeThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax; - volumeThresholdValueMin = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin; - - hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMax; + hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMaxIn; ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); - volumevalue = hwRender->renderParam.renderMode.ctlParam.volume; - EXPECT_EQ(188, volumevalue); + volumeValue = hwRender->renderParam.renderMode.ctlParam.volume; + EXPECT_EQ(127, volumeValue); - hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMin; - ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam); - EXPECT_EQ(HDF_SUCCESS, ret); - volumevalue = hwRender->renderParam.renderMode.ctlParam.volume; - EXPECT_EQ(0, volumevalue); CloseServiceRenderSo(handle); free(hwRender); + hwRender = nullptr; } /** -* @tc.name test InterfaceLibCtlRender API via writing volume value of smartpa is invalid value. -* @tc.number SUB_Audio_InterfaceLibCtlRender_Volum_AcodecOut_Write_Read_0003 +* @tc.name test InterfaceLibCtlRender API via writing volume value is invalid value of AcodecIn. +* @tc.number SUB_Audio_InterfaceLibCtlRender_Volume_AcodecIn_Write_Read_0003 * @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ. * @tc.author: zhouyongxiao */ -HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_Volum_AcodecOut_Write_Read_0003, TestSize.Level1) +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_Volume_AcodecIn_Write_Read_0003, TestSize.Level1) { int32_t ret = -1; - float volumeThresholdValueMax = 0; - float volumeThresholdValueMin = 0; struct DevHandle *handle = nullptr; - handle = BindServiceRenderSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); - if (hwRender == nullptr) { - CloseServiceRenderSo(handle); - ASSERT_NE(nullptr, handle); - } - ret = InitHwRenderMode(hwRender->renderParam.renderMode); - EXPECT_EQ(HDF_SUCCESS, ret); - hwRender->renderParam.renderMode.hwInfo.card = AUDIO_SERVICE_OUT; - ret = strcpy_s(hwRender->renderParam.renderMode.hwInfo.adapterName, - NAME_LEN, ADAPTER_NAME_HDIMI.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); + struct AudioHwRender *hwRender = nullptr; + float volumeThresholdValueMaxIn = 0; + float volumeThresholdValueMinIn = 0; + + ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + hwRender->renderParam.renderMode.hwInfo.card = AUDIO_SERVICE_IN; ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); - volumeThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax; - volumeThresholdValueMin = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin; + volumeThresholdValueMaxIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax; + volumeThresholdValueMinIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin; - hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMax + 1; + hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMaxIn + 1; ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam); EXPECT_EQ(HDF_FAILURE, ret); - hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMin - 1; + hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMinIn - 1; ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam); EXPECT_EQ(HDF_FAILURE, ret); CloseServiceRenderSo(handle); free(hwRender); + hwRender = nullptr; } -/** -* @tc.name test InterfaceLibCtlRender API via writing GetVolthreshold value that -* Hardware equipment of Acodec_ChangeOut. -* @tc.number SUB_Audio_InterfaceLibCtlRender_GetVolthresholdRead_0001 -* @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ. -* @tc.author: zhouyongxiao -*/ -HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_GetVolthresholdRead_0001, TestSize.Level1) -{ - int32_t ret = -1; - float volumeThresholdValueMax = 0; - float volumeThresholdValueMin = 0; - float expMax = 188; - float expMix = 0; - struct DevHandle *handle = nullptr; - handle = BindServiceRenderSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); - if (hwRender == nullptr) { - CloseServiceRenderSo(handle); - ASSERT_NE(nullptr, handle); - } - ret = InitHwRenderMode(hwRender->renderParam.renderMode); - EXPECT_EQ(HDF_SUCCESS, ret); - hwRender->renderParam.renderMode.hwInfo.card = AUDIO_SERVICE_OUT; - ret = strcpy_s(hwRender->renderParam.renderMode.hwInfo.adapterName, - NAME_LEN, ADAPTER_NAME_HDIMI.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_OUT, &hwRender->renderParam); - EXPECT_EQ(HDF_SUCCESS, ret); - - ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam); - EXPECT_EQ(HDF_SUCCESS, ret); - volumeThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax; - volumeThresholdValueMin = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin; - EXPECT_EQ(expMax, volumeThresholdValueMax); - EXPECT_EQ(expMix, volumeThresholdValueMin); - CloseServiceRenderSo(handle); - free(hwRender); -} /** * @tc.name test InterfaceLibCtlRender API via writing GetVolthreshold value that * Hardware equipment of Acodec_ChangeIn. @@ -721,35 +503,31 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_GetVolthresholdRead HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_GetVolthresholdRead_0002, TestSize.Level1) { int32_t ret = -1; - float volumeThresholdValueMax = 0; - float volumeThresholdValueMin = 0; + float volumeThresholdValueMaxIn = 0; + float volumeThresholdValueMinIn = 0; float expMax = 127; float expMix = 40; + struct AudioHwRender *hwRender = nullptr; struct DevHandle *handle = nullptr; - handle = BindServiceRenderSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); - if (hwRender == nullptr) { - CloseServiceRenderSo(handle); - ASSERT_NE(nullptr, handle); - } - ret = InitHwRenderMode(hwRender->renderParam.renderMode); - EXPECT_EQ(HDF_SUCCESS, ret); + ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle); + ASSERT_EQ(HDF_SUCCESS, ret); hwRender->renderParam.renderMode.hwInfo.card = AUDIO_SERVICE_IN; - ret = strcpy_s(hwRender->renderParam.renderMode.hwInfo.adapterName, - NAME_LEN, ADAPTER_NAME_USB.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); - volumeThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax; - volumeThresholdValueMin = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin; - EXPECT_EQ(expMax, volumeThresholdValueMax); - EXPECT_EQ(expMix, volumeThresholdValueMin); + volumeThresholdValueMaxIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax; + volumeThresholdValueMinIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin; + EXPECT_EQ(expMax, volumeThresholdValueMaxIn); + if (IS_ADM == false) { + EXPECT_EQ(0, volumeThresholdValueMinIn); + } else { + EXPECT_EQ(expMix, volumeThresholdValueMinIn); + } CloseServiceRenderSo(handle); free(hwRender); + hwRender = nullptr; } /** * @tc.name test InterfaceLibCtlRender API via writing ChannelMode value is normal value and reading this value. @@ -763,21 +541,19 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_ChannelMode_Write_R int32_t ret = -1; float channelModeExc = 1; struct DevHandle *handle = nullptr; - handle = BindServiceRenderSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwRender *impl = (struct AudioHwRender *)calloc(1, sizeof(struct AudioHwRender)); - if (impl == nullptr) { + struct DevHandle *handleRender = nullptr; + struct AudioHwRender *impl = nullptr; + ret = BindServiceAndHwRender(impl, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + handleRender = BindServiceRenderSo(BIND_RENDER.c_str()); + if (handleRender == nullptr) { CloseServiceRenderSo(handle); - ASSERT_NE(nullptr, handle); + free(impl); + impl = nullptr; + ASSERT_NE(nullptr, handleRender); } - ret = InitHwRenderMode(impl->renderParam.renderMode); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = strcpy_s(impl->renderParam.renderMode.hwInfo.adapterName, - NAME_LEN, ADAPTER_NAME_USB.c_str()); + ret = LibHwOutputRender(impl, handleRender); EXPECT_EQ(HDF_SUCCESS, ret); - ret = InitRenderFramepara(impl->renderParam.frameRenderMode); - EXPECT_EQ(HDF_SUCCESS, ret); - impl->renderParam.frameRenderMode.mode = AUDIO_CHANNEL_BOTH_RIGHT; ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE, &impl->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); @@ -793,9 +569,10 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_ChannelMode_Write_R EXPECT_EQ(HDF_SUCCESS, ret); channelModeExc = impl->renderParam.frameRenderMode.mode; EXPECT_EQ(AUDIO_CHANNEL_RIGHT_MUTE, channelModeExc); - + CloseServiceRenderSo(handleRender); CloseServiceRenderSo(handle); free(impl); + impl = nullptr; } /** * @tc.name test InterfaceLibCtlRender API via writing ChannelMode value is boundary value and reading this value. @@ -808,22 +585,20 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_ChannelMode_Write_R { int32_t ret = -1; float channelModeExc = 1; + struct DevHandle *handleRender = nullptr; struct DevHandle *handle = nullptr; - handle = BindServiceRenderSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwRender *impl = (struct AudioHwRender *)calloc(1, sizeof(struct AudioHwRender)); - if (impl == nullptr) { + struct AudioHwRender *impl = nullptr; + ret = BindServiceAndHwRender(impl, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + handleRender = BindServiceRenderSo(BIND_RENDER.c_str()); + if (handleRender == nullptr) { + free(impl); + impl = nullptr; CloseServiceRenderSo(handle); - ASSERT_NE(nullptr, handle); + ASSERT_NE(nullptr, handleRender); } - ret = InitHwRenderMode(impl->renderParam.renderMode); + ret = LibHwOutputRender(impl, handleRender); EXPECT_EQ(HDF_SUCCESS, ret); - ret = strcpy_s(impl->renderParam.renderMode.hwInfo.adapterName, - NAME_LEN, ADAPTER_NAME_USB.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InitRenderFramepara(impl->renderParam.frameRenderMode); - EXPECT_EQ(HDF_SUCCESS, ret); - impl->renderParam.frameRenderMode.mode = AUDIO_CHANNEL_NORMAL; ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE, &impl->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); @@ -839,9 +614,10 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_ChannelMode_Write_R EXPECT_EQ(HDF_SUCCESS, ret); channelModeExc = impl->renderParam.frameRenderMode.mode; EXPECT_EQ(AUDIO_CHANNEL_BOTH_MUTE, channelModeExc); - + CloseServiceRenderSo(handleRender); CloseServiceRenderSo(handle); free(impl); + impl = nullptr; } /** * @tc.name test InterfaceLibCtlRender API via writing mute value that include 1 and 0 and reading mute value. @@ -856,18 +632,10 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_MuteWrite_Read_0001 bool wishValue = 0; bool expectedValue = 1; struct DevHandle *handle = nullptr; - handle = BindServiceRenderSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); - if (hwRender == nullptr) { - CloseServiceRenderSo(handle); - ASSERT_NE(nullptr, handle); - } - ret = InitHwRenderMode(hwRender->renderParam.renderMode); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = strcpy_s(hwRender->renderParam.renderMode.hwInfo.adapterName, - NAME_LEN, ADAPTER_NAME_USB.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); + struct AudioHwRender *hwRender = nullptr; + ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + hwRender->renderParam.renderMode.ctlParam.mute = 0; ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_MUTE_WRITE, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); @@ -884,6 +652,7 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_MuteWrite_Read_0001 EXPECT_EQ(expectedValue, muteValue); CloseServiceRenderSo(handle); free(hwRender); + hwRender = nullptr; } /** * @tc.name test InterfaceLibCtlRender API via writing mute value that include 2 and reading mute value. @@ -894,30 +663,31 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_MuteWrite_Read_0001 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_MuteWrite_Read_0002, TestSize.Level1) { int32_t ret = -1; - bool mutevalue = 0; + bool muteValue = 0; + bool wishValue = 0; bool expectedValue = 1; struct DevHandle *handle = nullptr; - handle = BindServiceRenderSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); - if (hwRender == nullptr) { - CloseServiceRenderSo(handle); - ASSERT_NE(nullptr, handle); - } - ret = InitHwRenderMode(hwRender->renderParam.renderMode); + struct AudioHwRender *hwRender = nullptr; + ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + + hwRender->renderParam.renderMode.ctlParam.mute = 2; + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_MUTE_WRITE, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); - ret = strcpy_s(hwRender->renderParam.renderMode.hwInfo.adapterName, - NAME_LEN, ADAPTER_NAME_USB.c_str()); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_MUTE_READ, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); - hwRender->renderParam.renderMode.ctlParam.mute = 2; + muteValue = hwRender->renderParam.renderMode.ctlParam.mute; + EXPECT_EQ(expectedValue, muteValue); + hwRender->renderParam.renderMode.ctlParam.mute = 0; ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_MUTE_WRITE, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_MUTE_READ, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); - mutevalue = hwRender->renderParam.renderMode.ctlParam.mute; - EXPECT_EQ(expectedValue, mutevalue); + muteValue = hwRender->renderParam.renderMode.ctlParam.mute; + EXPECT_EQ(wishValue, muteValue); CloseServiceRenderSo(handle); free(hwRender); + hwRender = nullptr; } /** * @tc.name test InterfaceLibCtlRender API via selecting scene. @@ -929,21 +699,9 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLib_CtlRender_SelectScene_0001, { int32_t ret = -1; struct DevHandle *handle = nullptr; - handle = BindServiceRenderSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - - struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); - if (hwRender == nullptr) { - CloseServiceRenderSo(handle); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = InitHwRenderMode(hwRender->renderParam.renderMode); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = strcpy_s(hwRender->renderParam.renderMode.hwInfo.adapterName, - NAME_LEN, ADAPTER_NAME_USB.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InitRenderFramepara(hwRender->renderParam.frameRenderMode); - EXPECT_EQ(HDF_SUCCESS, ret); + struct AudioHwRender *hwRender = nullptr; + ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle); + ASSERT_EQ(HDF_SUCCESS, ret); struct AudioSceneDescriptor scene = { .scene.id = 0, @@ -961,6 +719,7 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLib_CtlRender_SelectScene_0001, CloseServiceRenderSo(handle); free(hwRender); + hwRender = nullptr; } /** * @tc.name test InterfaceLibCtlRender API via writing normal gain value. @@ -971,22 +730,20 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLib_CtlRender_SelectScene_0001, HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_GainWrite_Read_0001, TestSize.Level1) { int32_t ret = -1; - float gainValue = 0; + struct AudioHwRender *hwRender = nullptr; struct DevHandle *handle = nullptr; + float gainValue = 0; float gainThresholdValueMax, gainThresholdValueMin; - handle = BindServiceRenderSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); - if (hwRender == nullptr) { - CloseServiceRenderSo(handle); - ASSERT_NE(nullptr, handle); - } + ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); gainThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMax; gainThresholdValueMin = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMin; ret = InitHwRenderMode(hwRender->renderParam.renderMode); EXPECT_EQ(HDF_SUCCESS, ret); + hwRender->renderParam.renderMode.ctlParam.audioGain.gain = gainThresholdValueMax - 1; ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); @@ -1010,6 +767,7 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_GainWrite_Read_0001 EXPECT_EQ(2, gainValue); CloseServiceRenderSo(handle); free(hwRender); + hwRender = nullptr; } /** * @tc.name test InterfaceLibCtlRender API via writing boundary value of gain and reading gain value. @@ -1021,15 +779,12 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_GainWrite_Read_0002 { int32_t ret = -1; float gainValue = 0; - struct DevHandle *handle = nullptr; float gainThresholdValueMax, gainThresholdValueMin; - handle = BindServiceRenderSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); - if (hwRender == nullptr) { - CloseServiceRenderSo(handle); - ASSERT_NE(nullptr, handle); - } + struct DevHandle *handle = nullptr; + struct AudioHwRender *hwRender = nullptr; + ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); gainThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMax; @@ -1052,6 +807,7 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_GainWrite_Read_0002 EXPECT_EQ(gainThresholdValueMax, gainValue); CloseServiceRenderSo(handle); free(hwRender); + hwRender = nullptr; } /** * @tc.name test InterfaceLibCtlRender API via writing gain invalid value. @@ -1062,15 +818,12 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_GainWrite_Read_0002 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_GainWrite_Read_0003, TestSize.Level1) { int32_t ret = -1; - struct DevHandle *handle = nullptr; float gainThresholdValueMax, gainThresholdValueMin; - handle = BindServiceRenderSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); - if (hwRender == nullptr) { - CloseServiceRenderSo(handle); - ASSERT_NE(nullptr, handle); - } + struct AudioHwRender *hwRender = nullptr; + struct DevHandle *handle = nullptr; + ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); gainThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMax; @@ -1085,6 +838,7 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_GainWrite_Read_0003 EXPECT_EQ(HDF_FAILURE, ret); CloseServiceRenderSo(handle); free(hwRender); + hwRender = nullptr; } /** * @tc.name test InterfaceLibCtlRender API via getting gainthreshold value. @@ -1095,25 +849,23 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_GainWrite_Read_0003 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_GetGainthresholdRead_0001, TestSize.Level1) { int32_t ret = -1; - float gainThresholdValueMax, gainThresholdValueMin; + float gainThresholdValueMaxGet, gainThresholdValueMinGet; float expMax = 10; float expMix = 0; struct DevHandle *handle = nullptr; - handle = BindServiceRenderSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); - if (hwRender == nullptr) { - CloseServiceRenderSo(handle); - ASSERT_NE(nullptr, handle); - } + struct AudioHwRender *hwRender = nullptr; + ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); - gainThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMax; - gainThresholdValueMin = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMin; - EXPECT_LT(expMax, gainThresholdValueMax); - EXPECT_EQ(expMix, gainThresholdValueMin); + gainThresholdValueMaxGet = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMax; + gainThresholdValueMinGet = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMin; + EXPECT_LT(expMax, gainThresholdValueMaxGet); + EXPECT_EQ(expMix, gainThresholdValueMinGet); CloseServiceRenderSo(handle); free(hwRender); + hwRender = nullptr; } /** * @tc.name test InterfaceLibCtlRender API via using Acodec_ChangeIn. @@ -1125,53 +877,16 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_Acodec_ChangeIn_000 { int32_t ret = -1; struct DevHandle *handle = nullptr; - handle = BindServiceRenderSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); - if (hwRender == nullptr) { - CloseServiceRenderSo(handle); - ASSERT_NE(nullptr, handle); - } - ret = InitHwRenderMode(hwRender->renderParam.renderMode); - EXPECT_EQ(HDF_SUCCESS, ret); - hwRender->renderParam.renderMode.hwInfo.card = AUDIO_SERVICE_IN; - ret = strcpy_s(hwRender->renderParam.renderMode.hwInfo.adapterName, - NAME_LEN, ADAPTER_NAME_USB.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); + struct AudioHwRender *hwRender = nullptr; + ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + hwRender->renderParam.renderMode.hwInfo.card = AUDIO_SERVICE_IN; ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); CloseServiceRenderSo(handle); free(hwRender); -} -/** -* @tc.name test InterfaceLibCtlRender API via using smartpa. -* @tc.number SUB_Audio_InterfaceLibCtlRender_Acodec_ChangeOut_0001 -* @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_OUT. -* @tc.author: zhouyongxiao -*/ -HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_Acodec_ChangeOut_0001, TestSize.Level1) -{ - int32_t ret = -1; - struct DevHandle *handle = nullptr; - handle = BindServiceRenderSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); - if (hwRender == nullptr) { - CloseServiceRenderSo(handle); - ASSERT_NE(nullptr, handle); - } - ret = InitHwRenderMode(hwRender->renderParam.renderMode); - EXPECT_EQ(HDF_SUCCESS, ret); - hwRender->renderParam.renderMode.hwInfo.card = AUDIO_SERVICE_OUT; - ret = strcpy_s(hwRender->renderParam.renderMode.hwInfo.adapterName, - NAME_LEN, ADAPTER_NAME_HDIMI.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); - - ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_OUT, &hwRender->renderParam); - EXPECT_EQ(HDF_SUCCESS, ret); - CloseServiceRenderSo(handle); - free(hwRender); + hwRender = nullptr; } /** * @tc.name test InterfaceLibCtlRender API via inputting invalid cmdid. @@ -1183,27 +898,21 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_Abnormal_0001, Test { int32_t ret = -1; struct DevHandle *handle = nullptr; - handle = BindServiceRenderSo(BIND_CONTROL.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); - if (hwRender == nullptr) { - CloseServiceRenderSo(handle); - ASSERT_NE(nullptr, handle); - } - ret = InitHwRenderMode(hwRender->renderParam.renderMode); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = strcpy_s(hwRender->renderParam.renderMode.hwInfo.adapterName, - NAME_LEN, ADAPTER_NAME_USB.c_str()); - EXPECT_EQ(HDF_SUCCESS, ret); + struct AudioHwRender *hwRender = nullptr; + ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlRender(handle, 50, &hwRender->renderParam); if (ret == 0) { CloseServiceRenderSo(handle); free(hwRender); + hwRender = nullptr; ASSERT_EQ(HDF_FAILURE, ret); } EXPECT_EQ(HDF_FAILURE, ret); CloseServiceRenderSo(handle); free(hwRender); + hwRender = nullptr; } /** * @tc.name test InterfaceLibCtlRender API via inputting handleData invalid. @@ -1237,20 +946,15 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_HwParams_0001, T { int32_t ret = -1; struct DevHandle *handle = nullptr; - struct AudioSampleAttributes attrs = {}; - handle = BindServiceRenderSo(BIND_RENDER.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); - if (hwRender == nullptr) { - CloseServiceRenderSo(handle); - ASSERT_NE(nullptr, handle); - } - ret = InitHwRender(hwRender, attrs, ADAPTER_NAME_USB); - EXPECT_EQ(HDF_SUCCESS, ret); + struct AudioHwRender *hwRender = nullptr; + ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME_USB, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); CloseServiceRenderSo(handle); free(hwRender); + hwRender = nullptr; } /** * @tc.name test InterfaceLibOutputRender API via cmdid is AUDIO_DRV_PCM_IOCTL_PREPARE. @@ -1261,23 +965,18 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_HwParams_0001, T HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Prepare_0001, TestSize.Level1) { int32_t ret = -1; + struct AudioHwRender *hwRender = nullptr; struct DevHandle *handle = nullptr; - struct AudioSampleAttributes attrs = {}; - handle = BindServiceRenderSo(BIND_RENDER.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); - if (hwRender == nullptr) { - CloseServiceRenderSo(handle); - ASSERT_NE(nullptr, handle); - } - ret = InitHwRender(hwRender, attrs, ADAPTER_NAME_USB); - EXPECT_EQ(HDF_SUCCESS, ret); + ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME_USB, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_PREPARE, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); CloseServiceRenderSo(handle); free(hwRender); + hwRender = nullptr; } /** * @tc.name test InterfaceLibOutputRender API via cmdid is AUDIO_DRV_PCM_IOCTRL_START. @@ -1289,16 +988,10 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Start_0001, Test { int32_t ret = -1; struct DevHandle *handle = nullptr; - struct AudioSampleAttributes attrs = {}; - handle = BindServiceRenderSo(BIND_RENDER.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); - if (hwRender == nullptr) { - CloseServiceRenderSo(handle); - ASSERT_NE(nullptr, handle); - } - ret = InitHwRender(hwRender, attrs, ADAPTER_NAME_USB); - EXPECT_EQ(HDF_SUCCESS, ret); + struct AudioHwRender *hwRender = nullptr; + ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME_USB, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_PREPARE, &hwRender->renderParam); @@ -1307,6 +1000,7 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Start_0001, Test EXPECT_EQ(HDF_SUCCESS, ret); CloseServiceRenderSo(handle); free(hwRender); + hwRender = nullptr; } /** * @tc.name test InterfaceLibOutputRender API via cmdid is AUDIO_DRV_PCM_IOCTL_WRITE and AUDIO_DRV_PCM_IOCTRL_STOP. @@ -1318,25 +1012,18 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Write_Stop_0001, { int32_t ret = -1; struct DevHandle *handle = nullptr; - struct AudioSampleAttributes attrs = {}; struct AudioHeadInfo wavHeadInfo = {}; - handle = BindServiceRenderSo(BIND_RENDER.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); - if (hwRender == nullptr) { - CloseServiceRenderSo(handle); - ASSERT_NE(nullptr, handle); - } - ret = InitHwRender(hwRender, attrs, ADAPTER_NAME_USB); - EXPECT_EQ(HDF_SUCCESS, ret); + struct AudioHwRender *hwRender = nullptr; + ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME_USB, handle); + ASSERT_EQ(HDF_SUCCESS, ret); ret = LibHwOutputRender(hwRender, handle); EXPECT_EQ(HDF_SUCCESS, ret); char absPath[PATH_MAX] = {0}; - if (realpath(AUDIO_FILE_PATH.c_str(), absPath) == nullptr) { + if (realpath(AUDIO_FILE.c_str(), absPath) == nullptr) { free(hwRender); hwRender = nullptr; CloseServiceRenderSo(handle); - ASSERT_NE(nullptr, realpath(AUDIO_FILE_PATH.c_str(), absPath)); + ASSERT_NE(nullptr, realpath(AUDIO_FILE.c_str(), absPath)); } FILE *file = fopen(absPath, "rb"); if (file == nullptr) { @@ -1345,7 +1032,7 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Write_Stop_0001, CloseServiceRenderSo(handle); ASSERT_NE(nullptr, file); } - ret = WavHeadAnalysis(wavHeadInfo, file, attrs); + ret = WavHeadAnalysis(wavHeadInfo, file, hwRender->renderParam.frameRenderMode.attrs); if (ret < 0) { free(hwRender); hwRender = nullptr; @@ -1353,18 +1040,19 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Write_Stop_0001, CloseServiceRenderSo(handle); ASSERT_EQ(HDF_SUCCESS, ret); } - ret = FrameLibStart(file, attrs, wavHeadInfo, hwRender); + ret = FrameLibStart(file, hwRender->renderParam.frameRenderMode.attrs, wavHeadInfo, hwRender); EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_WRITE, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_STOP, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); CloseServiceRenderSo(handle); + free(hwRender->renderParam.frameRenderMode.buffer); + hwRender->renderParam.frameRenderMode.buffer = nullptr; free(hwRender); hwRender = nullptr; fclose(file); } - /** * @tc.name test InterfaceLibCtlRender and InterfaceLibOutputRender API via Serial transmission of data flow and control flow. @@ -1375,27 +1063,22 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Write_Stop_0001, HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Write_0001, TestSize.Level1) { int32_t ret = -1; - float muteValue = 1; + float muteValue = 0; float expectedValue = 0; struct DevHandle *handler = nullptr; struct DevHandle *handlec = nullptr; - struct AudioSampleAttributes attrs = {}; struct AudioHeadInfo wavHeadInfo = {}; - handler = BindServiceRenderSo(BIND_RENDER.c_str()); - ASSERT_NE(nullptr, handler); + struct AudioHwRender *hwRender = nullptr; + ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME_USB, handler); + ASSERT_EQ(HDF_SUCCESS, ret); handlec = BindServiceRenderSo(BIND_CONTROL.c_str()); if (handlec == nullptr) { CloseServiceRenderSo(handler); + free(hwRender); + hwRender = nullptr; ASSERT_NE(nullptr, handlec); } - struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); - if (hwRender == nullptr) { - CloseServiceRenderSo(handler); - CloseServiceRenderSo(handlec); - ASSERT_NE(nullptr, hwRender); - } - ret = InitHwRender(hwRender, attrs, ADAPTER_NAME_USB); - EXPECT_EQ(HDF_SUCCESS, ret); + hwRender->renderParam.renderMode.ctlParam.mute = muteValue; ret = InterfaceLibCtlRender(handlec, AUDIODRV_CTL_IOCTL_MUTE_WRITE, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); @@ -1403,15 +1086,15 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Write_0001, Test EXPECT_EQ(HDF_SUCCESS, ret); expectedValue = hwRender->renderParam.renderMode.ctlParam.mute; EXPECT_EQ(expectedValue, muteValue); - ret = LibStartAndStream(AUDIO_FILE_PATH, attrs, handler, hwRender, wavHeadInfo); + + ret = LibStartAndStream(AUDIO_FILE, hwRender->renderParam.frameRenderMode.attrs, + handler, hwRender, wavHeadInfo); if (ret < 0) { CloseServiceRenderSo(handler); CloseServiceRenderSo(handlec); free(hwRender); - hwRender = nullptr; ASSERT_EQ(HDF_SUCCESS, ret); } - ret = InterfaceLibOutputRender(handler, AUDIO_DRV_PCM_IOCTRL_STOP, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); CloseServiceRenderSo(handler); @@ -1429,19 +1112,17 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Pause_0001, Test { int32_t ret = -1; struct DevHandle *handle = nullptr; - handle = BindServiceRenderSo(BIND_RENDER.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); - if (hwRender == nullptr) { - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = InitHwRenderMode(hwRender->renderParam.renderMode); + struct AudioHwRender *hwRender = nullptr; + ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME_USB, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = LibHwOutputRender(hwRender, handle); EXPECT_EQ(HDF_SUCCESS, ret); hwRender->renderParam.renderMode.ctlParam.pause = 1; ret = InterfaceLibOutputRender(handle, AUDIODRV_CTL_IOCTL_PAUSE_WRITE, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); CloseServiceRenderSo(handle); free(hwRender); + hwRender = nullptr; } /** * @tc.name test InterfaceLibOutputRender API via resuming. @@ -1453,19 +1134,17 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Resume_0001, Tes { int32_t ret = -1; struct DevHandle *handle = nullptr; - handle = BindServiceRenderSo(BIND_RENDER.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); - if (hwRender == nullptr) { - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = InitHwRenderMode(hwRender->renderParam.renderMode); + struct AudioHwRender *hwRender = nullptr; + ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME_USB, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = LibHwOutputRender(hwRender, handle); EXPECT_EQ(HDF_SUCCESS, ret); hwRender->renderParam.renderMode.ctlParam.pause = 0; ret = InterfaceLibOutputRender(handle, AUDIODRV_CTL_IOCTL_PAUSE_WRITE, &hwRender->renderParam); EXPECT_EQ(HDF_SUCCESS, ret); CloseServiceRenderSo(handle); free(hwRender); + hwRender = nullptr; } /** * @tc.name test InterfaceLibOutputRender API via setting the cmdId is invalid. @@ -1477,19 +1156,15 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Abnormal_0001, T { int32_t ret = -1; struct DevHandle *handle = nullptr; - handle = BindServiceRenderSo(BIND_RENDER.c_str()); - ASSERT_NE(nullptr, handle); - struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); - if (hwRender == nullptr) { - CloseServiceRenderSo(handle); - ASSERT_NE(nullptr, handle); - } - ret = InitRenderFramepara(hwRender->renderParam.frameRenderMode); - EXPECT_EQ(HDF_SUCCESS, ret); + struct AudioHwRender *hwRender = nullptr; + ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME_USB, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputRender(handle, 30, &hwRender->renderParam); EXPECT_EQ(HDF_FAILURE, ret); CloseServiceRenderSo(handle); free(hwRender); + hwRender = nullptr; } /** * @tc.name test InterfaceLibOutputRender API via inputting handleData is nullptr. @@ -1508,4 +1183,4 @@ HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Abnormal_0002, T EXPECT_EQ(HDF_FAILURE, ret); CloseServiceRenderSo(handle); } -} +} \ No newline at end of file diff --git a/audio/test/systemtest/audio_function/BUILD.gn b/audio/test/systemtest/audio_function/BUILD.gn index e82b3e35f8..3f42b0e533 100755 --- a/audio/test/systemtest/audio_function/BUILD.gn +++ b/audio/test/systemtest/audio_function/BUILD.gn @@ -11,15 +11,21 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build/test.gni") -import("//drivers/adapter/uhdf2/uhdf.gni") +if (defined(ohos_lite)) { + import("//build/lite/config/test.gni") +} else { + import("//build/test.gni") + import("//drivers/adapter/uhdf2/uhdf.gni") +} ###########################end########################### group("function") { - testonly = true - deps = [] - deps += [ - "audio_server:AudioServerFunctionTest", - "audio_pathroute:AudioPathRouteTest", - ] + if (!defined(ohos_lite)) { + testonly = true + } + deps = [ + "audio_server:hdf_audio_hdi_server_function_test", + "audio_pathroute:hdf_audio_hdi_path_route_test", + "audio_smartpa:hdf_audio_smartpa_test" + ] } diff --git a/audio/test/systemtest/audio_function/audio_pathroute/BUILD.gn b/audio/test/systemtest/audio_function/audio_pathroute/BUILD.gn index 297a928a47..baf0413266 100755 --- a/audio/test/systemtest/audio_function/audio_pathroute/BUILD.gn +++ b/audio/test/systemtest/audio_function/audio_pathroute/BUILD.gn @@ -11,56 +11,127 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build/test.gni") -import("//drivers/adapter/uhdf2/uhdf.gni") +if (defined(ohos_lite)) { + import("//build/lite/config/test.gni") +} else { + import("//build/test.gni") + import("//drivers/adapter/uhdf2/uhdf.gni") + import("//drivers/peripheral/audio/audio.gni") +} + +if (defined(ohos_lite)) { +###########################LITEOS########################################## +###########################hdf_audio_hdi_path_route_test########################### + unittest("hdf_audio_hdi_path_route_test") { + sources = [ + "src/audio_pathroute_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp", + "//drivers/framework/ability/sbuf/src/hdf_sbuf.c" + ] + + include_dirs = [ + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/include", + "//drivers/framework/core/sec/include", + "//drivers/framework/core/shared/include", + "//drivers/framework/core/host/include", + "//drivers/framework/core/manager/include", + "//drivers/framework/core/common/include/host/", + "//third_party/bounds_checking_function/include", + "//drivers/adapter/khdf/liteos/osal/include", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/adapter/uhdf2/include/hdi/", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//drivers/peripheral/audio/test/systemtest/audio_function/audio_pathroute/include", + "//third_party/googletest/googletest/include/gtest", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] -module_output_path = "hdf/audio/systemtest/function" -###########################systemtest############################## -###########################AudioPathRouteTest########################### -ohos_systemtest("AudioPathRouteTest") { - module_out_path = module_output_path - sources = [ - "src/audio_pathroute_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + deps = [ + "//third_party/bounds_checking_function:libsec_shared", + "//base/hiviewdfx/hilog_lite/frameworks/featured:hilog_shared", + "//drivers/adapter/uhdf/manager:hdf_core", + "//drivers/adapter/uhdf/posix:hdf_posix_osal" + ] + } +} else { + module_output_path = "hdf/audio" + ###########################hdf_audio_hdi_path_route_test########################### + ohos_systemtest("hdf_audio_hdi_path_route_test") { + module_out_path = module_output_path + sources = [ + "src/audio_pathroute_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] - include_dirs = [ - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/interfaces/include", - "//drivers/framework/include/core", - "//drivers/framework/include/utils", - "//drivers/framework/include/osal", - "//drivers/framework/include", - "//third_party/bounds_checking_function/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/framework/utils/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/adapter/uhdf2/osal/include", - "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", - "//drivers/peripheral/audio/test/systemtest/audio_function/audio_pathroute/include", - "//third_party/googletest/googletest/include/gtest", - ] - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - ] - deps = [ - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - "//utils/native/base:utils", - "//drivers/adapter/uhdf2/hdi:libhdi", - "//drivers/adapter/uhdf2/manager:hdf_devmgr", - "//drivers/adapter/uhdf2/manager:hdf_devmgr.rc", - "//drivers/adapter/uhdf2/ipc:libhdf_ipc_adapter", - "//drivers/adapter/uhdf2/osal:libhdf_utils", - "//drivers/adapter/uhdf2/host:hdf_devhost", - "//drivers/adapter/uhdf2/host:libhdf_host", - "//drivers/adapter/uhdf2/config:libhdf_hcs", - "//drivers/adapter/uhdf2/hcs:hdf_default.hcb", - ] + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/include", + "//third_party/bounds_checking_function/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/adapter/uhdf2/osal/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//drivers/peripheral/audio/test/systemtest/audio_function/audio_pathroute/include", + "//third_party/googletest/googletest/include/gtest", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + deps = [ + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + "//utils/native/base:utils", + "//drivers/adapter/uhdf2/hdi:libhdi", + "//drivers/adapter/uhdf2/manager:hdf_devmgr", + "//drivers/adapter/uhdf2/manager:hdf_devmgr.rc", + "//drivers/adapter/uhdf2/ipc:libhdf_ipc_adapter", + "//drivers/adapter/uhdf2/osal:libhdf_utils", + "//drivers/adapter/uhdf2/host:hdf_devhost", + "//drivers/adapter/uhdf2/host:libhdf_host", + "//drivers/adapter/uhdf2/config:libhdf_hcs", + "//drivers/adapter/uhdf2/hcs:hdf_default.hcb", + ] + defines = [] + if (enable_audio_adm_so) { + defines += [ "AUDIO_ADM_SO" ] + } + if (enable_audio_mpi_so) { + defines += [ "AUDIO_MPI_SO" ] + } + if (enable_audio_adm_service) { + defines += [ "AUDIO_ADM_SERVICE" ] + } + if (enable_audio_mpi_service) { + defines += [ "AUDIO_MPI_SERVICE" ] + } + } } ###########################end########################### \ No newline at end of file diff --git a/audio/test/systemtest/audio_function/audio_pathroute/src/audio_pathroute_test.cpp b/audio/test/systemtest/audio_function/audio_pathroute/src/audio_pathroute_test.cpp index 5e4d8df84a..fcf3188eef 100755 --- a/audio/test/systemtest/audio_function/audio_pathroute/src/audio_pathroute_test.cpp +++ b/audio/test/systemtest/audio_function/audio_pathroute/src/audio_pathroute_test.cpp @@ -64,30 +64,31 @@ public: static void TearDownTestCase(void); void SetUp(); void TearDown(); - struct AudioManager *(*GetAudioManager)() = nullptr; - void *handleSo = nullptr; - int32_t GetLoadAdapter(struct AudioManager manager, enum AudioPortDirection portType, - const string adapterName, struct AudioAdapter **adapter, struct AudioPort& renderPort) const; + static TestAudioManager *(*GetAudioManager)(); + static void *handleSo; }; -void AudioPathRouteTest::SetUpTestCase(void) {} +TestAudioManager *(*AudioPathRouteTest::GetAudioManager)() = nullptr; +void *AudioPathRouteTest::handleSo = nullptr; -void AudioPathRouteTest::TearDownTestCase(void) {} - -void AudioPathRouteTest::SetUp(void) +void AudioPathRouteTest::SetUpTestCase(void) { +#ifdef __LITEOS__ + char resolvedPath[] = "/usr/lib/libhdi_audio.so"; +#else char resolvedPath[] = "//system/lib/libhdi_audio.z.so"; +#endif handleSo = dlopen(resolvedPath, RTLD_LAZY); if (handleSo == nullptr) { return; } - GetAudioManager = (struct AudioManager* (*)())(dlsym(handleSo, "GetAudioManagerFuncs")); + GetAudioManager = (TestAudioManager* (*)())(dlsym(handleSo, "GetAudioManagerFuncs")); if (GetAudioManager == nullptr) { return; } } -void AudioPathRouteTest::TearDown(void) +void AudioPathRouteTest::TearDownTestCase(void) { if (handleSo != nullptr) { dlclose(handleSo); @@ -98,109 +99,55 @@ void AudioPathRouteTest::TearDown(void) } } -int32_t AudioPathRouteTest::GetLoadAdapter(struct AudioManager manager, enum AudioPortDirection portType, - const string adapterName, struct AudioAdapter **adapter, struct AudioPort& audioPort) const -{ - int32_t ret = -1; - int size = 0; - struct AudioAdapterDescriptor *desc = nullptr; - struct AudioAdapterDescriptor *descs = nullptr; - if (adapter == nullptr) { - return HDF_FAILURE; - } - ret = manager.GetAllAdapters(&manager, &descs, &size); - if (ret != 0 || descs == nullptr || size == 0) { - return HDF_FAILURE; - } else { - int index = SwitchAdapter(descs, adapterName, portType, audioPort, size); - if (index < 0) { - return HDF_FAILURE; - } else { - desc = &descs[index]; - } - } - if (desc == nullptr) { - return HDF_FAILURE; - } else { - ret = manager.LoadAdapter(&manager, desc, adapter); - } - if (ret != 0 || adapter == nullptr) { - return HDF_FAILURE; - } - return HDF_SUCCESS; -} +void AudioPathRouteTest::SetUp(void) {} + +void AudioPathRouteTest::TearDown(void) {} /** -* @tc.name Test the audio path route selection funtion of palyback scene +* @tc.name Test the audio path route selection function of palyback scene * @tc.number SUB_Audio_AudioPathRoute_0001 -* @tc.desc The audio path route can be opened sucessfuly,When it is set to +* @tc.desc The audio path route can be opened successfully,When it is set to palyback scene(attrs.type = AUDIO_IN_MEDIA,pins = PIN_OUT_SPEAKER) * @tc.author: liweiming */ HWTEST_F(AudioPathRouteTest, SUB_Audio_AudioPathRoute_0001, TestSize.Level1) { int32_t ret = -1; - enum AudioPortDirection portType = PORT_OUT; enum AudioPortPin pins = PIN_OUT_SPEAKER; - struct AudioPort renderPort = {}; - struct AudioSampleAttributes attrs = {}; - struct AudioDeviceDescriptor devDesc = {}; - struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; + struct AudioAdapter *adapter = nullptr; ret = PowerOff(g_elemValues[0], g_elemValues[1]); ASSERT_EQ(HDF_SUCCESS, ret); ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_USB, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, pins, ADAPTER_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = InitAttrs(attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InitDevDesc(devDesc, renderPort.portId, pins); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = CheckRegisterStatus(g_elemValues[0].id, g_elemValues[1].id, REGISTER_STATUS_ON, REGISTER_STATUS_ON); EXPECT_EQ(HDF_SUCCESS, ret); adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); } /** -* @tc.name Test the audio path route selection funtion via switching device SPEAKER to HEADSET +* @tc.name Test the audio path route selection function via switching device SPEAKER to HEADSET * @tc.number SUB_Audio_AudioPathRoute_0002 -* @tc.desc The audio path route can be opened sucessfuly,When switching +* @tc.desc The audio path route can be opened successfully,When switching device(attrs.type = AUDIO_IN_MEDIA,pins = PIN_OUT_HEADSET) * @tc.author: liweiming */ HWTEST_F(AudioPathRouteTest, SUB_Audio_AudioPathRoute_0002, TestSize.Level1) { int32_t ret = -1; - enum AudioPortDirection portType = PORT_OUT; enum AudioPortPin pins = PIN_OUT_SPEAKER; - struct AudioPort renderPort = {}; - struct AudioSampleAttributes attrs = {}; - struct AudioDeviceDescriptor devDesc = {}; - struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; + struct AudioAdapter *adapter = nullptr; g_elemValues[0].value[0] = 1; g_elemValues[1].value[0] = 1; ret = PowerOff(g_elemValues[0], g_elemValues[1]); ASSERT_EQ(HDF_SUCCESS, ret); ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_USB, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, pins, ADAPTER_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = InitAttrs(attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InitDevDesc(devDesc, renderPort.portId, pins); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } struct AudioSceneDescriptor scene = { .scene.id = 0, .desc.pins = PIN_OUT_HEADSET, @@ -212,104 +159,71 @@ HWTEST_F(AudioPathRouteTest, SUB_Audio_AudioPathRoute_0002, TestSize.Level1) manager.UnloadAdapter(&manager, adapter); } /** -* @tc.name Test the audio path route selection funtion of playback sence +* @tc.name Test the audio path route selection function of playback sence when the audio path route has been opened * @tc.number SUB_Audio_AudioPathRoute_0003 -* @tc.desc The audio path route of playback scene can be opened sucessfuly,When The current +* @tc.desc The audio path route of playback scene can be opened successfully,When The current audio path route has been opened * @tc.author: liweiming */ HWTEST_F(AudioPathRouteTest, SUB_Audio_AudioPathRoute_0003, TestSize.Level1) { int32_t ret = -1; - enum AudioPortDirection portType = PORT_OUT; - enum AudioPortPin pins = PIN_OUT_SPEAKER; - struct AudioPort renderPort = {}; - struct AudioSampleAttributes attrs = {}; - struct AudioDeviceDescriptor devDesc = {}; + struct AudioRender *render = nullptr; struct AudioAdapter *adapter = nullptr; - struct AudioRender *renderFirst = nullptr; - struct AudioRender *renderSecond = nullptr; ret = PowerOff(g_elemValues[0], g_elemValues[1]); ASSERT_EQ(HDF_SUCCESS, ret); ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_INTERNAL, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = InitAttrs(attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InitDevDesc(devDesc, renderPort.portId, pins); + struct AudioSceneDescriptor scene = { + .scene.id = 0, + .desc.pins = PIN_OUT_SPEAKER, + }; + ret = render->scene.SelectScene(AudioHandle(render), &scene); EXPECT_EQ(HDF_SUCCESS, ret); - ret = adapter->CreateRender(adapter, &devDesc, &attrs, &renderFirst); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = adapter->CreateRender(adapter, &devDesc, &attrs, &renderSecond); - if (ret < 0) { - adapter->DestroyRender(adapter, renderFirst); - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = CheckRegisterStatus(g_elemValues[0].id, g_elemValues[1].id, REGISTER_STATUS_ON, REGISTER_STATUS_ON); EXPECT_EQ(HDF_SUCCESS, ret); - adapter->DestroyRender(adapter, renderFirst); - adapter->DestroyRender(adapter, renderSecond); + adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); } /** -* @tc.name Test the audio path route selection funtion of recording scene +* @tc.name Test the audio path route selection function of recording scene * @tc.number SUB_Audio_AudioPathRoute_0004 -* @tc.desc The audio path route can be opened sucessfuly,When it is set to +* @tc.desc The audio path route can be opened successfully,When it is set to recording scene(attrs.type = AUDIO_IN_MEDIA,pins = PIN_IN_MIC) * @tc.author: liweiming */ HWTEST_F(AudioPathRouteTest, SUB_Audio_AudioPathRoute_0004, TestSize.Level1) { int32_t ret = -1; - enum AudioPortDirection portType = PORT_IN; enum AudioPortPin pins = PIN_IN_MIC; - struct AudioPort capturePort = {}; - struct AudioSampleAttributes attrs = {}; - struct AudioDeviceDescriptor devDesc = {}; struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; g_elemValues[3].value[0] = 1; ret = PowerOff(g_elemValues[2], g_elemValues[3]); ASSERT_EQ(HDF_SUCCESS, ret); ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_INTERNAL, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, pins, ADAPTER_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = InitAttrs(attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InitDevDesc(devDesc, capturePort.portId, pins); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = adapter->CreateCapture(adapter, &devDesc, &attrs, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = CheckRegisterStatus(g_elemValues[2].id, g_elemValues[3].id, REGISTER_STATUS_ON, REGISTER_STATUS_OFF); EXPECT_EQ(HDF_SUCCESS, ret); adapter->DestroyCapture(adapter, capture); manager.UnloadAdapter(&manager, adapter); } /** -* @tc.name Test the audio path route selection funtion via switching device MIC to HS_MIC +* @tc.name Test the audio path route selection function via switching device MIC to HS_MIC * @tc.number SUB_Audio_AudioPathRoute_0005 -* @tc.desc The audio path route can be opened sucessfuly,When it is set to +* @tc.desc The audio path route can be opened successfully,When it is set to recording scene(attrs.type = AUDIO_IN_MEDIA,pins = PIN_IN_HS_MIC) * @tc.author: liweiming */ HWTEST_F(AudioPathRouteTest, SUB_Audio_AudioPathRoute_0005, TestSize.Level1) { int32_t ret = -1; - enum AudioPortDirection portType = PORT_IN; enum AudioPortPin pins = PIN_IN_MIC; - struct AudioPort capturePort = {}; - struct AudioSampleAttributes attrs = {}; - struct AudioDeviceDescriptor devDesc = {}; struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; g_elemValues[2].value[0] = 1; @@ -317,18 +231,9 @@ HWTEST_F(AudioPathRouteTest, SUB_Audio_AudioPathRoute_0005, TestSize.Level1) ret = PowerOff(g_elemValues[2], g_elemValues[3]); ASSERT_EQ(HDF_SUCCESS, ret); ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_INTERNAL, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, pins, ADAPTER_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = InitAttrs(attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InitDevDesc(devDesc, capturePort.portId, pins); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = adapter->CreateCapture(adapter, &devDesc, &attrs, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } struct AudioSceneDescriptor scene = { .scene.id = 0, .desc.pins = PIN_IN_HS_MIC, @@ -340,65 +245,45 @@ HWTEST_F(AudioPathRouteTest, SUB_Audio_AudioPathRoute_0005, TestSize.Level1) manager.UnloadAdapter(&manager, adapter); } /** -* @tc.name Test the audio path route selection funtion of recording sence +* @tc.name Test the audio path route selection function of recording sence when the audio path route has been opened * @tc.number SUB_Audio_AudioPathRoute_0006 -* @tc.desc The audio path route of recording scene can be opened sucessfuly,When The current +* @tc.desc The audio path route of recording scene can be opened successfully,When The current audio path route has been opened * @tc.author: liweiming */ HWTEST_F(AudioPathRouteTest, SUB_Audio_AudioPathRoute_0006, TestSize.Level1) { int32_t ret = -1; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioPort capturePort = {}; - struct AudioSampleAttributes attrs = {}; - struct AudioDeviceDescriptor devDesc = {}; struct AudioAdapter *adapter = nullptr; - struct AudioCapture *captureFirst = nullptr; - struct AudioCapture *captureSecond = nullptr; - ret = PowerOff(g_elemValues[0], g_elemValues[1]); + struct AudioCapture *capture = nullptr; + g_elemValues[3].value[0] = 1; + ret = PowerOff(g_elemValues[2], g_elemValues[3]); ASSERT_EQ(HDF_SUCCESS, ret); ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_INTERNAL, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = InitAttrs(attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InitDevDesc(devDesc, capturePort.portId, pins); + struct AudioSceneDescriptor scene = { + .scene.id = 0, + .desc.pins = PIN_IN_MIC, + }; + ret = capture->scene.SelectScene(AudioHandle(capture), &scene); EXPECT_EQ(HDF_SUCCESS, ret); - ret = adapter->CreateCapture(adapter, &devDesc, &attrs, &captureFirst); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = adapter->CreateCapture(adapter, &devDesc, &attrs, &captureSecond); - if (ret < 0) { - adapter->DestroyCapture(adapter, captureFirst); - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = CheckRegisterStatus(g_elemValues[2].id, g_elemValues[3].id, REGISTER_STATUS_ON, REGISTER_STATUS_OFF); EXPECT_EQ(HDF_SUCCESS, ret); - adapter->DestroyCapture(adapter, captureFirst); - adapter->DestroyCapture(adapter, captureSecond); + adapter->DestroyCapture(adapter, capture); manager.UnloadAdapter(&manager, adapter); } /** -* @tc.name Test the audio path route selection funtion via runing multi service scenarios +* @tc.name Test the audio path route selection function via runing multi service scenarios * @tc.number SUB_Audio_AudioPathRoute_0007 -* @tc.desc The audio path route can be opened sucessfuly,When runing multi service scenarios +* @tc.desc The audio path route can be opened successfully,When runing multi service scenarios * @tc.author: liweiming */ HWTEST_F(AudioPathRouteTest, SUB_Audio_AudioPathRoute_0007, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - struct AudioPort renderPort = {}; - struct AudioSampleAttributes attrs = {}; - struct AudioDeviceDescriptor captureDesc = {}; - struct AudioDeviceDescriptor renderDesc = {}; struct AudioAdapter *captureAdapter = nullptr; struct AudioAdapter *renderAdapter = nullptr; struct AudioCapture *capture = nullptr; @@ -407,30 +292,15 @@ HWTEST_F(AudioPathRouteTest, SUB_Audio_AudioPathRoute_0007, TestSize.Level1) ASSERT_EQ(HDF_SUCCESS, ret); ret = PowerOff(g_elemValues[2], g_elemValues[3]); ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_INTERNAL, &captureAdapter, capturePort); - ASSERT_EQ(HDF_SUCCESS, ret); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_USB, &renderAdapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_INTERNAL, &captureAdapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = InitAttrs(attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InitDevDesc(captureDesc, capturePort.portId, PIN_IN_MIC); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = InitDevDesc(renderDesc, renderPort.portId, PIN_OUT_SPEAKER); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = captureAdapter->CreateCapture(captureAdapter, &captureDesc, &attrs, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, captureAdapter); - manager.UnloadAdapter(&manager, renderAdapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = CheckRegisterStatus(g_elemValues[2].id, g_elemValues[3].id, REGISTER_STATUS_ON, REGISTER_STATUS_OFF); EXPECT_EQ(HDF_SUCCESS, ret); - ret = renderAdapter->CreateRender(renderAdapter, &renderDesc, &attrs, &render); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_USB, &renderAdapter, &render); if (ret < 0) { captureAdapter->DestroyCapture(captureAdapter, capture); manager.UnloadAdapter(&manager, captureAdapter); - manager.UnloadAdapter(&manager, renderAdapter); ASSERT_EQ(HDF_SUCCESS, ret); } ret = CheckRegisterStatus(g_elemValues[0].id, g_elemValues[1].id, REGISTER_STATUS_ON, REGISTER_STATUS_ON); diff --git a/audio/test/systemtest/audio_function/audio_server/BUILD.gn b/audio/test/systemtest/audio_function/audio_server/BUILD.gn index eb9dbf36f5..390a450f26 100755 --- a/audio/test/systemtest/audio_function/audio_server/BUILD.gn +++ b/audio/test/systemtest/audio_function/audio_server/BUILD.gn @@ -11,46 +11,106 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build/test.gni") -import("//drivers/adapter/uhdf2/uhdf.gni") +if (defined(ohos_lite)) { + import("//build/lite/config/test.gni") +} else { + import("//build/test.gni") + import("//drivers/adapter/uhdf2/uhdf.gni") + import("//drivers/peripheral/audio/audio.gni") +} + +if (defined(ohos_lite)) { +###########################LITEOS########################################## +###########################hdf_audio_hdi_server_function_test########################### + unittest("hdf_audio_hdi_server_function_test") { + sources = [ + "src/audio_server_function_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] -module_output_path = "hdf/audio/systemtest/function" -###########################systemtest############################## -###########################AudioServerFunctionTest########################### -ohos_systemtest("AudioServerFunctionTest") { - module_out_path = module_output_path - sources = [ - "src/audio_server_function_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/include", + "//third_party/bounds_checking_function/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/adapter/uhdf2/osal/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//drivers/peripheral/audio/test/systemtest/audio_function/audio_server/include", + "//third_party/googletest/googletest/include/gtest", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + "-std=c++11" + ] + } +} else { + module_output_path = "hdf/audio" + ###########################hdf_audio_hdi_server_function_test########################### + ohos_systemtest("hdf_audio_hdi_server_function_test") { + module_out_path = module_output_path + sources = [ + "src/audio_server_function_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] - include_dirs = [ - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/interfaces/include", - "//drivers/framework/include/core", - "//drivers/framework/include/utils", - "//drivers/framework/include/osal", - "//drivers/framework/include", - "//third_party/bounds_checking_function/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/framework/utils/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/adapter/uhdf2/osal/include", - "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", - "//drivers/peripheral/audio/test/systemtest/audio_function/audio_server/include", - "//third_party/googletest/googletest/include/gtest", - ] - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - ] - deps = [ - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - ] + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/include", + "//third_party/bounds_checking_function/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/adapter/uhdf2/osal/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//drivers/peripheral/audio/test/systemtest/audio_function/audio_server/include", + "//third_party/googletest/googletest/include/gtest", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + deps = [ + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + defines = [] + if (enable_audio_adm_so) { + defines += [ "AUDIO_ADM_SO" ] + } + if (enable_audio_mpi_so) { + defines += [ "AUDIO_MPI_SO" ] + } + if (enable_audio_adm_service) { + defines += [ "AUDIO_ADM_SERVICE" ] + } + if (enable_audio_mpi_service) { + defines += [ "AUDIO_MPI_SERVICE" ] + } + } } ###########################end########################### \ No newline at end of file diff --git a/audio/test/systemtest/audio_function/audio_server/src/audio_server_function_test.cpp b/audio/test/systemtest/audio_function/audio_server/src/audio_server_function_test.cpp index 8bb4f77a3b..185b6880ba 100755 --- a/audio/test/systemtest/audio_function/audio_server/src/audio_server_function_test.cpp +++ b/audio/test/systemtest/audio_function/audio_server/src/audio_server_function_test.cpp @@ -21,12 +21,9 @@ using namespace testing::ext; using namespace HMOS::Audio; namespace { -const string AUDIO_FILE = "//bin/audiorendertest.wav"; -const string AUDIO_CAPTURE_FILE = "//bin/audiocapture.wav"; -const string ADAPTER_NAME = "hdmi"; -const string ADAPTER_NAME2 = "usb"; -const string ADAPTER_NAME3 = "internal"; -const uint64_t FILESIZE = 2048; +const string ADAPTER_NAME_USB = "usb"; +const string ADAPTER_NAME_INTERNAL = "internal"; +const uint64_t FILESIZE = 1024; const uint32_t CHANNELCOUNTEXOECT = 2; const uint32_t SAMPLERATEEXOECT = 32000; @@ -36,65 +33,80 @@ public: static void TearDownTestCase(void); void SetUp(); void TearDown(); - struct AudioManager *(*GetAudioManager)() = nullptr; - void *handleSo = nullptr; - static int32_t GetLoadAdapter(struct PrepareAudioPara& audiopara); - static int32_t PlayAudioFile(struct PrepareAudioPara& audiopara); - static int32_t RecordAudio(struct PrepareAudioPara& audiopara); + static TestAudioManager *(*GetAudioManager)(); + static void *handleSo; +#ifdef AUDIO_MPI_SO + static int32_t (*SdkInit)(); + static void (*SdkExit)(); + static void *sdkSo; +#endif + static int32_t GetManager(struct PrepareAudioPara& audiopara); uint32_t FrameSizeExpect(const struct AudioSampleAttributes attrs); }; +TestAudioManager *(*AudioServerFunctionTest::GetAudioManager)() = nullptr; +void *AudioServerFunctionTest::handleSo = nullptr; +#ifdef AUDIO_MPI_SO + int32_t (*AudioServerFunctionTest::SdkInit)() = nullptr; + void (*AudioServerFunctionTest::SdkExit)() = nullptr; + void *AudioServerFunctionTest::sdkSo = nullptr; +#endif using THREAD_FUNC = void *(*)(void *); -void AudioServerFunctionTest::SetUpTestCase(void) {} - -void AudioServerFunctionTest::TearDownTestCase(void) {} - -void AudioServerFunctionTest::SetUp(void) +void AudioServerFunctionTest::SetUpTestCase(void) { - char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; - handleSo = dlopen(resolvedPath, RTLD_LAZY); +#ifdef AUDIO_MPI_SO + char sdkResolvedPath[] = "//system/lib/libhdi_audio_interface_lib_render.z.so"; + sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY); + if (sdkSo == nullptr) { + return; + } + SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit")); + if (SdkInit == nullptr) { + return; + } + SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit")); + if (SdkExit == nullptr) { + return; + } + SdkInit(); +#endif + handleSo = dlopen(RESOLVED_PATH.c_str(), RTLD_LAZY); if (handleSo == nullptr) { return; } - GetAudioManager = (struct AudioManager* (*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); + GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str())); if (GetAudioManager == nullptr) { return; } } -void AudioServerFunctionTest::TearDown(void) +void AudioServerFunctionTest::TearDownTestCase(void) { +#ifdef AUDIO_MPI_SO + SdkExit(); + if (sdkSo != nullptr) { + dlclose(sdkSo); + sdkSo = nullptr; + } + if (SdkInit != nullptr) { + SdkInit = nullptr; + } + if (SdkExit != nullptr) { + SdkExit = nullptr; + } +#endif if (GetAudioManager != nullptr) { GetAudioManager = nullptr; } } -struct PrepareAudioPara { - struct AudioManager *manager; - enum AudioPortDirection portType; - const char *adapterName; - struct AudioAdapter *adapter; - struct AudioPort audioPort; - void *self; - enum AudioPortPin pins; - const char *path; - struct AudioRender *render; - struct AudioCapture *capture; - struct AudioHeadInfo headInfo; - struct AudioAdapterDescriptor *desc; - struct AudioAdapterDescriptor *descs; - char *frame; - uint64_t requestBytes; - uint64_t replyBytes; - uint64_t fileSize; - struct AudioSampleAttributes attrs; -}; +void AudioServerFunctionTest::SetUp(void) {} -int32_t AudioServerFunctionTest::GetLoadAdapter(struct PrepareAudioPara& audiopara) +void AudioServerFunctionTest::TearDown(void) {} + +int32_t AudioServerFunctionTest::GetManager(struct PrepareAudioPara& audiopara) { - int32_t ret = -1; - int size = 0; auto *inst = (AudioServerFunctionTest *)audiopara.self; if (inst != nullptr && inst->GetAudioManager != nullptr) { audiopara.manager = inst->GetAudioManager(); @@ -102,119 +114,15 @@ int32_t AudioServerFunctionTest::GetLoadAdapter(struct PrepareAudioPara& audiopa if (audiopara.manager == nullptr) { return HDF_FAILURE; } - ret = audiopara.manager->GetAllAdapters(audiopara.manager, &audiopara.descs, &size); - if (ret < 0 || audiopara.descs == nullptr || size == 0) { - return HDF_FAILURE; - } else { - int index = SwitchAdapter(audiopara.descs, audiopara.adapterName, - audiopara.portType, audiopara.audioPort, size); - if (index < 0) { - return HDF_FAILURE; - } else { - audiopara.desc = &audiopara.descs[index]; - } - } - if (audiopara.desc == nullptr) { - return HDF_FAILURE; - } else { - ret = audiopara.manager->LoadAdapter(audiopara.manager, audiopara.desc, &audiopara.adapter); - } - if (ret < 0 || audiopara.adapter == nullptr) { - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t AudioServerFunctionTest::PlayAudioFile(struct PrepareAudioPara& audiopara) -{ - int32_t ret = -1; - struct AudioDeviceDescriptor devDesc = {}; - char absPath[PATH_MAX] = {0}; - if (audiopara.adapter == nullptr || audiopara.manager == nullptr) { - return HDF_FAILURE; - } - if (realpath(audiopara.path, absPath) == nullptr) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - return HDF_FAILURE; - } - FILE *file = fopen(absPath, "rb"); - if (file == nullptr) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - return HDF_FAILURE; - } - - ret = HMOS::Audio::InitAttrs(audiopara.attrs); - - if (WavHeadAnalysis(audiopara.headInfo, file, audiopara.attrs) < 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - fclose(file); - return HDF_FAILURE; - } - - ret = HMOS::Audio::InitDevDesc(devDesc, (&audiopara.audioPort)->portId, audiopara.pins); - - ret = audiopara.adapter->CreateRender(audiopara.adapter, &devDesc, &(audiopara.attrs), &audiopara.render); - if (ret < 0 || audiopara.render == nullptr) { - fclose(file); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - return HDF_FAILURE; - } - ret = HMOS::Audio::FrameStart(audiopara.headInfo, audiopara.render, file, audiopara.attrs); - if (ret == HDF_SUCCESS) { - fclose(file); - } else { - audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - fclose(file); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t AudioServerFunctionTest::RecordAudio(struct PrepareAudioPara& audiopara) -{ - int32_t ret = -1; - struct AudioDeviceDescriptor devDesc = {}; - if (audiopara.adapter == nullptr || audiopara.manager == nullptr) { - return HDF_FAILURE; - } - ret = InitAttrs(audiopara.attrs); - - ret = InitDevDesc(devDesc, (&audiopara.audioPort)->portId, audiopara.pins); - - ret = audiopara.adapter->CreateCapture(audiopara.adapter, &devDesc, &(audiopara.attrs), &audiopara.capture); - if (ret < 0 || audiopara.capture == nullptr) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - return HDF_FAILURE; - } - bool isMute = false; - ret = audiopara.capture->volume.SetMute(audiopara.capture, isMute); - if (ret < 0) { - audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - return HDF_FAILURE; - } - - FILE *file = fopen(audiopara.path, "wb+"); - if (file == nullptr) { - audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - return HDF_FAILURE; - } - ret = StartRecord(audiopara.capture, file, audiopara.fileSize); - if (ret < 0) { - audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - fclose(file); - return HDF_FAILURE; - } - fclose(file); return HDF_SUCCESS; } uint32_t AudioServerFunctionTest::FrameSizeExpect(const struct AudioSampleAttributes attrs) { - uint32_t sizeExpect = FRAME_SIZE * (attrs.channelCount) * (PcmFormatToBits(attrs.format) >> 3); + if (attrs.channelCount < 1 || attrs.channelCount > 2) { + return 0; + } + uint32_t sizeExpect = FRAME_SIZE * (attrs.channelCount) * (PcmFormatToBits(attrs.format) >> MOVE_RIGHT_NUM); return sizeExpect; } @@ -228,28 +136,18 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0001, TestSize. { int32_t ret = -1; struct PrepareAudioPara audiopara = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; - ret = GetLoadAdapter(audiopara); + ret = GetManager(audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->control.Stop((AudioHandle)(audiopara.render)); + + ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); } /** * @tc.name Set audio file volume @@ -260,50 +158,37 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0001, TestSize. HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0002, TestSize.Level1) { int32_t ret = -1; - float volumeMax = 1.0; - bool muteFalse = false; - float volumeValue[10] = {0}; - float volumeArr[10] = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0}; struct PrepareAudioPara audiopara = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; + float volumeMax = 1.0; + bool muteFalse = false; + float volumeValue[10] = {0}; + float volume[10] = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0}; - ret = GetLoadAdapter(audiopara); + ret = GetManager(audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); sleep(1); if (audiopara.render != nullptr) { ret = audiopara.render->volume.SetMute(audiopara.render, muteFalse); EXPECT_EQ(HDF_SUCCESS, ret); - sleep(1); ret = audiopara.render->volume.SetVolume(audiopara.render, volumeMax); EXPECT_EQ(HDF_SUCCESS, ret); for (int i = 0; i < 10; i++) { - ret = audiopara.render->volume.SetVolume(audiopara.render, volumeArr[i]); + ret = audiopara.render->volume.SetVolume(audiopara.render, volume[i]); EXPECT_EQ(HDF_SUCCESS, ret); ret = audiopara.render->volume.GetVolume(audiopara.render, &volumeValue[i]); EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_EQ(volumeArr[i], volumeValue[i]); - sleep(1); - } + EXPECT_EQ(volume[i], volumeValue[i]); + usleep(30000); + } } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->control.Stop((AudioHandle)(audiopara.render)); + ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); - - audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); } /** * @tc.name Mute audio files @@ -314,23 +199,19 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0002, TestSize. HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0003, TestSize.Level1) { int32_t ret = -1; - bool muteTrue = true; - bool muteFalse = false; - float volume = 0.8; struct PrepareAudioPara audiopara = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; + bool muteTrue = true; + bool muteFalse = false; + float volume = 0.8; - ret = GetLoadAdapter(audiopara); + ret = GetManager(audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); sleep(1); if (audiopara.render != nullptr) { ret = audiopara.render->volume.SetVolume(audiopara.render, volume); @@ -348,17 +229,8 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0003, TestSize. EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(false, muteFalse); } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - - ret = audiopara.render->control.Stop((AudioHandle)(audiopara.render)); + ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); - - audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); } /** * @tc.name Pause Resume and Stop audio file @@ -368,21 +240,17 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0003, TestSize. */ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0004, TestSize.Level1) { - int32_t ret = -1; struct PrepareAudioPara audiopara = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; + int32_t ret = -1; - ret = GetLoadAdapter(audiopara); + ret = GetManager(audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); sleep(1); if (audiopara.render != nullptr) { ret = audiopara.render->control.Pause((AudioHandle)(audiopara.render)); @@ -391,17 +259,8 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0004, TestSize. ret = audiopara.render->control.Resume((AudioHandle)(audiopara.render)); EXPECT_EQ(HDF_SUCCESS, ret); } - - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->control.Stop((AudioHandle)(audiopara.render)); + ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); - - audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); } /** * @tc.name Get audio gainthreshold and set gain value @@ -412,53 +271,40 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0004, TestSize. HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0005, TestSize.Level1) { int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }; float gain = 0; float gainMax = 0; float gainMin = 0; float gainMinValue = 1; float gainMaxValue = 14; - struct PrepareAudioPara audiopara = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, - .path = AUDIO_FILE.c_str() - }; - ret = GetLoadAdapter(audiopara); + ret = GetManager(audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); sleep(1); if (audiopara.render != nullptr) { ret = audiopara.render->volume.GetGainThreshold(audiopara.render, &gainMin, &gainMax); EXPECT_EQ(HDF_SUCCESS, ret); - - ret = audiopara.render->volume.SetGain(audiopara.render, gainMax-1); + + ret = audiopara.render->volume.SetGain(audiopara.render, gainMax - 1); EXPECT_EQ(HDF_SUCCESS, ret); ret = audiopara.render->volume.GetGain(audiopara.render, &gain); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(gainMaxValue, gain); - - sleep(1); - ret = audiopara.render->volume.SetGain(audiopara.render, gainMin+1); + + ret = audiopara.render->volume.SetGain(audiopara.render, gainMin + 1); EXPECT_EQ(HDF_SUCCESS, ret); ret = audiopara.render->volume.GetGain(audiopara.render, &gain); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(gainMinValue, gain); } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->control.Stop((AudioHandle)(audiopara.render)); + ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); - - audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); } /** * @tc.name set volume after the audio file is Paused and set mute after the audio file is resumed @@ -469,51 +315,45 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0005, TestSize. HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0006, TestSize.Level1) { int32_t ret = -1; - bool muteTrue = true; - float volumeValue[10] = {0}; - float volumeArr[10] = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0}; struct PrepareAudioPara audiopara = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; - ret = GetLoadAdapter(audiopara); + float volumeValue = 1.0; + float volume = 1.0; + bool muteTrue = true; + bool muteFalse = false; + + ret = GetManager(audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); + + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } sleep(1); if (audiopara.render != nullptr) { ret = audiopara.render->control.Pause((AudioHandle)(audiopara.render)); EXPECT_EQ(HDF_SUCCESS, ret); sleep(1); - for (int i = 0; i < 10; i++) { - ret = audiopara.render->volume.SetVolume(audiopara.render, volumeArr[i]); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->volume.GetVolume(audiopara.render, &volumeValue[i]); - EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_EQ(volumeArr[i], volumeValue[i]); - sleep(1); - } + ret = audiopara.render->volume.SetVolume(audiopara.render, volume); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->volume.GetVolume(audiopara.render, &volume); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(volumeValue, volume); ret = audiopara.render->control.Resume((AudioHandle)(audiopara.render)); EXPECT_EQ(HDF_SUCCESS, ret); - sleep(1); ret = audiopara.render->volume.SetMute(audiopara.render, muteTrue); EXPECT_EQ(HDF_SUCCESS, ret); ret = audiopara.render->volume.GetMute(audiopara.render, &muteTrue); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(true, muteTrue); + ret = audiopara.render->volume.SetMute(audiopara.render, muteFalse); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->volume.GetMute(audiopara.render, &muteFalse); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(false, muteFalse); } - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->control.Stop((AudioHandle)(audiopara.render)); + ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); } /** * @tc.name set mute after the audio file is Paused and set volume after the audio file is resumed @@ -524,21 +364,19 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0006, TestSize. HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0007, TestSize.Level1) { int32_t ret = -1; - float volumeMax = 1.0; - bool muteTrue = true; - bool muteFalse = false; struct PrepareAudioPara audiopara = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; - ret = GetLoadAdapter(audiopara); + float volumeMax = 1.0; + bool muteTrue = true; + bool muteFalse = false; + + ret = GetManager(audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); + + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } sleep(1); if (audiopara.render != nullptr) { ret = audiopara.render->control.Pause((AudioHandle)(audiopara.render)); @@ -557,19 +395,11 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0007, TestSize. sleep(1); ret = audiopara.render->control.Resume((AudioHandle)(audiopara.render)); EXPECT_EQ(HDF_SUCCESS, ret); - sleep(1); ret = audiopara.render->volume.SetVolume(audiopara.render, volumeMax); EXPECT_EQ(HDF_SUCCESS, ret); } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->control.Stop((AudioHandle)(audiopara.render)); + ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); } /** * @tc.name Get Current ChannelId during playing. @@ -580,23 +410,19 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0007, TestSize. HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0008, TestSize.Level1) { int32_t ret = -1; - float speed = 3; - uint32_t channelId = 0; - uint32_t channelIdValue = CHANNELCOUNT; struct PrepareAudioPara audiopara = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; + float speed = 3; + uint32_t channelId = 0; + uint32_t channelIdValue = CHANNELCOUNT; - ret = GetLoadAdapter(audiopara); + ret = GetManager(audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(ret, HDF_SUCCESS); - } + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); sleep(1); if (audiopara.render != nullptr) { ret = audiopara.render->SetRenderSpeed(audiopara.render, speed); @@ -607,15 +433,8 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0008, TestSize. EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(channelId, channelIdValue); } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->control.Stop((AudioHandle)(audiopara.render)); + ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); } /** * @tc.name Get Frame Size during playing @@ -625,23 +444,19 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0008, TestSize. */ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0009, TestSize.Level1) { - int32_t ret = -1; - uint64_t size = 0; - uint64_t sizeExpect = 0; struct PrepareAudioPara audiopara = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; + uint64_t size = 0; + uint64_t sizeExpect = 0; + int32_t ret = -1; - ret = GetLoadAdapter(audiopara); + ret = GetManager(audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(ret, HDF_SUCCESS); - } + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); sleep(1); if (audiopara.render != nullptr) { ret = audiopara.render->attr.GetFrameSize(audiopara.render, &size); @@ -649,15 +464,8 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0009, TestSize. sizeExpect = FrameSizeExpect(audiopara.attrs); EXPECT_EQ(size, sizeExpect); } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->control.Stop((AudioHandle)(audiopara.render)); + ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); } /** * @tc.name Get Frame Count during playing @@ -668,37 +476,26 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0009, TestSize. HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0010, TestSize.Level1) { int32_t ret = -1; - uint64_t count = 0; - uint64_t zero = 0; struct PrepareAudioPara audiopara = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; + uint64_t count = 0; + uint64_t zero = 0; - ret = GetLoadAdapter(audiopara); + ret = GetManager(audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(ret, HDF_SUCCESS); - } + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); sleep(1); if (audiopara.render != nullptr) { ret = audiopara.render->attr.GetFrameCount(audiopara.render, &count); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_GT(count, zero); } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->control.Stop((AudioHandle)(audiopara.render)); + ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); } /** * @tc.name Get render position when playing audio file @@ -713,35 +510,24 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0011, TestSize. int64_t timeExp = 0; struct AudioTimeStamp time = {.tvSec = 0}; struct PrepareAudioPara audiopara = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; - ret = GetLoadAdapter(audiopara); + ret = GetManager(audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - sleep(1); + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); + sleep(2); if (audiopara.render != nullptr) { ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &time); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_GT(time.tvSec, timeExp); EXPECT_GT(frames, INITIAL_VALUE); } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->control.Stop((AudioHandle)(audiopara.render)); + ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); } /** * @tc.name Check Scene Capability during playing @@ -755,36 +541,25 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0012, TestSize. bool supported = false; struct AudioSceneDescriptor scenes = {}; struct PrepareAudioPara audiopara = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; scenes.scene.id = 0; scenes.desc.pins = PIN_OUT_SPEAKER; - ret = GetLoadAdapter(audiopara); + ret = GetManager(audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(ret, HDF_SUCCESS); - } + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); sleep(1); if (audiopara.render != nullptr) { ret = audiopara.render->scene.CheckSceneCapability(audiopara.render, &scenes, &supported); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_TRUE(supported); } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->control.Stop((AudioHandle)(audiopara.render)); + ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); } /** * @tc.name when audio file playing SetSampleAttributes @@ -796,23 +571,19 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0012, TestSize. HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0013, TestSize.Level1) { int32_t ret = -1; - uint32_t samplerateValue = 48000; - uint32_t channelcountValue = 1; - struct AudioSampleAttributes attrsValue = {}; struct PrepareAudioPara audiopara = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; + uint32_t samplerateValue = 48000; + uint32_t channelcountValue = 1; + struct AudioSampleAttributes attrsValue = {}; - ret = GetLoadAdapter(audiopara); + ret = GetManager(audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(ret, HDF_SUCCESS); - } + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); sleep(1); if (audiopara.render != nullptr) { audiopara.attrs.type = AUDIO_IN_MEDIA; @@ -820,27 +591,20 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0013, TestSize. audiopara.attrs.format = AUDIO_FORMAT_PCM_16_BIT; audiopara.attrs.sampleRate = 48000; audiopara.attrs.channelCount = 1; - + ret = audiopara.render->attr.SetSampleAttributes(audiopara.render, &(audiopara.attrs)); EXPECT_EQ(HDF_SUCCESS, ret); ret = audiopara.render->attr.GetSampleAttributes(audiopara.render, &attrsValue); EXPECT_EQ(HDF_SUCCESS, ret); - + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); EXPECT_FALSE(attrsValue.interleaved); EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); EXPECT_EQ(samplerateValue, attrsValue.sampleRate); EXPECT_EQ(channelcountValue, attrsValue.channelCount); } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->control.Stop((AudioHandle)(audiopara.render)); + ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); } /** * @tc.name Record audio file @@ -852,28 +616,16 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0001, TestSize { int32_t ret = -1; struct PrepareAudioPara audiopara = { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .self = this, .pins = PIN_IN_MIC, + .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE }; - - ret = GetLoadAdapter(audiopara); + ret = GetManager(audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(ret, HDF_SUCCESS); - } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - EXPECT_EQ(HDF_SUCCESS, ret); - ret = audiopara.capture->control.Stop((AudioHandle)(audiopara.capture)); + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); + ret = ThreadRelease(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); } /** * @tc.name Pause,resume and stop when recording. @@ -885,20 +637,15 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0002, TestSize { int32_t ret = -1; struct PrepareAudioPara audiopara = { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .self = this, .pins = PIN_IN_MIC, + .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE }; - - ret = GetLoadAdapter(audiopara); + ret = GetManager(audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - pthread_t tids; CaptureFrameStatus(1); - ret = pthread_create(&tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(ret, HDF_SUCCESS); - } + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); sleep(1); if (audiopara.capture != nullptr) { CaptureFrameStatus(0); @@ -910,15 +657,8 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0002, TestSize EXPECT_EQ(HDF_SUCCESS, ret); CaptureFrameStatus(1); } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.capture->control.Stop((AudioHandle)(audiopara.capture)); + ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); } /** * @tc.name Set volume when recording audio file @@ -929,22 +669,17 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0002, TestSize HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0003, TestSize.Level1) { int32_t ret = -1; - float val = 0.9; - float getVal = 0; struct PrepareAudioPara audiopara = { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .self = this, .pins = PIN_IN_MIC, + .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE }; - - ret = GetLoadAdapter(audiopara); + float val = 0.9; + float getVal = 0; + ret = GetManager(audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(ret, HDF_SUCCESS); - } + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); sleep(1); if (audiopara.capture != nullptr) { ret = audiopara.capture->volume.SetVolume((AudioHandle)(audiopara.capture), val); @@ -953,15 +688,8 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0003, TestSize EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_FLOAT_EQ(val, getVal); } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.capture->control.Stop((AudioHandle)(audiopara.capture)); + ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); } /** * @tc.name Set Mute when recording audio file @@ -973,21 +701,16 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0004, TestSize { int32_t ret = -1; bool isMute = false; - bool mute = true; struct PrepareAudioPara audiopara = { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .self = this, .pins = PIN_IN_MIC, + .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE }; - - ret = GetLoadAdapter(audiopara); + bool mute = true; + ret = GetManager(audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(ret, HDF_SUCCESS); - } + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); sleep(1); if (audiopara.capture != nullptr) { ret = audiopara.capture->volume.SetMute((AudioHandle)(audiopara.capture), mute); @@ -1003,15 +726,8 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0004, TestSize EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_FALSE(isMute); } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.capture->control.Stop((AudioHandle)(audiopara.capture)); + ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); } /** * @tc.name Set Gain when recording audio file @@ -1024,23 +740,17 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0005, TestSize int32_t ret = -1; float gainMin = 0; float gainMax = 0; - float gainValue = 0; - float gain = 0; struct PrepareAudioPara para = { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .self = this, .pins = PIN_IN_MIC, + .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE }; - - ret = GetLoadAdapter(para); + float gainValue = 0; + float gain = 0; + ret = GetManager(para); ASSERT_EQ(HDF_SUCCESS, ret); - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)RecordAudio, ¶); - if (ret != 0) { - para.manager->UnloadAdapter(para.manager, para.adapter); - ASSERT_EQ(ret, HDF_SUCCESS); - } - + ret = pthread_create(¶.tids, NULL, (THREAD_FUNC)RecordAudio, ¶); + ASSERT_EQ(HDF_SUCCESS, ret); sleep(1); if (para.capture != nullptr) { ret = para.capture->volume.GetGainThreshold(para.capture, &gainMin, &gainMax); @@ -1059,15 +769,8 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0005, TestSize EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_FLOAT_EQ(gainValue, gain); } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = para.capture->control.Stop((AudioHandle)(para.capture)); + ret = ThreadRelease(para); EXPECT_EQ(HDF_SUCCESS, ret); - para.adapter->DestroyCapture(para.adapter, para.capture); - para.manager->UnloadAdapter(para.manager, para.adapter); } /** * @tc.name Set SampleAttributes during recording. @@ -1079,24 +782,20 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0006, TestSize { int32_t ret = -1; struct AudioSampleAttributes attrsValue = {}; - struct AudioSampleAttributes attrs = { - .format = AUDIO_FORMAT_PCM_16_BIT, .channelCount = CHANNELCOUNTEXOECT, .sampleRate = SAMPLERATEEXOECT, - .type = AUDIO_IN_MEDIA, .interleaved = 0 - }; struct PrepareAudioPara audiopara = { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .self = this, .pins = PIN_IN_MIC, + .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE }; - - ret = GetLoadAdapter(audiopara); + struct AudioSampleAttributes attrs = {}; + ret = GetManager(audiopara); ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrs(attrs); + attrs.sampleRate = SAMPLERATEEXOECT; + CaptureFrameStatus(1); - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(ret, HDF_SUCCESS); - } + + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); sleep(1); if (audiopara.capture != nullptr) { @@ -1115,15 +814,8 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0006, TestSize EXPECT_EQ(SAMPLERATEEXOECT, attrsValue.sampleRate); EXPECT_EQ(CHANNELCOUNTEXOECT, attrsValue.channelCount); } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.capture->control.Stop((AudioHandle)(audiopara.capture)); + ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); } /** * @tc.name Get CurrentChannel Id during recording. @@ -1135,37 +827,24 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0007, TestSize { int32_t ret = -1; uint32_t channelId = 0; - uint32_t channelIdValue = CHANNELCOUNT; struct PrepareAudioPara audiopara = { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .self = this, .pins = PIN_IN_MIC, + .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE }; + uint32_t channelIdValue = CHANNELCOUNT; - ret = GetLoadAdapter(audiopara); + ret = GetManager(audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(ret, HDF_SUCCESS); - } sleep(1); if (audiopara.capture != nullptr) { ret = audiopara.capture->attr.GetCurrentChannelId(audiopara.capture, &channelId); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(channelId, channelIdValue); } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.capture->control.Stop((AudioHandle)(audiopara.capture)); + ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); - - audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); } /** * @tc.name Get Frame Size during recording. @@ -1176,22 +855,17 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0007, TestSize HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0008, TestSize.Level1) { int32_t ret = -1; - uint64_t size = 0; - uint64_t sizeExpect = 0; struct PrepareAudioPara audiopara = { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .self = this, .pins = PIN_IN_MIC, + .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE }; - - ret = GetLoadAdapter(audiopara); + uint64_t size = 0; + uint64_t sizeExpect = 0; + ret = GetManager(audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrs(audiopara.attrs); + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(ret, HDF_SUCCESS); - } sleep(1); if (audiopara.capture != nullptr) { ret = audiopara.capture->attr.GetFrameSize(audiopara.capture, &size); @@ -1199,15 +873,8 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0008, TestSize sizeExpect = FrameSizeExpect(audiopara.attrs); EXPECT_EQ(size, sizeExpect); } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.capture->control.Stop((AudioHandle)(audiopara.capture)); + ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); } /** * @tc.name Get Frame Count during recording. @@ -1218,37 +885,25 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0008, TestSize HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0009, TestSize.Level1) { int32_t ret = -1; - uint64_t count = 0; - uint64_t zero = 0; struct PrepareAudioPara audiopara = { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .self = this, .pins = PIN_IN_MIC, + .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE }; - - ret = GetLoadAdapter(audiopara); + uint64_t count = 0; + uint64_t zero = 0; + ret = GetManager(audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(ret, HDF_SUCCESS); - } + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); sleep(1); if (audiopara.capture != nullptr) { ret = audiopara.capture->attr.GetFrameCount(audiopara.capture, &count); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_GT(count, zero); } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.capture->control.Stop((AudioHandle)(audiopara.capture)); + ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); } /** * @tc.name Get Gain during recording. @@ -1260,21 +915,16 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0010, TestSize { int32_t ret = -1; float min = 0; - float max = 0; struct PrepareAudioPara audiopara = { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .self = this, .pins = PIN_IN_MIC, + .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE }; - - ret = GetLoadAdapter(audiopara); + float max = 0; + ret = GetManager(audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(ret, HDF_SUCCESS); - } + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); sleep(1); if (audiopara.capture != nullptr) { ret = audiopara.capture->volume.GetGainThreshold((AudioHandle)(audiopara.capture), &min, &max); @@ -1282,16 +932,8 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0010, TestSize EXPECT_EQ(min, GAIN_MIN); EXPECT_EQ(max, GAIN_MAX); } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.capture->control.Stop((AudioHandle)(audiopara.capture)); + ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); - - audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); } /** * @tc.name Check Scene Capability during recording. @@ -1303,330 +945,25 @@ HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0011, TestSize { int32_t ret = -1; bool supported = false; - struct AudioSceneDescriptor scenes = {}; - scenes.scene.id = 0; - scenes.desc.pins = PIN_IN_MIC; struct PrepareAudioPara audiopara = { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .self = this, .pins = PIN_IN_MIC, + .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE }; - - ret = GetLoadAdapter(audiopara); + struct AudioSceneDescriptor scenes = {}; + scenes.scene.id = 0; + scenes.desc.pins = PIN_IN_MIC; + ret = GetManager(audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(ret, HDF_SUCCESS); - } + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); sleep(1); if (audiopara.capture != nullptr) { ret = audiopara.capture->scene.CheckSceneCapability(audiopara.capture, &scenes, &supported); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_TRUE(supported); } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.capture->control.Stop((AudioHandle)(audiopara.capture)); - EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); -} -/** -* @tc.name Pause,Flush,Resume and Stop when playing audio file based smartPA -* @tc.number SUB_Audio_Function_Smartpa_Test_0001 -* @tc.desc test Render interface by playing an audio file based smartPA successfully. -* @tc.author: wangkang -*/ -HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Smartpa_Test_0001, TestSize.Level1) -{ - int32_t ret = -1; - uint32_t latencyTime = 0; - uint32_t expectedValue = 0; - struct PrepareAudioPara audiopara = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, - .path = AUDIO_FILE.c_str() - }; - - ret = GetLoadAdapter(audiopara); - ASSERT_EQ(HDF_SUCCESS, ret); - - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(ret, HDF_SUCCESS); - } - sleep(1); - if (audiopara.render != nullptr) { - ret = audiopara.render->GetLatency(audiopara.render, &latencyTime); - EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_LT(expectedValue, latencyTime); - ret = audiopara.render->control.Pause((AudioHandle)(audiopara.render)); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->control.Flush((AudioHandle)audiopara.render); - EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); - sleep(3); - ret = audiopara.render->control.Resume((AudioHandle)(audiopara.render)); - EXPECT_EQ(HDF_SUCCESS, ret); - } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->control.Stop((AudioHandle)(audiopara.render)); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->control.Flush((AudioHandle)audiopara.render); - EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); - audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); -} -/** -* @tc.name Setting audio file volume based smartPA -* @tc.number SUB_Audio_Function_Smartpa_Test_0002 -* @tc.desc test Render function,set volume when playing audio file based smartPA. -* @tc.author: wangkang -*/ -HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Smartpa_Test_0002, TestSize.Level1) -{ - int32_t ret = -1; - float volumeMax = 1.0; - float volumeValue[10] = {0}; - float volumeArr[10] = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0}; - struct PrepareAudioPara audiopara = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, - .path = AUDIO_FILE.c_str() - }; - - ret = GetLoadAdapter(audiopara); - ASSERT_EQ(HDF_SUCCESS, ret); - - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(ret, HDF_SUCCESS); - } - sleep(1); - if (audiopara.render != nullptr) { - ret = audiopara.render->volume.SetVolume(audiopara.render, volumeMax); - for (int i = 0; i < 10; i++) { - ret = audiopara.render->volume.SetVolume(audiopara.render, volumeArr[i]); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->volume.GetVolume(audiopara.render, &volumeValue[i]); - EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_EQ(volumeArr[i], volumeValue[i]); - sleep(1); - } - } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->control.Stop((AudioHandle)(audiopara.render)); - EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); -} -/** -* @tc.name SetMute audio files when playing audio file based smartPA -* @tc.number SUB_Audio_Function_Smartpa_Test_0003 -* @tc.desc test render function by SetMute and GetMute when playing audio file based smartPA. -* @tc.author: wangkang -*/ -HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Smartpa_Test_0003, TestSize.Level1) -{ - int32_t ret = -1; - struct PrepareAudioPara audiopara = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, - .path = AUDIO_FILE.c_str() - }; - - ret = GetLoadAdapter(audiopara); - ASSERT_EQ(HDF_SUCCESS, ret); - - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - sleep(1); - if (audiopara.render != nullptr) { - bool muteTrue = true; - bool muteFalse = false; - ret = audiopara.render->volume.SetMute(audiopara.render, muteTrue); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->volume.GetMute(audiopara.render, &muteTrue); - EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_EQ(true, muteTrue); - sleep(1); - ret = audiopara.render->volume.SetMute(audiopara.render, muteFalse); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->volume.GetMute(audiopara.render, &muteFalse); - EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_EQ(false, muteFalse); - } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->control.Stop((AudioHandle)(audiopara.render)); - EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); -} -/** -* @tc.name Get render position when playing audio file based smartPA -* @tc.number SUB_Audio_Function_Smartpa_Test_0004 -* @tc.desc test render functio by Get render position when playing audio file based smartPA. -* @tc.author: wangkang -*/ -HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Smartpa_Test_0004, TestSize.Level1) -{ - int32_t ret = -1; - uint64_t frames = 0; - int64_t timeExp = 0; - struct AudioTimeStamp time = {.tvSec = 0}; - struct PrepareAudioPara audiopara = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, - .path = AUDIO_FILE.c_str() - }; - - ret = GetLoadAdapter(audiopara); - ASSERT_EQ(HDF_SUCCESS, ret); - - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - sleep(1); - if (audiopara.render != nullptr) { - ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &time); - EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_GT(time.tvSec, timeExp); - EXPECT_GT(frames, INITIAL_VALUE); - } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->control.Stop((AudioHandle)(audiopara.render)); - EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); -} -/** -* @tc.name Get frame count and size when playing audio file based smartPA -* @tc.number SUB_Audio_Function_Smartpa_Test_0005 -* @tc.desc test render functio by Get frame count and size when playing audio file based smartPA. -* @tc.author: wangkang -*/ -HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Smartpa_Test_0005, TestSize.Level1) -{ - int32_t ret = -1; - uint64_t size = 0; - uint64_t count = 0; - uint64_t zero = 0; - uint64_t sizeExpect = 0; - struct PrepareAudioPara audiopara = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, - .path = AUDIO_FILE.c_str() - }; - - ret = GetLoadAdapter(audiopara); - ASSERT_EQ(HDF_SUCCESS, ret); - - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - sleep(1); - if (audiopara.render != nullptr) { - ret = audiopara.render->attr.GetFrameSize(audiopara.render, &size); - EXPECT_EQ(HDF_SUCCESS, ret); - sizeExpect = FrameSizeExpect(audiopara.attrs); - EXPECT_EQ(size, sizeExpect); - - ret = audiopara.render->attr.GetFrameCount(audiopara.render, &count); - EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_GT(count, zero); - } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->control.Stop((AudioHandle)(audiopara.render)); - EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); -} -/** -* @tc.name SetSampleAttributes when playing audio file based smartPA -* @tc.number SUB_Audio_Function_Smartpa_Test_0006 -* @tc.desc test render functio by SetSampleAttributes when playing audio file based smartPA. -* @tc.author: wangkang -*/ -HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Smartpa_Test_0006, TestSize.Level1) -{ - int32_t ret = -1; - uint32_t samplerateValue = 48000; - uint32_t channelcountValue = 1; - struct AudioSampleAttributes attrsValue = {}; - struct PrepareAudioPara audiopara = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, - .path = AUDIO_FILE.c_str() - }; - - ret = GetLoadAdapter(audiopara); - ASSERT_EQ(HDF_SUCCESS, ret); - - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - sleep(1); - if (audiopara.render != nullptr) { - audiopara.attrs.type = AUDIO_IN_MEDIA; - audiopara.attrs.format = AUDIO_FORMAT_PCM_16_BIT; - audiopara.attrs.sampleRate = 48000; - audiopara.attrs.channelCount = 1; - audiopara.attrs.stopThreshold = INT_32_MAX; - - ret = audiopara.render->attr.SetSampleAttributes(audiopara.render, &(audiopara.attrs)); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->attr.GetSampleAttributes(audiopara.render, &attrsValue); - EXPECT_EQ(HDF_SUCCESS, ret); - - EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); - EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); - EXPECT_EQ(samplerateValue, attrsValue.sampleRate); - EXPECT_EQ(channelcountValue, attrsValue.channelCount); - EXPECT_EQ(INT_32_MAX, attrsValue.stopThreshold); - } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->control.Stop((AudioHandle)(audiopara.render)); + ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); } } \ No newline at end of file diff --git a/audio/hal/hdi_passthrough/src/BUILD.gn b/audio/test/systemtest/audio_function/audio_smartpa/BUILD.gn similarity index 32% rename from audio/hal/hdi_passthrough/src/BUILD.gn rename to audio/test/systemtest/audio_function/audio_smartpa/BUILD.gn index da21ce1e24..079f37211d 100755 --- a/audio/hal/hdi_passthrough/src/BUILD.gn +++ b/audio/test/systemtest/audio_function/audio_smartpa/BUILD.gn @@ -11,101 +11,67 @@ # See the License for the specific language governing permissions and # limitations under the License. -if (defined(ohos_lite)) { - import("//build/lite/config/component/lite_component.gni") -} else { - import("//build/ohos.gni") -} +import("//build/test.gni") import("//drivers/adapter/uhdf2/uhdf.gni") -import("//drivers/peripheral/audio/audio.gni") - -config("hdi_audio_config") { - visibility = [ ":*" ] - - cflags = [ - "-fPIC", - "-Wall", - "-Wextra", - "-Werror", - "-DGST_DISABLE_DEPRECATED", - "-DHAVE_CONFIG_H", - "-fno-strict-aliasing", - "-Wno-sign-compare", - "-Wno-builtin-requires-header", - "-Wno-implicit-function-declaration", - "-Wno-format", - "-Wno-int-conversion", - "-Wno-unused-function", - "-Wno-unused-parameter", - "-Wno-thread-safety-attributes", - "-Wno-inconsistent-missing-override", - "-fno-rtti", - "-fno-exceptions", - "-ffunction-sections", - "-fdata-sections", - ] - - ldflags = [ "-Wl" ] -} -ohos_shared_library("hdi_audio") { +module_output_path = "hdf/audio" +###########################systemtest############################## +###########################hdfAudioSmartPaTest########################### +ohos_systemtest("hdfAudioSmartPaTest") { + module_out_path = module_output_path sources = [ - "//third_party/cJSON/cJSON.c", - "audio_manager.c", - "audio_common.c", - "audio_adapter.c", - "audio_capture.c", - "audio_render.c", - "audio_adapter_info_common.c", - ] + "src/audio_smartpa_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp", + "../../common/lib_common/src/audio_lib_common.cpp", + "../../common/adm_common/src/audio_adm_common.cpp" + ] include_dirs = [ - "//drivers/peripheral/audio/hal/hdi_passthrough/include", "//drivers/peripheral/audio/supportlibs/adm_adapter/include", - "//third_party/cJSON", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", "//drivers/peripheral/audio/interfaces/include", - "$hdf_framework_path/include/core", - "$hdf_framework_path/include/utils", - "$hdf_framework_path/include/osal", - "$hdf_framework_path/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/include", "//third_party/bounds_checking_function/include", - "$hdf_framework_path/ability/sbuf/include", - "$hdf_framework_path/utils/include", - "$hdf_framework_path/ability/sbuf/include", - "$hdf_uhdf_path/osal/include", - "$hdf_uhdf_path/common/include/core", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/adapter/uhdf2/osal/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//drivers/peripheral/audio/test/systemtest/audio_function/audio_smartpa/include", + "//drivers/peripheral/audio/test/systemtest/common/lib_common/include", + "//drivers/peripheral/audio/test/systemtest/common/adm_common/include", + "//drivers/peripheral/audio/test/systemtest/adm_interface_lib/render/include", + "//drivers/peripheral/audio/test/systemtest/adm/audio_adm_interface/include", + "//third_party/googletest/googletest/include/gtest", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", ] - deps = [ - "$hdf_uhdf_path/osal:libhdf_utils", - "$hdf_uhdf_path/manager:hdf_devmgr", - "$hdf_uhdf_path/manager:hdf_devmgr.rc", "//utils/native/base:utils", - "$hdf_uhdf_path/hdi:libhdi", - "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", - "$hdf_uhdf_path/host:hdf_devhost", - "$hdf_uhdf_path/host:libhdf_host", - "$hdf_uhdf_path/config:libhdf_hcs", - "$hdf_uhdf_path/hcs:hdf_default.hcb", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + "//utils/native/base:utils", + "//drivers/adapter/uhdf2/hdi:libhdi", + "//drivers/adapter/uhdf2/manager:hdf_devmgr", + "//drivers/adapter/uhdf2/manager:hdf_devmgr.rc", + "//drivers/adapter/uhdf2/ipc:libhdf_ipc_adapter", + "//drivers/adapter/uhdf2/osal:libhdf_utils", + "//drivers/adapter/uhdf2/host:hdf_devhost", + "//drivers/adapter/uhdf2/host:libhdf_host", + "//drivers/adapter/uhdf2/config:libhdf_hcs", + "//drivers/adapter/uhdf2/hcs:hdf_default.hcb", ] - - defines = [] - if (enable_audio_device_mpi) { - defines += [ "AUDIO_HAL_USER" ] - } - - defines = [] - if (enable_audio_hal_notsupport_pathselect) { - defines += [ "AUDIO_HAL_NOTSUPPORT_PATHSELECT" ] - } - - if (is_standard_system) { - external_deps = [ "hiviewdfx_hilog_native:libhilog" ] - } else { - external_deps = [ "hilog:libhilog" ] - } - - public_configs = [ ":hdi_audio_config" ] - - subsystem_name = "hdf" } +###########################end########################### \ No newline at end of file diff --git a/audio/test/systemtest/audio_function/audio_smartpa/include/audio_smartpa_test.h b/audio/test/systemtest/audio_function/audio_smartpa/include/audio_smartpa_test.h new file mode 100755 index 0000000000..6f2a905348 --- /dev/null +++ b/audio/test/systemtest/audio_function/audio_smartpa/include/audio_smartpa_test.h @@ -0,0 +1,22 @@ +/* + * 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 AUDIO_SMARTPA_TEST_H +#define AUDIO_SMARTPA_TEST_H + +#include "audio_interface_lib_render.h" +#include "audio_adm_interface_test.h" + +#endif diff --git a/audio/test/systemtest/audio_function/audio_smartpa/src/audio_smartpa_test.cpp b/audio/test/systemtest/audio_function/audio_smartpa/src/audio_smartpa_test.cpp new file mode 100755 index 0000000000..8ec55fdc12 --- /dev/null +++ b/audio/test/systemtest/audio_function/audio_smartpa/src/audio_smartpa_test.cpp @@ -0,0 +1,597 @@ +/* + * 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 "audio_lib_common.h" +#include "audio_smartpa_test.h" + +using namespace std; +using namespace testing::ext; +using namespace HMOS::Audio; + +namespace { +const string AUDIO_FILE = "//bin/audiorendertest.wav"; +const string ADAPTER_NAME_HDMI = "hdmi"; +const string ADAPTER_NAME_USB = "usb"; +const string ADAPTER_NAME_INTERNAL = "internal"; +const string BIND_CONTROL = "control"; +const string BIND_RENDER = "render"; +const string BIND_NAME_ERROR = "rendeo"; + +class AudioSmartPaTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + static struct AudioManager *(*GetAudioManager)(); + static void *handleSo; + static struct DevHandle *(*BindServiceRenderSo)(const char *); + static int32_t (*InterfaceLibOutputRender)(struct DevHandle *, int, struct AudioHwRenderParam *); + static int32_t (*InterfaceLibCtlRender)(struct DevHandle *, int, struct AudioHwRenderParam *); + static void (*CloseServiceRenderSo)(struct DevHandle *); + static void *PtrHandle; + static int32_t GetManager(struct PrepareAudioPara& audiopara); + uint32_t FrameSizeExpect(const struct AudioSampleAttributes attrs); + uint32_t BindServiceAndHwRender(struct AudioHwRender *&hwRender, const std::string BindName, + const std::string adapterNameCase, struct DevHandle *&handle) const; +}; + +struct AudioManager *(*AudioSmartPaTest::GetAudioManager)() = nullptr; +void *AudioSmartPaTest::handleSo = nullptr; +struct DevHandle *(*AudioSmartPaTest::BindServiceRenderSo)(const char *) = nullptr; +int32_t (*AudioSmartPaTest::InterfaceLibOutputRender)(struct DevHandle *, int, struct AudioHwRenderParam *) = nullptr; +int32_t (*AudioSmartPaTest::InterfaceLibCtlRender)(struct DevHandle *, int, struct AudioHwRenderParam *) = nullptr; +void (*AudioSmartPaTest::CloseServiceRenderSo)(struct DevHandle *) = nullptr; +void *AudioSmartPaTest::PtrHandle = nullptr; +using THREAD_FUNC = void *(*)(void *); + +void AudioSmartPaTest::SetUpTestCase(void) +{ + string functionName = "GetAudioManagerFuncs"; + string resolvedPath = "//system/lib/libhdi_audio.z.so"; + if (IS_SERVICE) { + functionName = "GetAudioProxyManagerFuncs"; + resolvedPath = "//system/lib/libaudio_hdi_proxy_server.z.so"; + } + handleSo = dlopen(resolvedPath.c_str(), RTLD_LAZY); + if (handleSo == nullptr) { + return; + } + GetAudioManager = (struct AudioManager *(*)())(dlsym(handleSo, functionName.c_str())); + if (GetAudioManager == nullptr) { + return; + } + string resolvedPathOne = "//system/lib/libhdi_audio_interface_lib_render.z.so"; + PtrHandle = dlopen(resolvedPathOne.c_str(), RTLD_LAZY); + if (PtrHandle == nullptr) { + return; + } + BindServiceRenderSo = (struct DevHandle* (*)(const char *))dlsym(PtrHandle, "AudioBindServiceRender"); + InterfaceLibOutputRender = (int32_t (*)(struct DevHandle *, int, + struct AudioHwRenderParam *))dlsym(PtrHandle, "AudioInterfaceLibOutputRender"); + InterfaceLibCtlRender = (int32_t (*)(struct DevHandle *, int, + struct AudioHwRenderParam *))dlsym(PtrHandle, "AudioInterfaceLibCtlRender"); + CloseServiceRenderSo = (void (*)(struct DevHandle *))dlsym(PtrHandle, "AudioCloseServiceRender"); + if (BindServiceRenderSo == nullptr || CloseServiceRenderSo == nullptr || + InterfaceLibCtlRender == nullptr || InterfaceLibOutputRender == nullptr) { + dlclose(PtrHandle); + return; + } +} + +void AudioSmartPaTest::TearDownTestCase(void) +{ + if (GetAudioManager != nullptr) { + GetAudioManager = nullptr; + } + if (PtrHandle != nullptr) { + dlclose(PtrHandle); + PtrHandle = nullptr; + } + if (BindServiceRenderSo != nullptr) { + BindServiceRenderSo = nullptr; + } + if (CloseServiceRenderSo != nullptr) { + CloseServiceRenderSo = nullptr; + } + if (InterfaceLibOutputRender != nullptr) { + InterfaceLibOutputRender = nullptr; + } + if (InterfaceLibCtlRender != nullptr) { + InterfaceLibCtlRender = nullptr; + } +} + +void AudioSmartPaTest::SetUp(void) {} + +void AudioSmartPaTest::TearDown(void) {} + +int32_t AudioSmartPaTest::GetManager(struct PrepareAudioPara& audiopara) +{ + auto *inst = (AudioSmartPaTest *)audiopara.self; + if (inst != nullptr && inst->GetAudioManager != nullptr) { + audiopara.manager = inst->GetAudioManager(); + } + if (audiopara.manager == nullptr) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +uint32_t AudioSmartPaTest::FrameSizeExpect(const struct AudioSampleAttributes attrs) +{ + if (attrs.channelCount < 1 || attrs.channelCount > 2) { + return 0; + } + uint32_t sizeExpect = FRAME_SIZE * (attrs.channelCount) * (PcmFormatToBits(attrs.format) >> MOVE_RIGHT_NUM); + return sizeExpect; +} + +uint32_t AudioSmartPaTest::BindServiceAndHwRender(struct AudioHwRender *&hwRender, + const std::string BindName, const std::string adapterNameCase, struct DevHandle *&handle) const +{ + handle = BindServiceRenderSo(BindName.c_str()); + if (handle == nullptr) { + return HDF_FAILURE; + } + hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); + if (hwRender == nullptr) { + CloseServiceRenderSo(handle); + return HDF_FAILURE; + } + if (InitHwRender(hwRender, adapterNameCase)) { + CloseServiceRenderSo(handle); + free(hwRender); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} +/** +* @tc.name Pause,Flush,Resume and Stop when playing audio file based smartPA +* @tc.number SUB_Audio_Function_Smartpa_Test_0001 +* @tc.desc test Render interface by playing an audio file based smartPA successfully. +* @tc.author: wangkang +*/ +HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0001, TestSize.Level1) +{ + int32_t ret = -1; + uint32_t latencyTime = 0; + uint32_t expectedValue = 0; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }; + + ret = GetManager(audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); + + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); + if (ret != 0) { + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); + ASSERT_EQ(ret, HDF_SUCCESS); + } + sleep(1); + ret = audiopara.render->GetLatency(audiopara.render, &latencyTime); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_LT(expectedValue, latencyTime); + ret = audiopara.render->control.Pause((AudioHandle)(audiopara.render)); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->control.Flush((AudioHandle)audiopara.render); + EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); + sleep(3); + ret = audiopara.render->control.Resume((AudioHandle)(audiopara.render)); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = ThreadRelease(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); +} +/** +* @tc.name Setting audio file volume based smartPA +* @tc.number SUB_Audio_Function_Smartpa_Test_0002 +* @tc.desc test Render function,set volume when playing audio file based smartPA. +* @tc.author: wangkang +*/ +HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0002, TestSize.Level1) +{ + int32_t ret = -1; + float volumeMax = 1.0; + float volumeValue[10] = {0}; + float volumeArr[10] = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0}; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }; + + ret = GetManager(audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); + + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); + if (ret != 0) { + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); + ASSERT_EQ(ret, HDF_SUCCESS); + } + sleep(1); + ret = audiopara.render->volume.SetVolume(audiopara.render, volumeMax); + for (int i = 0; i < 10; i++) { + ret = audiopara.render->volume.SetVolume(audiopara.render, volumeArr[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->volume.GetVolume(audiopara.render, &volumeValue[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(volumeArr[i], volumeValue[i]); + sleep(3); + } + + ret = ThreadRelease(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); +} +/** +* @tc.name SetMute audio files when playing audio file based smartPA +* @tc.number SUB_Audio_Function_Smartpa_Test_0003 +* @tc.desc test render function by SetMute and GetMute when playing audio file based smartPA. +* @tc.author: wangkang +*/ +HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }; + + ret = GetManager(audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); + + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); + if (ret != 0) { + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); + ASSERT_EQ(HDF_SUCCESS, ret); + } + sleep(1); + bool muteTrue = true; + bool muteFalse = false; + ret = audiopara.render->volume.SetMute(audiopara.render, muteTrue); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->volume.GetMute(audiopara.render, &muteTrue); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(true, muteTrue); + sleep(3); + ret = audiopara.render->volume.SetMute(audiopara.render, muteFalse); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->volume.GetMute(audiopara.render, &muteFalse); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(false, muteFalse); + + ret = ThreadRelease(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); +} +/** +* @tc.name Get render position when playing audio file based smartPA +* @tc.number SUB_Audio_Function_Smartpa_Test_0004 +* @tc.desc test render function by Get render position when playing audio file based smartPA. +* @tc.author: wangkang +*/ +HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0004, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }; + uint64_t frames = 0; + int64_t timeExp = 0; + struct AudioTimeStamp time = {.tvSec = 0}; + + ret = GetManager(audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); + + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); + if (ret != 0) { + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); + ASSERT_EQ(HDF_SUCCESS, ret); + } + sleep(3); + ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &time); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(time.tvSec, timeExp); + EXPECT_GT(frames, INITIAL_VALUE); + + ret = ThreadRelease(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); +} +/** +* @tc.name Get frame count and size when playing audio file based smartPA +* @tc.number SUB_Audio_Function_Smartpa_Test_0005 +* @tc.desc test render function by Get frame count and size when playing audio file based smartPA. +* @tc.author: wangkang +*/ +HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0005, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }; + uint64_t size = 0; + uint64_t count = 0; + uint64_t zero = 0; + uint64_t sizeExpect = 0; + + ret = GetManager(audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); + + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); + if (ret != 0) { + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); + ASSERT_EQ(HDF_SUCCESS, ret); + } + sleep(1); + ret = audiopara.render->attr.GetFrameSize(audiopara.render, &size); + EXPECT_EQ(HDF_SUCCESS, ret); + sizeExpect = FrameSizeExpect(audiopara.attrs); + EXPECT_EQ(size, sizeExpect); + + ret = audiopara.render->attr.GetFrameCount(audiopara.render, &count); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(count, zero); + + ret = ThreadRelease(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); +} +/** +* @tc.name SetSampleAttributes when playing audio file based smartPA +* @tc.number SUB_Audio_Function_Smartpa_Test_0006 +* @tc.desc test render function by SetSampleAttributes when playing audio file based smartPA. +* @tc.author: wangkang +*/ +HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0006, TestSize.Level1) +{ + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }; + int32_t ret = -1; + uint32_t samplerateValue = 48000; + uint32_t channelcountValue = 1; + struct AudioSampleAttributes attrsValue = {}; + + ret = GetManager(audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); + + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); + if (ret != 0) { + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); + ASSERT_EQ(HDF_SUCCESS, ret); + } + sleep(1); + audiopara.attrs.type = AUDIO_IN_MEDIA; + audiopara.attrs.format = AUDIO_FORMAT_PCM_16_BIT; + audiopara.attrs.sampleRate = 48000; + audiopara.attrs.channelCount = 1; + audiopara.attrs.stopThreshold = INT_32_MAX; + + ret = audiopara.render->attr.SetSampleAttributes(audiopara.render, &(audiopara.attrs)); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->attr.GetSampleAttributes(audiopara.render, &attrsValue); + EXPECT_EQ(HDF_SUCCESS, ret); + + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(samplerateValue, attrsValue.sampleRate); + EXPECT_EQ(channelcountValue, attrsValue.channelCount); + EXPECT_EQ(INT_32_MAX, attrsValue.stopThreshold); + + ret = ThreadRelease(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); +} +/** +* @tc.name test InterfaceLibCtlRender API via writing GetVolthreshold value that +* Hardware equipment of Acodec_ChangeOut. +* @tc.number SUB_Audio_Function_Smartpa_Test_0007 +* @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0007, TestSize.Level1) +{ + int32_t ret = -1; + float thresholdValueMax = 0; + float thresholdValueMin = 0; + float expMax = 127; + float expMix = 40; + struct DevHandle *handle = nullptr; + struct AudioHwRender *hwRender = nullptr; + + ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_HDMI, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_OUT, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + thresholdValueMax = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax; + thresholdValueMin = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin; + EXPECT_EQ(expMax, thresholdValueMax); + EXPECT_EQ(expMix, thresholdValueMin); + CloseServiceRenderSo(handle); + free(hwRender); +} +/** +* @tc.name test InterfaceLibCtlRender API via using smartpa. +* @tc.number SUB_Audio_Function_Smartpa_Test_0008 +* @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_OUT. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0008, TestSize.Level1) +{ + int32_t ret = -1; + struct DevHandle *handle = nullptr; + struct AudioHwRender *hwRender = nullptr; + ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_HDMI, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_OUT, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + CloseServiceRenderSo(handle); + free(hwRender); +} +/** +* @tc.name test InterfaceLibCtlRender API via writing volume value of smartpa is normal value and reading +* this value. +* @tc.number SUB_Audio_Function_Smartpa_Test_0009 +* @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0009, TestSize.Level1) +{ + int32_t ret = -1; + float volumevalue = 0; + float thresholdValueMaxOut = 0; + float thresholdValueMinOut = 0; + float volumeBoundaryValueOut = 127.9; + struct DevHandle *handle = nullptr; + struct AudioHwRender *hwRender = nullptr; + ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_HDMI, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + thresholdValueMaxOut = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax; + thresholdValueMinOut = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin; + + hwRender->renderParam.renderMode.ctlParam.volume = thresholdValueMinOut+1; + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + volumevalue = hwRender->renderParam.renderMode.ctlParam.volume; + EXPECT_EQ(41, volumevalue); + + hwRender->renderParam.renderMode.ctlParam.volume = thresholdValueMaxOut-1; + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + volumevalue = hwRender->renderParam.renderMode.ctlParam.volume; + EXPECT_EQ(126, volumevalue); + + hwRender->renderParam.renderMode.ctlParam.volume = volumeBoundaryValueOut; + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + volumevalue = hwRender->renderParam.renderMode.ctlParam.volume; + EXPECT_EQ(127, volumevalue); + + CloseServiceRenderSo(handle); + free(hwRender); +} +/** +* @tc.name test InterfaceLibCtlRender API via writing volume value of smartpa is boundary value and reading +* this value. +* @tc.number SUB_Audio_Function_Smartpa_Test_0010 +* @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0010, TestSize.Level1) +{ + int32_t ret = -1; + float thresholdValueMin = 0; + float thresholdValueMax = 0; + float volumevalue = 0; + struct DevHandle *handle = nullptr; + struct AudioHwRender *hwRender = nullptr; + ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_HDMI, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + thresholdValueMax = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax; + thresholdValueMin = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin; + hwRender->renderParam.renderMode.ctlParam.volume = thresholdValueMin; + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + volumevalue = hwRender->renderParam.renderMode.ctlParam.volume; + EXPECT_EQ(40, volumevalue); + + hwRender->renderParam.renderMode.ctlParam.volume = thresholdValueMax; + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + volumevalue = hwRender->renderParam.renderMode.ctlParam.volume; + EXPECT_EQ(127, volumevalue); + + CloseServiceRenderSo(handle); + free(hwRender); +} +/** +* @tc.name test InterfaceLibCtlRender API via writing volume value of smartpa is invalid value. +* @tc.number SUB_Audio_Function_Smartpa_Test_0011 +* @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0011, TestSize.Level1) +{ + int32_t ret = -1; + float volumeThresholdValueMax = 0; + float volumeThresholdValueMin = 0; + struct DevHandle *handle = nullptr; + struct AudioHwRender *hwRender = nullptr; + ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_HDMI, handle); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + volumeThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax; + volumeThresholdValueMin = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin; + + hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMax + 1; + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam); + EXPECT_EQ(HDF_FAILURE, ret); + + hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMin - 1; + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam); + EXPECT_EQ(HDF_FAILURE, ret); + + CloseServiceRenderSo(handle); + free(hwRender); +} +/** +* @tc.name Test AudioAdapterInitAllPorts API when the adapter is smartpa. +* @tc.number SUB_Audio_Function_Smartpa_Test_0012 +* @tc.desc Test AudioAdapterInitAllPorts interface, return 0 if the ports are initialized successfully. +* @tc.author: liutian +*/ +HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0012, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str() + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = HMOS::Audio::GetLoadAdapter(*audiopara.manager, audiopara.portType, audiopara.adapterName, + &audiopara.adapter, audiopara.audioPort); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = audiopara.adapter->InitAllPorts(audiopara.adapter); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} +} \ No newline at end of file diff --git a/audio/test/systemtest/common/adm_common/include/audio_adm_common.h b/audio/test/systemtest/common/adm_common/include/audio_adm_common.h index 7c9b7059ce..77e42bcf47 100755 --- a/audio/test/systemtest/common/adm_common/include/audio_adm_common.h +++ b/audio/test/systemtest/common/adm_common/include/audio_adm_common.h @@ -36,45 +36,13 @@ to buffer #ifndef AUDIO_ADM_COMMON_H #define AUDIO_ADM_COMMON_H -#include -#include "audio_adapter.h" -#include "audio_internal.h" -#include "audio_types.h" -#include "hdf_io_service_if.h" #include "osal_mem.h" -#include "hdf_sbuf.h" +#include "audio_hdi_common.h" namespace HMOS { namespace Audio { -const std::string HDF_CONTROL_SERVICE = "hdf_audio_control"; -const std::string HDF_RENDER_SERVICE = "hdf_audio_render"; -const std::string HDF_CAPTURE_SERVICE = "hdf_audio_capture"; -const int AUDIODRV_CTL_ELEM_IFACE_DAC = 0; /* virtual dac device */ -const int AUDIODRV_CTL_ELEM_IFACE_ADC = 1; /* virtual adc device */ -const int AUDIODRV_CTL_ELEM_IFACE_GAIN = 2; /* virtual adc device */ -const int AUDIODRV_CTL_ELEM_IFACE_MIXER = 3; /* virtual mixer device */ -const int AUDIODRV_CTL_ELEM_IFACE_ACODEC = 4; /* Acodec device */ -const int AUDIODRV_CTL_ELEM_IFACE_PGA = 5; /* PGA device */ -const int AUDIODRV_CTL_ELEM_IFACE_AIAO = 6; /* AIAO device */ -const std::string AUDIO_RIFF = "RIFF"; -const std::string AUDIO_WAVE = "WAVE"; -const std::string AUDIO_DATA = "data"; const int REGISTER_STATUS_ON = 0; const int REGISTER_STATUS_OFF = 1; -const int MOVE_LEFT_NUM = 8; -const int G_CHANNELCOUNT = 2; -const int G_SAMPLERATE = 2; -const int G_PCM16BIT = 16; -const int G_PCM8BIT = 8; -const int G_PCM24BIT = 24; -const int Move_Right = 3; - -enum ControlDispMethodCmd { - AUDIODRV_CTL_IOCTL_ELEM_INFO, - AUDIODRV_CTL_IOCTL_ELEM_READ, - AUDIODRV_CTL_IOCTL_ELEM_WRITE, - AUDIODRV_CTL_IOCTL_ELEM_BUTT, -}; enum StreamDispMethodCmd { AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, @@ -110,68 +78,25 @@ struct AudioPcmHwParams { uint32_t silenceThreshold; }; -struct AudioCtlElemId { - const char *cardServiceName; - int32_t iface; - const char *itemName; /* ASCII name of item */ -}; - -struct AudioCtlElemValue { - struct AudioCtlElemId id; - int32_t value[2]; -}; - struct AudioXferi { char *buf; unsigned long bufsize; unsigned long frameSize; }; -enum AudioPCMBit { - PCM_8_BIT = 8, - PCM_16_BIT = 16, - PCM_24_BIT = 24, - PCM_32_BIT = 32, -}; - -struct AudioHeadInfo { - uint32_t testFileRiffId; - uint32_t testFileRiffSize; - uint32_t testFileFmt; - uint32_t audioFileFmtId; - uint32_t audioFileFmtSize; - uint16_t audioFileFormat; - uint16_t audioChannelNum; - uint32_t audioSampleRate; - uint32_t audioByteRate; - uint16_t audioBlockAlign; - uint16_t audioBitsPerSample; - uint32_t dataId; - uint32_t dataSize; -}; - -int32_t WriteIdToBuf(struct HdfSBuf *sBuf, struct AudioCtlElemId id); - -int32_t WriteEleValueToBuf(struct HdfSBuf *sBuf, struct AudioCtlElemValue elemvalue); - int32_t WriteHwParamsToBuf(struct HdfSBuf *sBuf, struct AudioPcmHwParams hwParams); -int32_t WavHeadAnalysis(struct AudioHeadInfo& wavHeadInfo, FILE *file, struct AudioSampleAttributes& attrs); - -uint32_t PcmFormatToBitsCapture(enum AudioFormat format); - -int32_t InitAttrs(struct AudioSampleAttributes& attrs); +int32_t AdmRenderFramePrepare(const std::string &path, char *&frame, unsigned long& numRead, unsigned long& frameSize); -int32_t AdmRenderFramePrepare(const std::string path, char *&frame, unsigned long& numRead, unsigned long& frameSize); +int32_t WriteFrameToSBuf(struct HdfSBuf *&sBufT, const std::string &path); -uint32_t FormatToBits(enum AudioFormat format); +int32_t ObtainBuf(struct HdfSBuf *&readBuf, struct HdfSBuf *&readReply); -uint32_t PcmBytesToFrames(const struct AudioFrameRenderMode& frameRenderMode, uint64_t bytes); +int32_t WriteCtrlInfo(struct HdfIoService *service, struct AudioCtlElemValue writeElemValue); -int32_t WriteFrameToSBuf(struct HdfSBuf *&sBufT, char *buf, unsigned long bufsize, - unsigned long frameSize, const std::string path); +int32_t ReadCtrlInfo(struct HdfIoService *service, struct AudioCtlElemId id, int32_t expectValue); -int32_t ObtainBuf(struct HdfSBuf *&writeBuf, struct HdfSBuf *&readBuf, struct HdfSBuf *&readReply); +int32_t WriteHwParams(std::string serviceName, struct HdfIoService *&service, struct AudioPcmHwParams hwParams); } } #endif // AUDIO_ADM_COMMON_H diff --git a/audio/test/systemtest/common/adm_common/src/audio_adm_common.cpp b/audio/test/systemtest/common/adm_common/src/audio_adm_common.cpp index c5b5046d83..7522018c23 100755 --- a/audio/test/systemtest/common/adm_common/src/audio_adm_common.cpp +++ b/audio/test/systemtest/common/adm_common/src/audio_adm_common.cpp @@ -39,39 +39,6 @@ using namespace std; namespace HMOS { namespace Audio { -int32_t WriteIdToBuf(struct HdfSBuf *sBuf, struct AudioCtlElemId id) -{ - if (sBuf == nullptr) { - return HDF_FAILURE; - } - if (!HdfSbufWriteInt32(sBuf, id.iface)) { - return HDF_FAILURE; - } - if (!HdfSbufWriteString(sBuf, id.cardServiceName)) { - return HDF_FAILURE; - } - if (!HdfSbufWriteString(sBuf, id.itemName)) { - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t WriteEleValueToBuf(struct HdfSBuf *sBuf, struct AudioCtlElemValue elemvalue) -{ - int32_t ret = -1; - if (sBuf == nullptr) { - return HDF_FAILURE; - } - if (!HdfSbufWriteInt32(sBuf, elemvalue.value[0])) { - return HDF_FAILURE; - } - ret = WriteIdToBuf(sBuf, elemvalue.id); - if (ret != HDF_SUCCESS) { - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - int32_t WriteHwParamsToBuf(struct HdfSBuf *sBuf, struct AudioPcmHwParams hwParams) { if (sBuf == nullptr) { @@ -122,110 +89,14 @@ int32_t WriteHwParamsToBuf(struct HdfSBuf *sBuf, struct AudioPcmHwParams hwParam return HDF_SUCCESS; } -int32_t InitAttrs(struct AudioSampleAttributes& attrs) -{ - attrs.format = AUDIO_FORMAT_PCM_16_BIT; - attrs.channelCount = G_CHANNELCOUNT; - attrs.sampleRate = G_SAMPLERATE; - attrs.interleaved = 0; - attrs.type = AUDIO_IN_MEDIA; - return HDF_SUCCESS; -} - -uint32_t StringToInt(std::string flag) -{ - uint32_t temp = flag[0]; - for (int i = flag.size() - 1; i >= 0; i--) { - temp <<= MOVE_LEFT_NUM; - temp += flag[i]; - } - return temp; -} - -uint32_t PcmFormatToBits(enum AudioFormat format) -{ - switch (format) { - case AUDIO_FORMAT_PCM_16_BIT: - return PCM_16_BIT; - case AUDIO_FORMAT_PCM_8_BIT: - return PCM_8_BIT; - default: - return PCM_8_BIT; - }; -} - -int32_t WavHeadAnalysis(struct AudioHeadInfo& wavHeadInfo, FILE *file, struct AudioSampleAttributes& attrs) -{ - int ret = 0; - if (file == nullptr) { - return HDF_FAILURE; - } - ret = fread(&wavHeadInfo, sizeof(wavHeadInfo), 1, file); - if (ret != 1) { - return HDF_FAILURE; - } - uint32_t audioRiffId = StringToInt(AUDIO_RIFF); - uint32_t audioFileFmt = StringToInt(AUDIO_WAVE); - uint32_t aduioDataId = StringToInt(AUDIO_DATA); - if (wavHeadInfo.testFileRiffId != audioRiffId || wavHeadInfo.testFileFmt != audioFileFmt || - wavHeadInfo.dataId != aduioDataId) { - return HDF_FAILURE; - } - attrs.channelCount = wavHeadInfo.audioChannelNum; - attrs.sampleRate = wavHeadInfo.audioSampleRate; - switch (wavHeadInfo.audioBitsPerSample) { - case PCM_8_BIT: { - attrs.format = AUDIO_FORMAT_PCM_8_BIT; - break; - } - case PCM_16_BIT: { - attrs.format = AUDIO_FORMAT_PCM_16_BIT; - break; - } - case PCM_24_BIT: { - attrs.format = AUDIO_FORMAT_PCM_24_BIT; - break; - } - case PCM_32_BIT: { - attrs.format = AUDIO_FORMAT_PCM_32_BIT; - break; - } - default: - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -uint32_t PcmFramesToBytes(const struct AudioSampleAttributes attrs) -{ - uint32_t ret = 512 * (attrs.channelCount) * (PcmFormatToBits(attrs.format) >> 3); - return ret; -} - -uint32_t FormatToBits(enum AudioFormat format) -{ - switch (format) { - case AUDIO_FORMAT_PCM_16_BIT: - return G_PCM16BIT; - case AUDIO_FORMAT_PCM_8_BIT: - return G_PCM8BIT; - default: - return G_PCM16BIT; - } -} - -int32_t AdmRenderFramePrepare(const std::string path, char *&frame, unsigned long& numRead, unsigned long& frameSize) +int32_t AdmRenderFramePrepare(const std::string &path, char *&frame, uint32_t& numRead, uint32_t& frameSize) { int32_t ret = -1; - int readSize = 0; - int bufferSize = 0; - int remainingDataSize = 0; + uint32_t readSize = 0; + uint32_t bufferSize = 0; + struct AudioSampleAttributes attrs = {}; - struct AudioHeadInfo headInfo = {}; - ret = InitAttrs(attrs); - if (ret < 0) { - return HDF_FAILURE; - } + InitAttrs(attrs); char absPath[PATH_MAX] = {0}; if (realpath(path.c_str(), absPath) == nullptr) { return HDF_FAILURE; @@ -234,34 +105,43 @@ int32_t AdmRenderFramePrepare(const std::string path, char *&frame, unsigned lon if (file == nullptr) { return HDF_FAILURE; } + struct AudioHeadInfo headInfo = {}; ret = WavHeadAnalysis(headInfo, file, attrs); if (ret < 0) { fclose(file); return HDF_FAILURE; } bufferSize = PcmFramesToBytes(attrs); + if (bufferSize <= 0) { + fclose(file); + return HDF_FAILURE; + } frame = (char *)calloc(1, bufferSize); if (frame == nullptr) { fclose(file); return HDF_FAILURE; } + uint32_t remainingDataSize = 0; remainingDataSize = headInfo.dataSize; readSize = (remainingDataSize) > (bufferSize) ? (bufferSize) : (remainingDataSize); numRead = fread(frame, 1, readSize, file); if (numRead < 0) { fclose(file); + free(frame); return HDF_FAILURE; } - frameSize = numRead / (attrs.channelCount * (FormatToBits(attrs.format) >> Move_Right)); + frameSize = numRead / (attrs.channelCount * (PcmFormatToBits(attrs.format) >> MOVE_RIGHT_NUM)); fclose(file); return HDF_SUCCESS; } -int32_t WriteFrameToSBuf(struct HdfSBuf *&sBufT, char *buf, unsigned long bufsize, - unsigned long frameSize, const std::string path) +int32_t WriteFrameToSBuf(struct HdfSBuf *&sBufT, const std::string &path) { int32_t ret = -1; sBufT = HdfSBufObtainDefaultSize(); + char *buf = nullptr; + uint32_t bufsize = 0; + uint32_t frameSize = 0; if (sBufT == NULL) { return HDF_FAILURE; } @@ -271,32 +151,128 @@ int32_t WriteFrameToSBuf(struct HdfSBuf *&sBufT, char *buf, unsigned long bufsiz return HDF_FAILURE; } - if (!HdfSbufWriteUint32(sBufT, (uint32_t)(frameSize))) { + if (!HdfSbufWriteUint32(sBufT, frameSize)) { + free(buf); + buf = nullptr; return HDF_FAILURE; } if (!HdfSbufWriteBuffer(sBufT, buf, bufsize)) { + free(buf); + buf = nullptr; return HDF_FAILURE; } + free(buf); + buf = nullptr; return HDF_SUCCESS; } -int32_t ObtainBuf(struct HdfSBuf *&writeBuf, struct HdfSBuf *&readBuf, struct HdfSBuf *&readReply) +int32_t ObtainBuf(struct HdfSBuf *&readBuf, struct HdfSBuf *&readReply) { + readBuf = HdfSBufObtainDefaultSize(); + if (readBuf == nullptr) { + return HDF_FAILURE; + } + readReply = HdfSBufObtainDefaultSize(); + if (readReply == nullptr) { + HdfSBufRecycle(readBuf); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +void RecycleBuf(struct HdfSBuf *&readBuf, struct HdfSBuf *&readReply) +{ + HdfSBufRecycle(readBuf); + HdfSBufRecycle(readReply); +} + +int32_t WriteCtrlInfo(struct HdfIoService *service, struct AudioCtlElemValue writeElemValue) +{ + int32_t ret = -1; + struct HdfSBuf *writeBuf = nullptr; + if (service == nullptr || service->dispatcher == nullptr) { + return HDF_FAILURE; + } + writeBuf = HdfSBufObtainDefaultSize(); if (writeBuf == nullptr) { return HDF_FAILURE; } - readBuf = HdfSBufObtainDefaultSize(); - if (readBuf == nullptr) { + ret = WriteEleValueToBuf(writeBuf, writeElemValue); + if (ret < 0) { HdfSBufRecycle(writeBuf); return HDF_FAILURE; } - readReply = HdfSBufObtainDefaultSize(); - if (readReply == nullptr) { + ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTRL_IOCTRL_ELEM_WRITE, writeBuf, nullptr); + if (ret < 0) { HdfSBufRecycle(writeBuf); - HdfSBufRecycle(readBuf); return HDF_FAILURE; } + HdfSBufRecycle(writeBuf); + return HDF_SUCCESS; +} + +int32_t ReadCtrlInfo(struct HdfIoService *service, struct AudioCtlElemId id, int32_t expectValue) +{ + int32_t ret = -1; + struct HdfSBuf *readBuf = nullptr; + struct HdfSBuf *readReply = nullptr; + struct AudioCtlElemValue readElemValue = {}; + if (service == nullptr || service->dispatcher == nullptr) { + return HDF_FAILURE; + } + ret = ObtainBuf(readBuf, readReply); + if (ret < 0) { + return HDF_FAILURE; + } + ret = WriteIdToBuf(readBuf, id); + if (ret < 0) { + RecycleBuf(readBuf, readReply); + return HDF_FAILURE; + } + ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTRL_IOCTRL_ELEM_READ, readBuf, readReply); + if (ret < 0) { + RecycleBuf(readBuf, readReply); + return HDF_FAILURE; + } + ret = HdfSbufReadInt32(readReply, &readElemValue.value[0]); + if (ret < 0 || expectValue != readElemValue.value[0]) { + RecycleBuf(readBuf, readReply); + return HDF_FAILURE; + } + RecycleBuf(readBuf, readReply); + return HDF_SUCCESS; +} +int32_t WriteHwParams(string serviceName, struct HdfIoService *&service, struct AudioPcmHwParams hwParams) +{ + int32_t ret = -1; + struct HdfSBuf *writeBuf = nullptr; + struct HdfSBuf *writeReply = nullptr; + service = HdfIoServiceBind(serviceName.c_str()); + if (service == nullptr || service->dispatcher == nullptr) { + return HDF_FAILURE; + } + writeBuf = HdfSBufObtainDefaultSize(); + if (writeBuf == nullptr) { + HdfIoServiceRecycle(service); + service = nullptr; + return HDF_FAILURE; + } + ret = WriteHwParamsToBuf(writeBuf, hwParams); + if (ret < 0) { + HdfSBufRecycle(writeBuf); + HdfIoServiceRecycle(service); + service = nullptr; + return HDF_FAILURE; + } + ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, writeBuf, writeReply); + if (ret < 0) { + HdfSBufRecycle(writeBuf); + HdfIoServiceRecycle(service); + service = nullptr; + return HDF_FAILURE; + } + HdfSBufRecycle(writeBuf); return HDF_SUCCESS; } } diff --git a/audio/test/systemtest/common/hdi_common/include/audio_hdi_common.h b/audio/test/systemtest/common/hdi_common/include/audio_hdi_common.h index 8ecdd2f35c..14d6960f42 100755 --- a/audio/test/systemtest/common/hdi_common/include/audio_hdi_common.h +++ b/audio/test/systemtest/common/hdi_common/include/audio_hdi_common.h @@ -42,14 +42,57 @@ #include "audio_types.h" #include "hdf_io_service_if.h" #include "hdf_sbuf.h" +#include "audio_proxy_manager.h" namespace HMOS { namespace Audio { +#ifdef AUDIO_ADM_SO + const std::string FUNCTION_NAME = "GetAudioManagerFuncs"; + const std::string RESOLVED_PATH = "//system/lib/libhdi_audio.z.so"; + using TestAudioManager = struct AudioManager; + const int IS_ADM = true; + const std::string AUDIO_FILE = "//bin/audiorendertest.wav"; + const std::string AUDIO_CAPTURE_FILE = "//bin/audiocapture.wav"; +#endif +#ifdef AUDIO_MPI_SO + const std::string FUNCTION_NAME = "GetAudioManagerFuncs"; + const std::string RESOLVED_PATH = "//system/lib/libhdi_audio.z.so"; + using TestAudioManager = struct AudioManager; + const int IS_ADM = false; + const std::string AUDIO_FILE = "//bin/audiorendertest.wav"; + const std::string AUDIO_CAPTURE_FILE = "//bin/audiocapture.wav"; +#endif +#ifdef AUDIO_ADM_SERVICE + const std::string FUNCTION_NAME = "GetAudioProxyManagerFuncs"; + const std::string RESOLVED_PATH = "//system/lib/libaudio_hdi_proxy_server.z.so"; + using TestAudioManager = struct AudioProxyManager; + const int IS_ADM = true; + const std::string AUDIO_FILE = "//bin/audiorendertest.wav"; + const std::string AUDIO_CAPTURE_FILE = "//bin/audiocapture.wav"; +#endif +#ifdef AUDIO_MPI_SERVICE + const std::string FUNCTION_NAME = "GetAudioProxyManagerFuncs"; + const std::string RESOLVED_PATH = "//system/lib/libaudio_hdi_proxy_server.z.so"; + using TestAudioManager = struct AudioProxyManager; + const int IS_ADM = false; + const std::string AUDIO_FILE = "//bin/audiorendertest.wav"; + const std::string AUDIO_CAPTURE_FILE = "//bin/audiocapture.wav"; +#endif +#ifdef __LITEOS__ + const std::string FUNCTION_NAME = "GetAudioManagerFuncs"; + const std::string RESOLVED_PATH = "/usr/lib/libhdi_audio.so"; + using TestAudioManager = struct AudioManager; + const int IS_ADM = true; + const std::string AUDIO_FILE = "/userdata/audiorendertest.wav"; + const std::string AUDIO_CAPTURE_FILE = "/userdata/audiocapture.wav"; +#endif + const std::string AUDIO_RIFF = "RIFF"; const std::string AUDIO_WAVE = "WAVE"; const std::string AUDIO_DATA = "data"; const uint32_t INT_32_MAX = 0x7fffffff; const uint32_t INDEX_END = 555; +const uint32_t MOVE_RIGHT_NUM = 3; const int MOVE_LEFT_NUM = 8; const int CHANNELCOUNT = 2; const int SAMPLERATE = 48000; @@ -60,9 +103,24 @@ const uint64_t INITIAL_VALUE = 0; const int BUFFER_LENTH = 1024 * 16; const uint64_t MEGABYTE = 1024; const int FRAME_SIZE = 1024; +const int FRAME_COUNT = 4; +const int ADAPTER_COUNT = 32; +const int TRY_NUM_FRAME = 20; +const int AUDIO_ADAPTER_MAX_NUM = 3; +const int64_t SECTONSEC = 1000000000; +const int MICROSECOND = 1000000; const std::string HDF_CONTROL_SERVICE = "hdf_audio_control"; +const std::string HDF_RENDER_SERVICE = "hdf_audio_render"; +const std::string HDF_CAPTURE_SERVICE = "hdf_audio_capture"; + const int AUDIODRV_CTL_ELEM_IFACE_DAC = 0; /* virtual dac device */ -const int AUDIODRV_CTL_ELEM_IFACE_PGA = 5; +const int AUDIODRV_CTL_ELEM_IFACE_ADC = 1; /* virtual adc device */ +const int AUDIODRV_CTL_ELEM_IFACE_GAIN = 2; /* virtual adc device */ +const int AUDIODRV_CTL_ELEM_IFACE_MIXER = 3; /* virtual mixer device */ +const int AUDIODRV_CTL_ELEM_IFACE_ACODEC = 4; /* Acodec device */ +const int AUDIODRV_CTL_ELEM_IFACE_PGA = 5; /* PGA device */ +const int AUDIODRV_CTL_ELEM_IFACE_AIAO = 6; /* AIAO device */ + enum ControlDispMethodCmd { AUDIODRV_CTRL_IOCTRL_ELEM_INFO, AUDIODRV_CTRL_IOCTRL_ELEM_READ, @@ -104,11 +162,65 @@ struct AudioHeadInfo { uint32_t dataSize; }; +struct AudioCharacteristic { + bool setmute; + bool getmute; + float setvolume; + float getvolume; + float setgain; + float getgain; + float gainthresholdmin; + float gainthresholdmax; + uint64_t getframes; + uint64_t getframesize; + uint64_t getframecount; + uint32_t getcurrentchannelId; + enum AudioChannelMode setmode; + enum AudioChannelMode getmode; + bool supported; + uint32_t latencyTime; +}; + +struct PrepareAudioPara { + TestAudioManager *manager; + enum AudioPortDirection portType; + const char *adapterName; + struct AudioAdapter *adapter; + struct AudioPort audioPort; + void *self; + void *result; + pthread_t tids; + enum AudioPortPin pins; + const char *path; + struct AudioRender *render; + struct AudioCapture *capture; + struct AudioHeadInfo headInfo; + struct AudioAdapterDescriptor *desc; + struct AudioAdapterDescriptor *descs; + char *frame; + uint64_t requestBytes; + uint64_t replyBytes; + uint64_t fileSize; + struct AudioSampleAttributes attrs; + struct AudioCharacteristic character; + struct AudioSampleAttributes attrsValue; + struct AudioSceneDescriptor scenes; + struct AudioPortCapability capability; + enum AudioPortPassthroughMode mode; + struct AudioTimeStamp time; + struct timeval start; + struct timeval end; + long delayTime; + long totalTime; + float averageDelayTime; + struct AudioDeviceDescriptor devDesc; +}; + int32_t InitAttrs(struct AudioSampleAttributes& attrs); int32_t InitDevDesc(struct AudioDeviceDescriptor& devDesc, const uint32_t portId, enum AudioPortPin pins); -int32_t SwitchAdapter(struct AudioAdapterDescriptor *descs, const std::string adapterNameCase, +int32_t SwitchAdapter(struct AudioAdapterDescriptor *descs, const std::string &adapterNameCase, enum AudioPortDirection portFlag, struct AudioPort& audioPort, int size); uint32_t PcmFormatToBits(enum AudioFormat format); @@ -117,23 +229,61 @@ uint32_t PcmFramesToBytes(const struct AudioSampleAttributes attrs); int32_t WavHeadAnalysis(struct AudioHeadInfo& wavHeadInfo, FILE *file, struct AudioSampleAttributes& attrs); +int32_t GetAdapters(TestAudioManager manager, struct AudioAdapterDescriptor **descs, int &size); + +int32_t GetLoadAdapter(TestAudioManager manager, enum AudioPortDirection portType, + const std::string &adapterName, struct AudioAdapter **adapter, struct AudioPort& audioPort); + +int32_t AudioCreateRender(TestAudioManager manager, enum AudioPortPin pins, const std::string &adapterName, + struct AudioAdapter **adapter, struct AudioRender **render); + +int32_t AudioCreateCapture(TestAudioManager manager, enum AudioPortPin pins, const std::string &adapterName, + struct AudioAdapter **adapter, struct AudioCapture **capture); + int32_t FrameStart(struct AudioHeadInfo wavHeadInfo, struct AudioRender *render, FILE *file, struct AudioSampleAttributes attrs); int32_t FrameStartCapture(struct AudioCapture *capture, FILE *file, const struct AudioSampleAttributes attrs); -uint32_t PcmFormatToBitsCapture(enum AudioFormat format); - -int32_t RenderFramePrepare(const std::string path, char *&frame, uint64_t& numRead); +int32_t RenderFramePrepare(const std::string &path, char *&frame, uint64_t& numRead); void CaptureFrameStatus(int status); int32_t StartRecord(struct AudioCapture *capture, FILE *file, uint64_t filesize); +int32_t WriteIdToBuf(struct HdfSBuf *sBuf, struct AudioCtlElemId id); + +int32_t WriteEleValueToBuf(struct HdfSBuf *sBuf, struct AudioCtlElemValue elemvalue); + int32_t PowerOff(struct AudioCtlElemValue firstElemValue, struct AudioCtlElemValue secondElemValue); int32_t CheckRegisterStatus(const struct AudioCtlElemId firstId, const struct AudioCtlElemId secondId, const int firstStatus, const int secondStatus); + +int32_t AudioCreateStartRender(TestAudioManager manager, struct AudioRender **render, struct AudioAdapter **adapter, + const std::string& adapterName); + +int32_t AudioRenderStartAndOneFrame(struct AudioRender *render); + +int32_t StopAudio(struct PrepareAudioPara& audiopara); + +int32_t ThreadRelease(struct PrepareAudioPara& audiopara); + +int32_t AudioCreateStartCapture(TestAudioManager manager, struct AudioCapture **capture, + struct AudioAdapter **adapter, const std::string& adapterName); + +int32_t AudioCaptureStartAndOneFrame(struct AudioCapture *capture); + +int32_t PlayAudioFile(struct PrepareAudioPara& audiopara); + +int32_t RecordAudio(struct PrepareAudioPara& audiopara); + +int32_t InitAttrsUpdate(struct AudioSampleAttributes& attrs, enum AudioFormat format, uint32_t channelCount, + uint32_t sampleRate); +int32_t AudioRenderSetGetSampleAttributes(struct AudioSampleAttributes attrs, struct AudioSampleAttributes& attrsValue, + struct AudioRender *render); +int32_t AudioCaptureSetGetSampleAttributes(struct AudioSampleAttributes attrs, struct AudioSampleAttributes& attrsValue, + struct AudioCapture *capture); } } #endif // AUDIO_HDI_COMMON_H diff --git a/audio/test/systemtest/common/hdi_common/src/audio_hdi_common.cpp b/audio/test/systemtest/common/hdi_common/src/audio_hdi_common.cpp index 00f2025653..d648e71a9f 100755 --- a/audio/test/systemtest/common/hdi_common/src/audio_hdi_common.cpp +++ b/audio/test/systemtest/common/hdi_common/src/audio_hdi_common.cpp @@ -37,7 +37,6 @@ using namespace std; -static int turnOff = 0; static int g_captureState = 1; namespace HMOS { namespace Audio { @@ -54,7 +53,50 @@ int32_t InitAttrs(struct AudioSampleAttributes& attrs) attrs.isSignedData = true; attrs.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (PCM_16_BIT * attrs.channelCount / MOVE_LEFT_NUM); attrs.stopThreshold = INT_32_MAX; - attrs.silenceThreshold = 0; + attrs.silenceThreshold = BUFFER_LENTH; + return HDF_SUCCESS; +} +int32_t InitAttrsUpdate(struct AudioSampleAttributes& attrs, enum AudioFormat format, uint32_t channelCount, + uint32_t sampleRate) +{ + InitAttrs(attrs); + attrs.format = format; + attrs.sampleRate = sampleRate; + attrs.channelCount = channelCount; + return HDF_SUCCESS; +} +int32_t AudioRenderSetGetSampleAttributes(struct AudioSampleAttributes attrs, struct AudioSampleAttributes& attrsValue, + struct AudioRender *render) +{ + int32_t ret = -1; + if (render == nullptr) { + return HDF_FAILURE; + } + ret = render->attr.SetSampleAttributes(render, &attrs); + if (ret < 0) { + return ret; + } + ret = render->attr.GetSampleAttributes(render, &attrsValue); + if (ret < 0) { + return ret; + } + return HDF_SUCCESS; +} +int32_t AudioCaptureSetGetSampleAttributes(struct AudioSampleAttributes attrs, struct AudioSampleAttributes& attrsValue, + struct AudioCapture *capture) +{ + int32_t ret = -1; + if (capture == nullptr) { + return HDF_FAILURE; + } + ret = capture->attr.SetSampleAttributes(capture, &attrs); + if (ret < 0) { + return ret; + } + ret = capture->attr.GetSampleAttributes(capture, &attrsValue); + if (ret < 0) { + return ret; + } return HDF_SUCCESS; } uint32_t StringToInt(std::string flag) @@ -75,19 +117,22 @@ int32_t InitDevDesc(struct AudioDeviceDescriptor& devDesc, const uint32_t portId return HDF_SUCCESS; } -int32_t SwitchAdapter(struct AudioAdapterDescriptor *descs, const std::string adapterNameCase, +int32_t SwitchAdapter(struct AudioAdapterDescriptor *descs, const std::string& adapterNameCase, enum AudioPortDirection portFlag, struct AudioPort& audioPort, int size) { - if (descs == nullptr) { + if (descs == nullptr || size > ADAPTER_COUNT) { return HDF_FAILURE; } - int count = size; - for (int index = 0; index < count; index++) { + + for (int index = 0; index < size; index++) { struct AudioAdapterDescriptor *desc = &descs[index]; + if (desc == nullptr || desc->adapterName == nullptr) { + continue; + } if (strcmp(desc->adapterName, adapterNameCase.c_str())) { continue; } - for (uint32_t port = 0; ((desc != nullptr) && (port < desc->portNum)); port++) { + for (uint32_t port = 0; port < desc->portNum; port++) { if (desc->ports[port].dir == portFlag) { audioPort = desc->ports[port]; return index; @@ -109,22 +154,18 @@ uint32_t PcmFormatToBits(enum AudioFormat format) }; } -void StreamClose(int sig) -{ - /* allow the stream to be closed gracefully */ - signal(sig, SIG_IGN); - turnOff = 1; -} - uint32_t PcmFramesToBytes(const struct AudioSampleAttributes attrs) { - uint32_t ret = 1024 * 4 * (attrs.channelCount) * (PcmFormatToBits(attrs.format) >> 3); + if (attrs.channelCount < 1 || attrs.channelCount > 2) { + return 0; + } + uint32_t ret = FRAME_SIZE * FRAME_COUNT * (attrs.channelCount) * (PcmFormatToBits(attrs.format) >> MOVE_RIGHT_NUM); return ret; } int32_t WavHeadAnalysis(struct AudioHeadInfo& wavHeadInfo, FILE *file, struct AudioSampleAttributes& attrs) { - int ret = 0; + size_t ret = 0; if (file == nullptr) { return HDF_FAILURE; } @@ -134,9 +175,9 @@ int32_t WavHeadAnalysis(struct AudioHeadInfo& wavHeadInfo, FILE *file, struct Au } uint32_t audioRiffId = StringToInt(AUDIO_RIFF); uint32_t audioFileFmt = StringToInt(AUDIO_WAVE); - uint32_t aduioDataId = StringToInt(AUDIO_DATA); + uint32_t audioDataId = StringToInt(AUDIO_DATA); if (wavHeadInfo.testFileRiffId != audioRiffId || wavHeadInfo.testFileFmt != audioFileFmt || - wavHeadInfo.dataId != aduioDataId) { + wavHeadInfo.dataId != audioDataId) { return HDF_FAILURE; } attrs.channelCount = wavHeadInfo.audioChannelNum; @@ -163,22 +204,214 @@ int32_t WavHeadAnalysis(struct AudioHeadInfo& wavHeadInfo, FILE *file, struct Au } return HDF_SUCCESS; } +int32_t GetAdapters(TestAudioManager manager, struct AudioAdapterDescriptor **descs, int &size) +{ + int32_t ret = -1; + if (descs == nullptr) { + return HDF_FAILURE; + } + ret = manager.GetAllAdapters(&manager, descs, &size); + if (ret < 0 || *descs == nullptr || size != AUDIO_ADAPTER_MAX_NUM) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t GetLoadAdapter(TestAudioManager manager, enum AudioPortDirection portType, + const std::string& adapterName, struct AudioAdapter **adapter, struct AudioPort& audioPort) +{ + int32_t ret = -1; + int size = 0; + struct AudioAdapterDescriptor *desc = nullptr; + struct AudioAdapterDescriptor *descs = nullptr; + if (adapter == nullptr) { + return HDF_FAILURE; + } + ret = GetAdapters(manager, &descs, size); + if (ret < 0 || descs == nullptr) { + return HDF_FAILURE; + } + int index = SwitchAdapter(descs, adapterName, portType, audioPort, size); + if (index < 0) { + return HDF_FAILURE; + } + desc = &descs[index]; + if (desc == nullptr) { + return HDF_FAILURE; + } + ret = manager.LoadAdapter(&manager, desc, adapter); + if (ret < 0 || *adapter == nullptr) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCreateRender(TestAudioManager manager, enum AudioPortPin pins, const std::string& adapterName, + struct AudioAdapter **adapter, struct AudioRender **render) +{ + int32_t ret = -1; + struct AudioSampleAttributes attrs = {}; + struct AudioDeviceDescriptor devDesc = {}; + struct AudioPort renderPort = {}; + if (adapter == nullptr || render == nullptr) { + return HDF_FAILURE; + } + ret = GetLoadAdapter(manager, PORT_OUT, adapterName, adapter, renderPort); + if (ret < 0 || *adapter == nullptr || (*adapter)->CreateRender == nullptr) { + return HDF_FAILURE; + } + InitAttrs(attrs); + InitDevDesc(devDesc, renderPort.portId, pins); + ret = (*adapter)->CreateRender(*adapter, &devDesc, &attrs, render); + if (ret < 0 || *render == nullptr) { + manager.UnloadAdapter(&manager, *adapter); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCreateStartRender(TestAudioManager manager, struct AudioRender **render, struct AudioAdapter **adapter, + const std::string& adapterName) +{ + int32_t ret = -1; + enum AudioPortPin pins = PIN_OUT_SPEAKER; + + if (adapter == nullptr || render == nullptr) { + return HDF_FAILURE; + } + ret = AudioCreateRender(manager, pins, adapterName, adapter, render); + if (ret < 0 || *render == nullptr || *adapter == nullptr) { + return HDF_FAILURE; + } + ret = AudioRenderStartAndOneFrame(*render); + if (ret < 0) { + (*adapter)->DestroyRender(*adapter, *render); + manager.UnloadAdapter(&manager, *adapter); + return ret; + } + return HDF_SUCCESS; +} + +int32_t AudioRenderStartAndOneFrame(struct AudioRender *render) +{ + int32_t ret = -1; + char *frame = nullptr; + uint64_t numRead = 0; + uint64_t replyBytes = 0; + if (render == nullptr || render->control.Start == nullptr || render->RenderFrame == nullptr) { + return HDF_FAILURE; + } + ret = render->control.Start((AudioHandle)render); + if (ret) { + return ret; + } + ret = RenderFramePrepare(AUDIO_FILE, frame, numRead); + if (ret < 0) { + if (frame != nullptr) { + free(frame); + frame = nullptr; + } + return HDF_FAILURE; + } + ret = render->RenderFrame(render, frame, numRead, &replyBytes); + if (ret < 0) { + if (frame != nullptr) { + free(frame); + frame = nullptr; + } + return ret; + } + free(frame); + frame = nullptr; + return HDF_SUCCESS; +} + +int32_t AudioCreateCapture(TestAudioManager manager, enum AudioPortPin pins, const std::string& adapterName, + struct AudioAdapter **adapter, struct AudioCapture **capture) +{ + int32_t ret = -1; + struct AudioSampleAttributes attrs = {}; + struct AudioDeviceDescriptor devDesc = {}; + struct AudioPort capturePort = {}; + if (adapter == nullptr || capture == nullptr) { + return HDF_FAILURE; + } + ret = GetLoadAdapter(manager, PORT_IN, adapterName, adapter, capturePort); + if (ret < 0 || *adapter == nullptr || (*adapter)->CreateCapture == nullptr) { + return HDF_FAILURE; + } + InitAttrs(attrs); + InitDevDesc(devDesc, capturePort.portId, pins); + ret = (*adapter)->CreateCapture(*adapter, &devDesc, &attrs, capture); + if (ret < 0 || *capture == nullptr) { + manager.UnloadAdapter(&manager, *adapter); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCreateStartCapture(TestAudioManager manager, struct AudioCapture **capture, + struct AudioAdapter **adapter, const std::string& adapterName) +{ + int32_t ret = -1; + struct AudioSampleAttributes attrs = {}; + enum AudioPortPin pins = PIN_IN_MIC; + ret = AudioCreateCapture(manager, pins, adapterName, adapter, capture); + if (ret < 0 || *capture == nullptr || *adapter == nullptr) { + return HDF_FAILURE; + } + FILE *file = fopen(AUDIO_CAPTURE_FILE.c_str(), "wb+"); + if (file == nullptr) { + (*adapter)->DestroyCapture(*adapter, *capture); + manager.UnloadAdapter(&manager, *adapter); + return HDF_FAILURE; + } + InitAttrs(attrs); + ret = FrameStartCapture((*capture), file, attrs); + if (ret < 0) { + (*adapter)->DestroyCapture(*adapter, *capture); + manager.UnloadAdapter(&manager, *adapter); + fclose(file); + return ret; + } + fclose(file); + return HDF_SUCCESS; +} + +int32_t AudioCaptureStartAndOneFrame(struct AudioCapture *capture) +{ + int32_t ret = -1; + struct AudioSampleAttributes attrs = {}; + InitAttrs(attrs); + FILE *file = fopen(AUDIO_CAPTURE_FILE.c_str(), "wb+"); + if (file == nullptr) { + return HDF_FAILURE; + } + ret = FrameStartCapture(capture, file, attrs); + if (ret < 0) { + fclose(file); + return ret; + } + fclose(file); + return HDF_SUCCESS; +} int32_t FrameStart(struct AudioHeadInfo wavHeadInfo, struct AudioRender* render, FILE* file, struct AudioSampleAttributes attrs) { - int32_t ret = 0; - int bufferSize = 0; - int readSize = 0; - int remainingDataSize = 0; - int numRead = 0; + int32_t ret = -1; + uint32_t bufferSize = 0; + uint32_t readSize = 0; + uint32_t remainingDataSize = 0; + size_t numRead = 0; uint64_t replyBytes = 0; + int32_t tryNumFrame = 0; if (render == nullptr || render->control.Start == nullptr || render->RenderFrame == nullptr || file == nullptr) { return HDF_FAILURE; } ret = render->control.Start((AudioHandle)render); if (ret) { - return HDF_FAILURE; + return ret; } remainingDataSize = wavHeadInfo.dataSize; bufferSize = PcmFramesToBytes(attrs); @@ -190,7 +423,6 @@ int32_t FrameStart(struct AudioHeadInfo wavHeadInfo, struct AudioRender* render, if (frame == nullptr) { return HDF_FAILURE; } - signal(SIGINT, StreamClose); do { readSize = (remainingDataSize) > (bufferSize) ? (bufferSize) : (remainingDataSize); numRead = fread(frame, 1, readSize, file); @@ -198,14 +430,20 @@ int32_t FrameStart(struct AudioHeadInfo wavHeadInfo, struct AudioRender* render, ret = render->RenderFrame(render, frame, numRead, &replyBytes); if (ret < 0) { if (ret == -1) { + if (tryNumFrame > TRY_NUM_FRAME) { + free(frame); + return ret; + } + tryNumFrame++; continue; } free(frame); - return HDF_FAILURE; + return ret; } + tryNumFrame = 0; remainingDataSize -= numRead; } - } while (!turnOff && numRead > 0 && remainingDataSize > 0); + } while (numRead > 0 && remainingDataSize > 0); free(frame); return HDF_SUCCESS; } @@ -213,7 +451,7 @@ int32_t FrameStart(struct AudioHeadInfo wavHeadInfo, struct AudioRender* render, int32_t FrameStartCapture(struct AudioCapture *capture, FILE *file, const struct AudioSampleAttributes attrs) { int32_t ret = 0; - int bufferSize = 0; + uint32_t bufferSize = 0; uint64_t replyBytes = 0; uint64_t requestBytes = 0; if (capture == nullptr || capture->control.Start == nullptr || capture->CaptureFrame == nullptr) { @@ -221,9 +459,12 @@ int32_t FrameStartCapture(struct AudioCapture *capture, FILE *file, const struct } ret = capture->control.Start((AudioHandle)capture); if (ret < 0) { - return HDF_FAILURE; + return ret; } bufferSize = PcmFramesToBytes(attrs); + if (bufferSize <= 0) { + return HDF_FAILURE; + } char *frame = nullptr; frame = (char *)calloc(1, bufferSize); if (frame == nullptr) { @@ -233,25 +474,23 @@ int32_t FrameStartCapture(struct AudioCapture *capture, FILE *file, const struct ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes); if (ret < 0) { free(frame); - return HDF_FAILURE; + return ret; } - fwrite(frame, requestBytes, 1, file); + uint32_t requestByte = static_cast(replyBytes); + fwrite(frame, requestByte, 1, file); free(frame); return HDF_SUCCESS; } -int32_t RenderFramePrepare(const std::string path, char *&frame, uint64_t& numRead) +int32_t RenderFramePrepare(const std::string& path, char *&frame, uint64_t& numRead) { int32_t ret = -1; - int readSize = 0; - int bufferSize = 0; - int remainingDataSize = 0; + uint32_t readSize = 0; + uint32_t bufferSize = 0; + uint32_t remainingDataSize = 0; struct AudioSampleAttributes attrs = {}; struct AudioHeadInfo headInfo = {}; - ret = InitAttrs(attrs); - if (ret < 0) { - return HDF_FAILURE; - } + InitAttrs(attrs); char absPath[PATH_MAX] = {0}; if (realpath(path.c_str(), absPath) == nullptr) { return HDF_FAILURE; @@ -279,6 +518,8 @@ int32_t RenderFramePrepare(const std::string path, char *&frame, uint64_t& numRe readSize = (remainingDataSize) > (bufferSize) ? (bufferSize) : (remainingDataSize); numRead = fread(frame, 1, readSize, file); if (numRead < 0) { + free(frame); + frame = nullptr; fclose(file); return HDF_FAILURE; } @@ -294,20 +535,19 @@ void CaptureFrameStatus(int status) int32_t StartRecord(struct AudioCapture *capture, FILE *file, uint64_t filesize) { - int32_t ret = 0; - int bufferSize = BUFFER_LENTH; uint64_t replyBytes = 0; uint64_t requestBytes = BUFFER_LENTH; uint64_t totalSize = 0; + int32_t tryNumFrame = 0; if (capture == nullptr || capture->control.Start == nullptr || - capture->CaptureFrame == nullptr ||file == nullptr) { + capture->CaptureFrame == nullptr || file == nullptr) { return HDF_FAILURE; } - ret = capture->control.Start((AudioHandle)capture); + int32_t ret = capture->control.Start((AudioHandle)capture); if (ret < 0) { - return HDF_FAILURE; + return ret; } - char *frame = (char *)calloc(1, bufferSize); + char *frame = (char *)calloc(1, BUFFER_LENTH); if (frame == nullptr) { return HDF_FAILURE; } @@ -316,15 +556,21 @@ int32_t StartRecord(struct AudioCapture *capture, FILE *file, uint64_t filesize) ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes); if (ret < 0) { if (ret == -1) { + if (tryNumFrame++ > TRY_NUM_FRAME) { + free(frame); + frame = nullptr; + return ret; + } continue; } free(frame); frame = nullptr; - return HDF_FAILURE; + return ret; } + tryNumFrame = 0; uint32_t replyByte = static_cast(replyBytes); - ret = fwrite(frame, replyByte, 1, file); - if (ret < 0) { + size_t writeRet = fwrite(frame, replyByte, 1, file); + if (writeRet < 0) { free(frame); frame = nullptr; return HDF_FAILURE; @@ -371,12 +617,12 @@ int32_t WriteEleValueToBuf(struct HdfSBuf *sBuf, struct AudioCtlElemValue elemva int32_t ChangeRegisterStatus(struct AudioCtlElemValue elemValue) { + int32_t ret = -1; struct HdfIoService *service = nullptr; - struct HdfSBuf *sBuf = nullptr; struct HdfSBuf *reply = nullptr; - int32_t ret = -1; + struct HdfSBuf *sBuf = nullptr; service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); - if (service == nullptr) { + if (service == nullptr || service->dispatcher == nullptr) { return HDF_FAILURE; } sBuf = HdfSBufObtainDefaultSize(); @@ -394,7 +640,7 @@ int32_t ChangeRegisterStatus(struct AudioCtlElemValue elemValue) if (ret < 0) { HdfSBufRecycle(sBuf); HdfIoServiceRecycle(service); - return HDF_FAILURE; + return ret; } HdfSBufRecycle(sBuf); HdfIoServiceRecycle(service); @@ -408,7 +654,7 @@ int32_t QueryRegisterStatus(struct AudioCtlElemId id, struct AudioCtlElemValue & struct HdfSBuf *reply = nullptr; int32_t ret = -1; service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); - if (service == nullptr) { + if (service == nullptr || service->dispatcher == nullptr) { return HDF_FAILURE; } sBuf = HdfSBufObtainDefaultSize(); @@ -433,7 +679,7 @@ int32_t QueryRegisterStatus(struct AudioCtlElemId id, struct AudioCtlElemValue & HdfSBufRecycle(sBuf); HdfSBufRecycle(reply); HdfIoServiceRecycle(service); - return HDF_FAILURE; + return ret; } if (!HdfSbufReadInt32(reply, &elemValue.value[0])) { HdfSBufRecycle(sBuf); @@ -452,11 +698,11 @@ int32_t PowerOff(struct AudioCtlElemValue firstElemValue, struct AudioCtlElemVal int32_t ret = -1; ret = ChangeRegisterStatus(firstElemValue); if (ret < 0) { - return HDF_FAILURE; + return ret; } ret = ChangeRegisterStatus(secondElemValue); if (ret < 0) { - return HDF_FAILURE; + return ret; } return HDF_SUCCESS; } @@ -468,20 +714,132 @@ int32_t CheckRegisterStatus(const struct AudioCtlElemId firstId, const struct Au struct AudioCtlElemValue elemValue[2] = {{}, {}}; ret = QueryRegisterStatus(firstId, elemValue[0]); if (ret < 0) { - return HDF_FAILURE; + return ret; } - if (firstStatus != elemValue[0].value[0]) { return HDF_FAILURE; } ret = QueryRegisterStatus(secondId, elemValue[1]); if (ret < 0) { + return ret; + } + if (secondStatus != elemValue[1].value[0]) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t StopAudio(struct PrepareAudioPara& audiopara) +{ + int32_t ret = -1; + if (audiopara.capture != nullptr) { + ret = audiopara.capture->control.Stop((AudioHandle)(audiopara.capture)); + if (ret < 0) { + audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); + return ret; + } + audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); + } + if (audiopara.render != nullptr) { + ret = audiopara.render->control.Stop((AudioHandle)(audiopara.render)); + if (ret < 0) { + audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); + return ret; + } + audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); + } + if (audiopara.manager != nullptr && audiopara.adapter != nullptr) { + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); + } + return HDF_SUCCESS; +} + +int32_t ThreadRelease(struct PrepareAudioPara& audiopara) +{ + int32_t ret = -1; + pthread_join(audiopara.tids, &audiopara.result); + ret = (intptr_t)audiopara.result; + if (ret < 0) { + StopAudio(audiopara); + return ret; + } + ret = StopAudio(audiopara); + if (ret < 0) { + return ret; + } + return HDF_SUCCESS; +} +int32_t PlayAudioFile(struct PrepareAudioPara& audiopara) +{ + int32_t ret = -1; + char absPath[PATH_MAX] = {0}; + if (realpath(audiopara.path, absPath) == nullptr) { + return HDF_FAILURE; + } + if (audiopara.manager == nullptr) { return HDF_FAILURE; } + FILE *file = fopen(absPath, "rb"); + if (file == nullptr) { + return HDF_FAILURE; + } + if (WavHeadAnalysis(audiopara.headInfo, file, audiopara.attrs) < 0) { + fclose(file); + return HDF_FAILURE; + } + ret = AudioCreateRender(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.render); + if (ret < 0 || audiopara.render == nullptr) { + fclose(file); + return ret; + } + ret = FrameStart(audiopara.headInfo, audiopara.render, file, audiopara.attrs); + if (ret == HDF_SUCCESS) { + fclose(file); + } else { + audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); + fclose(file); + return ret; + } + return HDF_SUCCESS; +} - if (secondStatus != elemValue[1].value[0]) { +int32_t RecordAudio(struct PrepareAudioPara& audiopara) +{ + int32_t ret = -1; + if (audiopara.manager == nullptr) { + return HDF_FAILURE; + } + ret = AudioCreateCapture(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.capture); + if (ret < 0 || audiopara.capture == nullptr) { + return ret; + } + bool isMute = false; + ret = audiopara.capture->volume.SetMute(audiopara.capture, isMute); + if (ret < 0) { + audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); + return ret; + } + + FILE *file = fopen(audiopara.path, "wb+"); + if (file == nullptr) { + audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); return HDF_FAILURE; } + ret = StartRecord(audiopara.capture, file, audiopara.fileSize); + if (ret < 0) { + audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); + fclose(file); + return ret; + } + fclose(file); return HDF_SUCCESS; } } diff --git a/audio/test/systemtest/common/lib_common/include/audio_lib_common.h b/audio/test/systemtest/common/lib_common/include/audio_lib_common.h index 7753b51790..f454a2d0ab 100755 --- a/audio/test/systemtest/common/lib_common/include/audio_lib_common.h +++ b/audio/test/systemtest/common/lib_common/include/audio_lib_common.h @@ -36,21 +36,10 @@ #ifndef AUDIO_LIB_COMMON_H #define AUDIO_LIB_COMMON_H -#include -#include "audio_internal.h" +#include "audio_hdi_common.h" namespace HMOS { namespace Audio { -const std::string AUDIO_RIFF = "RIFF"; -const std::string AUDIO_WAVE = "WAVE"; -const std::string AUDIO_DATA = "data"; -const uint32_t INDEX_END = 555; -const int G_CHANNELCOUNT = 2; -const int G_SAMPLERATE = 48000; -const int G_PCM16BIT = 16; -const int G_PCM8BIT = 8; -const int G_PCM24BIT = 24; -const int G_PCM32BIT = 32; const int G_PERIODSIZE = 4096; const int G_PERIODCOUNT = 8; const int G_BYTERATE = 48000; @@ -58,36 +47,9 @@ const int G_BUFFERFRAMESIZE = 0; const int G_BUFFERSIZE1 = 128; const int G_SILENCETHRESHOLE = 0; const int G_PORTID = 0; -const int MOVE_LEFT_NUM = 8; -const int DEEP_BUFFER_RENDER_PERIOD_SIZE = 4096; const int STOP_THRESHOLD = 32; const int START_THRESHOLD = 8; -enum AudioPCMBit { - PCM_8_BIT = 8, - PCM_16_BIT = 16, - PCM_24_BIT = 24, - PCM_32_BIT = 32, -}; - -struct AudioHeadInfo { - uint32_t testFileRiffId; - uint32_t testFileRiffSize; - uint32_t testFileFmt; - uint32_t audioFileFmtId; - uint32_t audioFileFmtSize; - uint16_t audioFileFormat; - uint16_t audioChannelNum; - uint32_t audioSampleRate; - uint32_t audioByteRate; - uint16_t audioBlockAlign; - uint16_t audioBitsPerSample; - uint32_t dataId; - uint32_t dataSize; -}; - -int32_t InitAttrs(struct AudioSampleAttributes& attrs); - int32_t InitRenderFramepara(struct AudioFrameRenderMode& frameRenderMode); int32_t InitHwCaptureFramepara(struct AudioFrameCaptureMode& frameCaptureMode); @@ -96,7 +58,9 @@ int32_t InitHwRenderMode(struct AudioHwRenderMode& renderMode); int32_t InitHwCaptureMode(struct AudioHwCaptureMode& captureMode); -int32_t WavHeadAnalysis(struct AudioHeadInfo& wavHeadInfo, FILE *file, struct AudioSampleAttributes& attrs); +uint32_t InitHwRender(struct AudioHwRender *&hwRender, const std::string adapterNameCase); + +uint32_t InitHwCapture(struct AudioHwCapture *&hwCapture, const std::string adapterNameCase); } } #endif // AUDIO_LIB_COMMON_H diff --git a/audio/test/systemtest/common/lib_common/src/audio_lib_common.cpp b/audio/test/systemtest/common/lib_common/src/audio_lib_common.cpp index 984afe58dd..ff935e04d9 100755 --- a/audio/test/systemtest/common/lib_common/src/audio_lib_common.cpp +++ b/audio/test/systemtest/common/lib_common/src/audio_lib_common.cpp @@ -39,23 +39,6 @@ using namespace std; namespace HMOS { namespace Audio { -int32_t InitAttrs(struct AudioSampleAttributes& attrs) -{ - attrs.format = AUDIO_FORMAT_PCM_16_BIT; - attrs.channelCount = G_CHANNELCOUNT; - attrs.sampleRate = G_SAMPLERATE; - attrs.interleaved = 0; - attrs.type = AUDIO_IN_MEDIA; - attrs.period = DEEP_BUFFER_RENDER_PERIOD_SIZE; - attrs.frameSize = G_PCM16BIT * G_CHANNELCOUNT / MOVE_LEFT_NUM; - attrs.isBigEndian = true; - attrs.isSignedData = true; - attrs.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (G_PCM16BIT * attrs.channelCount / MOVE_LEFT_NUM); - attrs.stopThreshold = STOP_THRESHOLD; - attrs.silenceThreshold = 0; - return HDF_SUCCESS; -} - int32_t InitRenderFramepara(struct AudioFrameRenderMode& frameRenderMode) { InitAttrs(frameRenderMode.attrs); @@ -115,55 +98,40 @@ int32_t InitHwCaptureMode(struct AudioHwCaptureMode& captureMode) return HDF_SUCCESS; } -uint32_t StringToInt(std::string flag) +uint32_t InitHwRender(struct AudioHwRender *&hwRender, const std::string adapterNameCase) { - uint32_t temp = flag[0]; - for (int i = flag.size() - 1; i >= 0; i--) { - temp <<= MOVE_LEFT_NUM; - temp += flag[i]; + int ret = -1; + if (hwRender == nullptr) { + return HDF_FAILURE; } - return temp; + if (InitHwRenderMode(hwRender->renderParam.renderMode) || + InitRenderFramepara(hwRender->renderParam.frameRenderMode)) { + return HDF_FAILURE; + } + hwRender->renderParam.renderMode.hwInfo.card = AUDIO_SERVICE_IN; + ret = strcpy_s(hwRender->renderParam.renderMode.hwInfo.adapterName, + NAME_LEN, adapterNameCase.c_str()); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; } -int32_t WavHeadAnalysis(struct AudioHeadInfo& wavHeadInfo, FILE *file, struct AudioSampleAttributes& attrs) +uint32_t InitHwCapture(struct AudioHwCapture *&hwCapture, const std::string adapterNameCase) { - int32_t ret = 0; - if (file == nullptr) { + int ret = -1; + if (hwCapture == nullptr) { return HDF_FAILURE; } - ret = fread(&wavHeadInfo, sizeof(wavHeadInfo), 1, file); - if (ret != 1) { + if (InitHwCaptureMode(hwCapture->captureParam.captureMode) || + InitHwCaptureFramepara(hwCapture->captureParam.frameCaptureMode)) { return HDF_FAILURE; } - uint32_t audioRiffId = StringToInt(AUDIO_RIFF); - uint32_t audioFileFmt = StringToInt(AUDIO_WAVE); - uint32_t aduioDataId = StringToInt(AUDIO_DATA); - if (wavHeadInfo.testFileRiffId != audioRiffId || wavHeadInfo.testFileFmt != audioFileFmt || - wavHeadInfo.dataId != aduioDataId) { + ret = strcpy_s(hwCapture->captureParam.captureMode.hwInfo.adapterName, + NAME_LEN, adapterNameCase.c_str()); + if (ret < 0) { return HDF_FAILURE; } - attrs.channelCount = wavHeadInfo.audioChannelNum; - attrs.sampleRate = wavHeadInfo.audioSampleRate; - switch (wavHeadInfo.audioBitsPerSample) { - case PCM_8_BIT: { - attrs.format = AUDIO_FORMAT_PCM_8_BIT; - break; - } - case PCM_16_BIT: { - attrs.format = AUDIO_FORMAT_PCM_16_BIT; - break; - } - case PCM_24_BIT: { - attrs.format = AUDIO_FORMAT_PCM_24_BIT; - break; - } - case PCM_32_BIT: { - attrs.format = AUDIO_FORMAT_PCM_32_BIT; - break; - } - default: - return HDF_FAILURE; - } return HDF_SUCCESS; } } diff --git a/audio/test/systemtest/hdi/BUILD.gn b/audio/test/systemtest/hdi/BUILD.gn index 5c0246eb56..a78e6ff03e 100755 --- a/audio/test/systemtest/hdi/BUILD.gn +++ b/audio/test/systemtest/hdi/BUILD.gn @@ -11,26 +11,41 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build/test.gni") -import("//drivers/adapter/uhdf2/uhdf.gni") +if (defined(ohos_lite)) { + import("//build/lite/config/test.gni") + import("//drivers/peripheral/audio/audio.gni") +} else { + import("//build/test.gni") + import("//drivers/adapter/uhdf2/uhdf.gni") + import("//drivers/peripheral/audio/audio.gni") +} ###########################end########################### group("hdi") { - testonly = true - deps = [] - deps += [ - "adapter:AudioHdiAdapterTest", - "hdireliability:AudioHdiCaptureReliabilityTest", - "hdireliability:AudioHdiRenderReliabilityTest", - "render:AudioHdiRenderAttrTest", - "render:AudioHdiRenderControlTest", - "render:AudioHdiRenderVolumeTest", - "render:AudioHdiRenderSceneTest", - "render:AudioHdiRenderTest", - "capture:AudioHdiCaptureAttrTest", - "capture:AudioHdiCaptureControlTest", - "capture:AudioHdiCaptureVolumeTest", - "capture:AudioHdiCaptureSceneTest", - "capture:AudioHdiCaptureTest", + if (!defined(ohos_lite)) { + testonly = true + } + deps = [ + "adapter:hdf_audio_hdi_adapter_test", + "hdireliability:hdf_audio_hdi_capture_reliability_test", + "hdireliability:hdf_audio_hdi_render_reliability_test", + "hdireliability:hdf_audio_hdi_capture_control_reliability_test", + "hdireliability:hdf_audio_hdi_render_control_reliability_test", + "render:hdf_audio_hdi_render_attr_test", + "render:hdf_audio_hdi_render_control_test", + "render:hdf_audio_hdi_render_volume_test", + "render:hdf_audio_hdi_render_scene_test", + "render:hdf_audio_hdi_render_test", + "capture:hdf_audio_hdi_capture_attr_test", + "capture:hdf_audio_hdi_capture_control_test", + "capture:hdf_audio_hdi_capture_volume_test", + "capture:hdf_audio_hdi_capture_scene_test", + "capture:hdf_audio_hdi_capture_test", + ] + if (!enable_audio_mpi_so && !enable_audio_mpi_service) { + deps += [ + "hdiperformace:hdf_audio_hdi_render_performace_test", + "hdiperformace:hdf_audio_hdi_capture_performace_test" ] + } } diff --git a/audio/test/systemtest/hdi/adapter/BUILD.gn b/audio/test/systemtest/hdi/adapter/BUILD.gn index f769f8416a..8f9840b677 100755 --- a/audio/test/systemtest/hdi/adapter/BUILD.gn +++ b/audio/test/systemtest/hdi/adapter/BUILD.gn @@ -11,46 +11,110 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build/test.gni") -import("//drivers/adapter/uhdf2/uhdf.gni") +if (defined(ohos_lite)) { + import("//build/lite/config/test.gni") +} else { + import("//build/test.gni") + import("//drivers/adapter/uhdf2/uhdf.gni") + import("//drivers/peripheral/audio/audio.gni") +} + +if (defined(ohos_lite)) { + ###########################LITEOS############################## + ###########################hdf_audio_hdi_adapter_test##################### + unittest("hdf_audio_hdi_adapter_test") { + sources = [ + "src/audio_hdiadapter_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] -module_output_path = "hdf/audio/systemtest/hdi" -###########################systemtest############################## -###########################AudioHdiAdapterTest##################### -ohos_systemtest("AudioHdiAdapterTest") { - module_out_path = module_output_path - sources = [ - "src/audio_hdiadapter_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + include_dirs = [ + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/include", + "//drivers/framework/core/sec/include", + "//drivers/framework/core/shared/include", + "//drivers/framework/core/host/include", + "//drivers/framework/core/manager/include", + "//drivers/framework/core/common/include/host/", + "//third_party/bounds_checking_function/include", + "//drivers/adapter/khdf/liteos/osal/include", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/adapter/uhdf2/include/hdi/", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/adapter/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + } +} else { + ###########################NOT LITEOS############################## + module_output_path = "hdf/audio" + ###########################hdf_audio_hdi_adapter_test##################### + ohos_systemtest("hdf_audio_hdi_adapter_test") { + module_out_path = module_output_path + sources = [ + "src/audio_hdiadapter_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] - include_dirs = [ - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/interfaces/include", - "//drivers/framework/include/core", - "//drivers/framework/include/utils", - "//drivers/framework/include/osal", - "//drivers/framework/include", - "//third_party/bounds_checking_function/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/framework/utils/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/adapter/uhdf2/osal/include", - "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", - "//third_party/googletest/googletest/include/gtest", - "//drivers/peripheral/audio/test/systemtest/hdi/adapter/include", - ] - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - ] - deps = [ - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - ] + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/adapter/uhdf2/osal/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/ability/sbuf/include", + "//third_party/bounds_checking_function/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/adapter/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + deps = [ + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + defines = [] + if (enable_audio_adm_so) { + defines += [ "AUDIO_ADM_SO" ] + } + if (enable_audio_mpi_so) { + defines += [ "AUDIO_MPI_SO" ] + } + if (enable_audio_adm_service) { + defines += [ "AUDIO_ADM_SERVICE" ] + } + if (enable_audio_mpi_service) { + defines += [ "AUDIO_MPI_SERVICE" ] + } + } } ###########################end########################### \ No newline at end of file diff --git a/audio/test/systemtest/hdi/adapter/src/audio_hdiadapter_test.cpp b/audio/test/systemtest/hdi/adapter/src/audio_hdiadapter_test.cpp index e7663fff67..1c33613124 100755 --- a/audio/test/systemtest/hdi/adapter/src/audio_hdiadapter_test.cpp +++ b/audio/test/systemtest/hdi/adapter/src/audio_hdiadapter_test.cpp @@ -41,10 +41,9 @@ using namespace testing::ext; using namespace HMOS::Audio; namespace { -const string ADAPTER_NAME = "hdmi"; -const string ADAPTER_NAME2 = "usb"; -const string ADAPTER_NAME3 = "internal"; -const int AUDIO_ADAPTER_MAX_NUM = 3; +const string ADAPTER_NAME_USB = "usb"; +const string ADAPTER_NAME_INTERNAL = "internal"; + class AudioHdiAdapterTest : public testing::Test { public: @@ -52,69 +51,75 @@ public: static void TearDownTestCase(void); void SetUp(); void TearDown(); - struct AudioManager *(*GetAudioManager)() = nullptr; - void *handleSo = nullptr; - int32_t GetLoadAdapter(struct AudioManager manager, enum AudioPortDirection portType, - const string adapterName, struct AudioAdapter **adapter, struct AudioPort& renderPort) const; + static TestAudioManager *(*GetAudioManager)(); + static void *handleSo; +#ifdef AUDIO_MPI_SO + static int32_t (*SdkInit)(); + static void (*SdkExit)(); + static void *sdkSo; +#endif }; -void AudioHdiAdapterTest::SetUpTestCase(void) {} - -void AudioHdiAdapterTest::TearDownTestCase(void) {} +TestAudioManager *(*AudioHdiAdapterTest::GetAudioManager)() = nullptr; +void *AudioHdiAdapterTest::handleSo = nullptr; +#ifdef AUDIO_MPI_SO + int32_t (*AudioHdiAdapterTest::SdkInit)() = nullptr; + void (*AudioHdiAdapterTest::SdkExit)() = nullptr; + void *AudioHdiAdapterTest::sdkSo = nullptr; +#endif -void AudioHdiAdapterTest::SetUp(void) +void AudioHdiAdapterTest::SetUpTestCase(void) { - char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; - handleSo = dlopen(resolvedPath, RTLD_LAZY); +#ifdef AUDIO_MPI_SO + char sdkResolvedPath[] = "//system/lib/libhdi_audio_interface_lib_render.z.so"; + sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY); + if (sdkSo == nullptr) { + return; + } + SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit")); + if (SdkInit == nullptr) { + return; + } + SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit")); + if (SdkExit == nullptr) { + return; + } + SdkInit(); +#endif + handleSo = dlopen(RESOLVED_PATH.c_str(), RTLD_LAZY); if (handleSo == nullptr) { return; } - GetAudioManager = (struct AudioManager *(*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); + GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str())); if (GetAudioManager == nullptr) { return; } } -void AudioHdiAdapterTest::TearDown(void) +void AudioHdiAdapterTest::TearDownTestCase(void) { - // step 2: input testsuit teardown step - if (GetAudioManager != nullptr) { - GetAudioManager = nullptr; - } -} - -int32_t AudioHdiAdapterTest::GetLoadAdapter(struct AudioManager manager, enum AudioPortDirection portType, - const string adapterName, struct AudioAdapter **adapter, struct AudioPort& audioPort) const -{ - int32_t ret = -1; - int size = 0; - struct AudioAdapterDescriptor *desc = nullptr; - struct AudioAdapterDescriptor *descs = nullptr; - if (adapter == nullptr) { - return HDF_FAILURE; +#ifdef AUDIO_MPI_SO + SdkExit(); + if (sdkSo != nullptr) { + dlclose(sdkSo); + sdkSo = nullptr; } - ret = manager.GetAllAdapters(&manager, &descs, &size); - if (ret < 0 || descs == nullptr || size == 0) { - return HDF_FAILURE; - } else { - int index = SwitchAdapter(descs, adapterName, portType, audioPort, size); - if (index < 0) { - return HDF_FAILURE; - } else { - desc = &descs[index]; - } + if (SdkInit != nullptr) { + SdkInit = nullptr; } - if (desc == nullptr) { - return HDF_FAILURE; - } else { - ret = manager.LoadAdapter(&manager, desc, adapter); + if (SdkExit != nullptr) { + SdkExit = nullptr; } - if (ret < 0 || adapter == nullptr) { - return HDF_FAILURE; +#endif + if (GetAudioManager != nullptr) { + GetAudioManager = nullptr; } - return HDF_SUCCESS; } +void AudioHdiAdapterTest::SetUp(void) {} + +void AudioHdiAdapterTest::TearDown(void) {} + /** * @tc.name Test GetAllAdapters API via legal input * @tc.number SUB_Audio_HDI_GetAllAdapters_0001 @@ -128,7 +133,7 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_GetAllAdapters_0001, TestSize.Level1 struct AudioAdapterDescriptor *descs = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager *manager = GetAudioManager(); + TestAudioManager *manager = GetAudioManager(); ASSERT_NE(nullptr, manager); ret = manager->GetAllAdapters(manager, &descs, &size); EXPECT_EQ(HDF_SUCCESS, ret); @@ -146,10 +151,10 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_GetAllAdapters_0002, TestSize.Level1 int32_t ret = -1; int size = 0; struct AudioAdapterDescriptor *descs = nullptr; - struct AudioManager *manager1 = nullptr; + TestAudioManager *manager1 = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager *manager = GetAudioManager(); + TestAudioManager *manager = GetAudioManager(); ASSERT_NE(nullptr, manager); ret = manager->GetAllAdapters(manager1, &descs, &size); EXPECT_EQ(HDF_FAILURE, ret); @@ -168,7 +173,7 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_GetAllAdapters_0003, TestSize.Level1 struct AudioAdapterDescriptor **descs = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager *manager = GetAudioManager(); + TestAudioManager *manager = GetAudioManager(); ASSERT_NE(nullptr, manager); ret = manager->GetAllAdapters(manager, descs, &size); EXPECT_EQ(HDF_FAILURE, ret); @@ -187,7 +192,7 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_GetAllAdapters_0004, TestSize.Level1 struct AudioAdapterDescriptor *descs = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager *manager = GetAudioManager(); + TestAudioManager *manager = GetAudioManager(); ASSERT_NE(nullptr, manager); ret = manager->GetAllAdapters(manager, &descs, size); EXPECT_EQ(HDF_FAILURE, ret); @@ -206,16 +211,13 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_LoadAdapter_0001, TestSize.Level1) struct AudioAdapterDescriptor *descs = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager *manager = GetAudioManager(); - ASSERT_NE(nullptr, manager); - ret = manager->GetAllAdapters(manager, &descs, &size); + TestAudioManager manager = *GetAudioManager(); + ret = GetAdapters(manager, &descs, size); ASSERT_EQ(HDF_SUCCESS, ret); - ASSERT_NE(nullptr, descs); - ASSERT_EQ(AUDIO_ADAPTER_MAX_NUM, size); struct AudioAdapterDescriptor *desc = &descs[0]; - struct AudioAdapter *adapter = nullptr; ASSERT_TRUE(desc != nullptr); - ret = manager->LoadAdapter(manager, desc, &adapter); + struct AudioAdapter *adapter = nullptr; + ret = manager.LoadAdapter(&manager, desc, &adapter); ASSERT_EQ(HDF_SUCCESS, ret); ret = -1; if (adapter != nullptr) { @@ -227,7 +229,7 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_LoadAdapter_0001, TestSize.Level1) } } EXPECT_EQ(HDF_SUCCESS, ret); - manager->UnloadAdapter(manager, adapter); + manager.UnloadAdapter(&manager, adapter); } /** @@ -243,21 +245,19 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_LoadAdapter_0002, TestSize.Level1) struct AudioAdapterDescriptor *descs = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager *manager = GetAudioManager(); - ASSERT_NE(nullptr, manager); - ret = manager->GetAllAdapters(manager, &descs, &size); + TestAudioManager manager = *GetAudioManager(); + ret = GetAdapters(manager, &descs, size); ASSERT_EQ(HDF_SUCCESS, ret); - ASSERT_NE(nullptr, descs); - ASSERT_EQ(AUDIO_ADAPTER_MAX_NUM, size); struct AudioAdapterDescriptor *desc = &descs[0]; desc->adapterName = "illegal"; - struct AudioAdapter *adapter = nullptr; ASSERT_TRUE(desc != nullptr); - ret = manager->LoadAdapter(manager, desc, &adapter); + struct AudioAdapter *adapter = nullptr; + + ret = manager.LoadAdapter(&manager, desc, &adapter); EXPECT_EQ(HDF_FAILURE, ret); desc->adapterName = "internal"; - ret = manager->LoadAdapter(manager, desc, &adapter); - manager->UnloadAdapter(manager, adapter); + ret = manager.LoadAdapter(&manager, desc, &adapter); + manager.UnloadAdapter(&manager, adapter); } /** @@ -277,7 +277,7 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_LoadAdapter_0003, TestSize.Level1) }; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager *manager = GetAudioManager(); + TestAudioManager *manager = GetAudioManager(); ASSERT_NE(nullptr, manager); ret = manager->LoadAdapter(manager, &desc, &adapter); EXPECT_EQ(HDF_FAILURE, ret); @@ -295,21 +295,19 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_LoadAdapter_0004, TestSize.Level1) int32_t ret = -1; int size = 0; struct AudioAdapterDescriptor *descs = nullptr; - struct AudioManager *manager1 = nullptr; + TestAudioManager *managerNull = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager *manager = GetAudioManager(); - ASSERT_NE(nullptr, manager); - ret = manager->GetAllAdapters(manager, &descs, &size); + TestAudioManager manager = *GetAudioManager(); + ret = GetAdapters(manager, &descs, size); ASSERT_EQ(HDF_SUCCESS, ret); - ASSERT_NE(nullptr, descs); - ASSERT_EQ(AUDIO_ADAPTER_MAX_NUM, size); struct AudioAdapterDescriptor *desc = &descs[0]; - struct AudioAdapter *adapter = nullptr; ASSERT_TRUE(desc != nullptr); - ret = manager->LoadAdapter(manager1, desc, &adapter); + struct AudioAdapter *adapter = nullptr; + + ret = manager.LoadAdapter(managerNull, desc, &adapter); ASSERT_EQ(HDF_FAILURE, ret); - manager->UnloadAdapter(manager, adapter); + manager.UnloadAdapter(&manager, adapter); } /** @@ -325,7 +323,7 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_LoadAdapter_0005, TestSize.Level1) struct AudioAdapter *adapter = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager *manager = GetAudioManager(); + TestAudioManager *manager = GetAudioManager(); ASSERT_NE(nullptr, manager); ret = manager->LoadAdapter(manager, desc, &adapter); ASSERT_EQ(HDF_FAILURE, ret); @@ -343,18 +341,16 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_LoadAdapter_0006, TestSize.Level1) int32_t ret = -1; int size = 0; struct AudioAdapterDescriptor *descs = nullptr; + struct AudioAdapter **adapter = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager *manager = GetAudioManager(); - ASSERT_NE(nullptr, manager); - ret = manager->GetAllAdapters(manager, &descs, &size); + TestAudioManager manager = *GetAudioManager(); + ret = GetAdapters(manager, &descs, size); ASSERT_EQ(HDF_SUCCESS, ret); - ASSERT_NE(nullptr, descs); - ASSERT_EQ(AUDIO_ADAPTER_MAX_NUM, size); struct AudioAdapterDescriptor *desc = &descs[0]; - struct AudioAdapter **adapter = nullptr; ASSERT_TRUE(desc != nullptr); - ret = manager->LoadAdapter(manager, desc, adapter); + + ret = manager.LoadAdapter(&manager, desc, adapter); EXPECT_EQ(HDF_FAILURE, ret); } @@ -370,9 +366,9 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterInitAllPorts_0001, TestSize.L struct AudioAdapter *adapter = nullptr; struct AudioPort renderPort = {}; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); + TestAudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, renderPort); ASSERT_EQ(HDF_SUCCESS, ret); ASSERT_NE(nullptr, adapter); ret = adapter->InitAllPorts(adapter); @@ -395,12 +391,12 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterInitAllPorts_0002, TestSize.L struct AudioAdapter *adapter = nullptr; struct AudioAdapter *adapter1 = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); + TestAudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME3, &adapter, renderPort); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_INTERNAL, &adapter, renderPort); ASSERT_EQ(HDF_SUCCESS, ret); ASSERT_NE(nullptr, adapter); - ret2 = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter1, renderPortUsb); + ret2 = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter1, renderPortUsb); if (ret2 < 0 || adapter1 == nullptr) { manager.UnloadAdapter(&manager, adapter); ASSERT_EQ(HDF_SUCCESS, ret2); @@ -428,9 +424,9 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterInitAllPorts_0003, TestSize.L struct AudioAdapter *adapter = nullptr; struct AudioAdapter *adapterNull = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); + TestAudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, audioPort); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, audioPort); ASSERT_EQ(HDF_SUCCESS, ret); ASSERT_NE(nullptr, adapter); ret = adapter->InitAllPorts(adapterNull); @@ -438,28 +434,6 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterInitAllPorts_0003, TestSize.L manager.UnloadAdapter(&manager, adapter); } -/** -* @tc.name Test AudioAdapterInitAllPorts API when the adapter is smartpa. -* @tc.number SUB_Audio_HDI_AdapterInitAllPorts_0004 -* @tc.desc Test AudioAdapterInitAllPorts interface, return 0 if the ports are initialized successfully. -* @tc.author: liutian -*/ -HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterInitAllPorts_0004, TestSize.Level1) -{ - int32_t ret = -1; - struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; - ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); - ASSERT_EQ(HDF_SUCCESS, ret); - ASSERT_NE(nullptr, adapter); - ret = adapter->InitAllPorts(adapter); - EXPECT_EQ(HDF_SUCCESS, ret); - manager.UnloadAdapter(&manager, adapter); -} - /** * @tc.name Test AudioAdapterGetPortCapability API when the PortType is PORT_OUT. * @tc.number SUB_Audio_HDI_AdapterGetPortCapability_0001 @@ -472,10 +446,10 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPortCapability_0001, TestS struct AudioPort audioPort = {}; struct AudioAdapter *adapter = {}; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); + TestAudioManager manager = *GetAudioManager(); struct AudioPortCapability capability = {}; - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, audioPort); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, audioPort); ASSERT_EQ(HDF_SUCCESS, ret); ASSERT_NE(nullptr, adapter); ret = adapter->InitAllPorts(adapter); @@ -507,10 +481,10 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPortCapability_0002, TestS struct AudioPort audioPort = {}; struct AudioAdapter *adapter = {}; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); + TestAudioManager manager = *GetAudioManager(); struct AudioPortCapability capability = {}; - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME2, &adapter, audioPort); + ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME_USB, &adapter, audioPort); ASSERT_EQ(HDF_SUCCESS, ret); ASSERT_NE(nullptr, adapter); ret = adapter->InitAllPorts(adapter); @@ -533,10 +507,10 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPortCapability_0003, TestS struct AudioPort audioPort = {}; struct AudioAdapter *adapter = {}; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); + TestAudioManager manager = *GetAudioManager(); struct AudioPortCapability capability = {}; - ret = GetLoadAdapter(manager, PORT_OUT_IN, ADAPTER_NAME2, &adapter, audioPort); + ret = GetLoadAdapter(manager, PORT_OUT_IN, ADAPTER_NAME_USB, &adapter, audioPort); ASSERT_EQ(HDF_SUCCESS, ret); ASSERT_NE(nullptr, adapter); ret = adapter->InitAllPorts(adapter); @@ -560,9 +534,9 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPortCapability_0004, TestS struct AudioAdapter *adapterNull = nullptr; struct AudioPortCapability capability = {}; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); + TestAudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME3, &adapter, audioPort); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_INTERNAL, &adapter, audioPort); ASSERT_EQ(HDF_SUCCESS, ret); ASSERT_NE(nullptr, adapter); ret = adapter->InitAllPorts(adapter); @@ -585,11 +559,11 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPortCapability_0005, TestS struct AudioAdapter *adapter = nullptr; struct AudioPortCapability capability = {}; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); + TestAudioManager manager = *GetAudioManager(); struct AudioPort audioPort = {}; struct AudioPort audioPortError = { .dir = PORT_OUT, .portId = 9, .portName = "AIP" }; - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME3, &adapter, audioPort); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_INTERNAL, &adapter, audioPort); ASSERT_EQ(HDF_SUCCESS, ret); ASSERT_NE(nullptr, adapter); ret = adapter->InitAllPorts(adapter); @@ -615,9 +589,9 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPortCapability_0006, TestS struct AudioAdapter *adapter = nullptr; struct AudioPortCapability *capabilityNull = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); + TestAudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME3, &adapter, audioPort); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_INTERNAL, &adapter, audioPort); ASSERT_EQ(HDF_SUCCESS, ret); ASSERT_NE(nullptr, adapter); ret = adapter->InitAllPorts(adapter); @@ -640,10 +614,10 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterSetPassthroughMode_0001, Test struct AudioPort audioPort = {}; struct AudioAdapter *adapter = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); + TestAudioManager manager = *GetAudioManager(); enum AudioPortPassthroughMode modeLpcm = PORT_PASSTHROUGH_AUTO; - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, audioPort); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, audioPort); ASSERT_EQ(HDF_SUCCESS, ret); ASSERT_NE(nullptr, adapter); ret = adapter->InitAllPorts(adapter); @@ -669,9 +643,9 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterSetPassthroughMode_0002, Test struct AudioAdapter *adapter = nullptr; struct AudioPort audioPort = {}; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); + TestAudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME2, &adapter, audioPort); + ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME_USB, &adapter, audioPort); ASSERT_EQ(HDF_SUCCESS, ret); ASSERT_NE(nullptr, adapter); ret = adapter->InitAllPorts(adapter); @@ -695,9 +669,9 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterSetPassthroughMode_0003, Test struct AudioAdapter *adapter = nullptr; struct AudioAdapter *adapterNull = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); + TestAudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME3, &adapter, audioPort); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_INTERNAL, &adapter, audioPort); ASSERT_EQ(HDF_SUCCESS, ret); ASSERT_NE(nullptr, adapter); ret = adapter->SetPassthroughMode(adapterNull, &audioPort, PORT_PASSTHROUGH_LPCM); @@ -719,9 +693,9 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterSetPassthroughMode_0004, Test enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; struct AudioAdapter *adapter = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); + TestAudioManager manager = *GetAudioManager(); struct AudioPort audioPortError = { .dir = PORT_OUT, .portId = 8, .portName = "AIP1" }; - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, audioPort); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, audioPort); ASSERT_EQ(HDF_SUCCESS, ret); ASSERT_NE(nullptr, adapter); ret = adapter->InitAllPorts(adapter); @@ -746,9 +720,9 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterSetPassthroughMode_0005, Test struct AudioPort audioPort = {}; struct AudioAdapter *adapter = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); + TestAudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, audioPort); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, audioPort); ASSERT_EQ(HDF_SUCCESS, ret); ASSERT_NE(nullptr, adapter); ret = adapter->InitAllPorts(adapter); @@ -772,9 +746,9 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPassthroughMode_0001, Test enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_AUTO; struct AudioAdapter *adapter = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); + TestAudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, audioPort); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, audioPort); ASSERT_EQ(HDF_SUCCESS, ret); ASSERT_NE(nullptr, adapter); ret = adapter->InitAllPorts(adapter); @@ -804,9 +778,9 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPassthroughMode_0002, Test struct AudioAdapter *adapter = nullptr; struct AudioAdapter *adapterNull = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); + TestAudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, audioPort); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, audioPort); ASSERT_EQ(HDF_SUCCESS, ret); ASSERT_NE(nullptr, adapter); ret = adapter->InitAllPorts(adapter); @@ -831,9 +805,9 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPassthroughMode_0003, Test enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; struct AudioAdapter *adapter = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); + TestAudioManager manager = *GetAudioManager(); struct AudioPort audioPortError = { .dir = PORT_OUT, .portId = 8, .portName = "AIP" }; - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, audioPort); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, audioPort); ASSERT_EQ(HDF_SUCCESS, ret); ASSERT_NE(nullptr, adapter); ret = adapter->InitAllPorts(adapter); @@ -859,9 +833,9 @@ HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPassthroughMode_0004, Test enum AudioPortPassthroughMode *modeNull = nullptr; struct AudioAdapter *adapter = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); + TestAudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, audioPort); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, audioPort); ASSERT_EQ(HDF_SUCCESS, ret); ASSERT_NE(nullptr, adapter); ret = adapter->InitAllPorts(adapter); diff --git a/audio/test/systemtest/hdi/capture/BUILD.gn b/audio/test/systemtest/hdi/capture/BUILD.gn index c3c5e075d9..516cd821f2 100755 --- a/audio/test/systemtest/hdi/capture/BUILD.gn +++ b/audio/test/systemtest/hdi/capture/BUILD.gn @@ -11,202 +11,486 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build/test.gni") -import("//drivers/adapter/uhdf2/uhdf.gni") +if (defined(ohos_lite)) { + import("//build/lite/config/test.gni") +} else { + import("//build/test.gni") + import("//drivers/adapter/uhdf2/uhdf.gni") + import("//drivers/peripheral/audio/audio.gni") +} -module_output_path = "hdf/audio/systemtest/hdi" -###########################systemtest############################## -###########################AudioHdiCaptureAttrTest##################### -ohos_systemtest("AudioHdiCaptureAttrTest") { - module_out_path = module_output_path - sources = [ - "src/audio_hdicapture_attr_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] +if (defined(ohos_lite)) { +###########################LITEOS########################################## + ###########################hdf_audio_hdi_capture_attr_test##################### + unittest("hdf_audio_hdi_capture_attr_test") { + sources = [ + "src/audio_hdicapture_attr_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] - include_dirs = [ - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/interfaces/include", - "//drivers/framework/include/core", - "//drivers/framework/include/utils", - "//drivers/framework/include/osal", - "//drivers/framework/include", - "//third_party/bounds_checking_function/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/framework/utils/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/adapter/uhdf2/osal/include", - "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", - "//third_party/googletest/googletest/include/gtest", - "//drivers/peripheral/audio/test/systemtest/hdi/capture/include", - ] - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - ] - deps = [ - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - ] -} -###########################end########################### -###########################systemtest############################## -###########################AudioHdiCaptureControlTest##################### -ohos_systemtest("AudioHdiCaptureControlTest") { - module_out_path = module_output_path - sources = [ - "src/audio_hdicapture_control_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + include_dirs = [ + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/include", + "//drivers/framework/core/sec/include", + "//drivers/framework/core/shared/include", + "//drivers/framework/core/host/include", + "//drivers/framework/core/manager/include", + "//drivers/framework/core/common/include/host/", + "//third_party/bounds_checking_function/include", + "//drivers/adapter/khdf/liteos/osal/include", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/adapter/uhdf2/include/hdi/" , + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/capture/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + } + ###########################end########################### + ###########################hdf_audio_hdi_capture_control_test##################### + unittest("hdf_audio_hdi_capture_control_test") { + sources = [ + "src/audio_hdicapture_control_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] - include_dirs = [ - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/interfaces/include", - "//drivers/framework/include/core", - "//drivers/framework/include/utils", - "//drivers/framework/include/osal", - "//drivers/framework/include", - "//third_party/bounds_checking_function/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/framework/utils/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/adapter/uhdf2/osal/include", - "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", - "//third_party/googletest/googletest/include/gtest", - "//drivers/peripheral/audio/test/systemtest/hdi/capture/include", - ] - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - ] - deps = [ - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - ] -} -###########################end########################### -###########################systemtest############################## -###########################AudioHdiCaptureVolumeTest##################### -ohos_systemtest("AudioHdiCaptureVolumeTest") { - module_out_path = module_output_path - sources = [ - "src/audio_hdicapture_volume_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + include_dirs = [ + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/include", + "//drivers/framework/core/sec/include", + "//drivers/framework/core/shared/include", + "//drivers/framework/core/host/include", + "//drivers/framework/core/manager/include", + "//drivers/framework/core/common/include/host/", + "//third_party/bounds_checking_function/include", + "//drivers/adapter/khdf/liteos/osal/include", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/adapter/uhdf2/include/hdi/" , + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/capture/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + } + ###########################end########################### + ###########################hdf_audio_hdi_capture_volume_test##################### + unittest("hdf_audio_hdi_capture_volume_test") { + sources = [ + "src/audio_hdicapture_volume_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] - include_dirs = [ - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/interfaces/include", - "//drivers/framework/include/core", - "//drivers/framework/include/utils", - "//drivers/framework/include/osal", - "//drivers/framework/include", - "//third_party/bounds_checking_function/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/framework/utils/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/adapter/uhdf2/osal/include", - "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", - "//third_party/googletest/googletest/include/gtest", - "//drivers/peripheral/audio/test/systemtest/hdi/capture/include", - ] - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - ] - deps = [ - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - ] -} -###########################end########################### -###########################systemtest############################## -###########################AudioHdiCaptureSceneTest##################### -ohos_systemtest("AudioHdiCaptureSceneTest") { - module_out_path = module_output_path - sources = [ - "src/audio_hdicapture_scene_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + include_dirs = [ + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/include", + "//drivers/framework/core/sec/include", + "//drivers/framework/core/shared/include", + "//drivers/framework/core/host/include", + "//drivers/framework/core/manager/include", + "//drivers/framework/core/common/include/host/", + "//third_party/bounds_checking_function/include", + "//drivers/adapter/khdf/liteos/osal/include", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/adapter/uhdf2/include/hdi/" , + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/capture/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + } + ###########################end########################### + ###########################hdf_audio_hdi_capture_scene_test##################### + unittest("hdf_audio_hdi_capture_scene_test") { + sources = [ + "src/audio_hdicapture_scene_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] - include_dirs = [ - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/interfaces/include", - "//drivers/framework/include/core", - "//drivers/framework/include/utils", - "//drivers/framework/include/osal", - "//drivers/framework/include", - "//third_party/bounds_checking_function/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/framework/utils/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/adapter/uhdf2/osal/include", - "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", - "//third_party/googletest/googletest/include/gtest", - "//drivers/peripheral/audio/test/systemtest/hdi/capture/include", - ] - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - ] - deps = [ - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - ] -} -###########################end########################### -###########################systemtest############################## -###########################AudioHdiCaptureTest##################### -ohos_systemtest("AudioHdiCaptureTest") { - module_out_path = module_output_path - sources = [ - "src/audio_hdicapture_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + include_dirs = [ + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/include", + "//drivers/framework/core/sec/include", + "//drivers/framework/core/shared/include", + "//drivers/framework/core/host/include", + "//drivers/framework/core/manager/include", + "//drivers/framework/core/common/include/host/", + "//third_party/bounds_checking_function/include", + "//drivers/adapter/khdf/liteos/osal/include", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/adapter/uhdf2/include/hdi/" , + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/capture/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + } + ###########################end########################### + ###########################hdf_audio_hdi_capture_test##################### + unittest("hdf_audio_hdi_capture_test") { + sources = [ + "src/audio_hdicapture_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] + + include_dirs = [ + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/include", + "//drivers/framework/core/sec/include", + "//drivers/framework/core/shared/include", + "//drivers/framework/core/host/include", + "//drivers/framework/core/manager/include", + "//drivers/framework/core/common/include/host/", + "//third_party/bounds_checking_function/include", + "//drivers/adapter/khdf/liteos/osal/include", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/adapter/uhdf2/include/hdi/" , + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/capture/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + } +} else { + ###########################systemtest############################## + module_output_path = "hdf/audio" + ###########################hdf_audio_hdi_capture_attr_test##################### + ohos_systemtest("hdf_audio_hdi_capture_attr_test") { + module_out_path = module_output_path + sources = [ + "src/audio_hdicapture_attr_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] + + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/include", + "//third_party/bounds_checking_function/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/adapter/uhdf2/osal/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/capture/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + deps = [ + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + defines = [] + if (enable_audio_adm_so) { + defines += [ "AUDIO_ADM_SO" ] + } + if (enable_audio_mpi_so) { + defines += [ "AUDIO_MPI_SO" ] + } + if (enable_audio_adm_service) { + defines += [ "AUDIO_ADM_SERVICE" ] + } + if (enable_audio_mpi_service) { + defines += [ "AUDIO_MPI_SERVICE" ] + } + } + ###########################end########################### + ###########################hdf_audio_hdi_capture_control_test##################### + ohos_systemtest("hdf_audio_hdi_capture_control_test") { + module_out_path = module_output_path + sources = [ + "src/audio_hdicapture_control_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] + + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/include", + "//third_party/bounds_checking_function/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/adapter/uhdf2/osal/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/capture/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + deps = [ + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + defines = [] + if (enable_audio_adm_so) { + defines += [ "AUDIO_ADM_SO" ] + } + if (enable_audio_mpi_so) { + defines += [ "AUDIO_MPI_SO" ] + } + if (enable_audio_adm_service) { + defines += [ "AUDIO_ADM_SERVICE" ] + } + if (enable_audio_mpi_service) { + defines += [ "AUDIO_MPI_SERVICE" ] + } + } + ###########################end########################### + ###########################hdf_audio_hdi_capture_volume_test##################### + ohos_systemtest("hdf_audio_hdi_capture_volume_test") { + module_out_path = module_output_path + sources = [ + "src/audio_hdicapture_volume_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] + + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/include", + "//third_party/bounds_checking_function/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/adapter/uhdf2/osal/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/capture/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + deps = [ + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + defines = [] + if (enable_audio_adm_so) { + defines += [ "AUDIO_ADM_SO" ] + } + if (enable_audio_mpi_so) { + defines += [ "AUDIO_MPI_SO" ] + } + if (enable_audio_adm_service) { + defines += [ "AUDIO_ADM_SERVICE" ] + } + if (enable_audio_mpi_service) { + defines += [ "AUDIO_MPI_SERVICE" ] + } + } + ###########################end########################################### + ###########################hdf_audio_hdi_capture_scene_test##################### + ohos_systemtest("hdf_audio_hdi_capture_scene_test") { + module_out_path = module_output_path + sources = [ + "src/audio_hdicapture_scene_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] + + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/include", + "//third_party/bounds_checking_function/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/adapter/uhdf2/osal/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/capture/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + deps = [ + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + defines = [] + if (enable_audio_adm_so) { + defines += [ "AUDIO_ADM_SO" ] + } + if (enable_audio_mpi_so) { + defines += [ "AUDIO_MPI_SO" ] + } + if (enable_audio_adm_service) { + defines += [ "AUDIO_ADM_SERVICE" ] + } + if (enable_audio_mpi_service) { + defines += [ "AUDIO_MPI_SERVICE" ] + } + } + ###########################end########################### + ###########################hdf_audio_hdi_capture_test##################### + ohos_systemtest("hdf_audio_hdi_capture_test") { + module_out_path = module_output_path + sources = [ + "src/audio_hdicapture_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] - include_dirs = [ - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/interfaces/include", - "//drivers/framework/include/core", - "//drivers/framework/include/utils", - "//drivers/framework/include/osal", - "//drivers/framework/include", - "//third_party/bounds_checking_function/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/framework/utils/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/adapter/uhdf2/osal/include", - "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", - "//third_party/googletest/googletest/include/gtest", - "//drivers/peripheral/audio/test/systemtest/hdi/capture/include", - ] - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - ] - deps = [ - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - ] + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/include", + "//third_party/bounds_checking_function/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/adapter/uhdf2/osal/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/capture/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + deps = [ + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + defines = [] + if (enable_audio_adm_so) { + defines += [ "AUDIO_ADM_SO" ] + } + if (enable_audio_mpi_so) { + defines += [ "AUDIO_MPI_SO" ] + } + if (enable_audio_adm_service) { + defines += [ "AUDIO_ADM_SERVICE" ] + } + if (enable_audio_mpi_service) { + defines += [ "AUDIO_MPI_SERVICE" ] + } + } } ###########################end########################### \ No newline at end of file diff --git a/audio/test/systemtest/hdi/capture/src/audio_hdicapture_attr_test.cpp b/audio/test/systemtest/hdi/capture/src/audio_hdicapture_attr_test.cpp index e70c0bfb14..d98afafd9f 100755 --- a/audio/test/systemtest/hdi/capture/src/audio_hdicapture_attr_test.cpp +++ b/audio/test/systemtest/hdi/capture/src/audio_hdicapture_attr_test.cpp @@ -17,7 +17,7 @@ * @addtogroup Audio * @{ * - * @brief Defines audio-related APIs, including custom data types and functions for capture drivers funtion. + * @brief Defines audio-related APIs, including custom data types and functions for capture drivers function. * accessing a driver adapter, and capturing audios. * * @since 1.0 @@ -41,10 +41,9 @@ using namespace testing::ext; using namespace HMOS::Audio; namespace { -const string AUDIO_CAPTURE_FILE = "//bin/audiocapturetest.wav"; -const string ADAPTER_NAME = "hdmi"; -const string ADAPTER_NAME2 = "usb"; -const string ADAPTER_NAME3 = "internal"; +const string ADAPTER_NAME_HDMI = "hdmi"; +const string ADAPTER_NAME_USB = "usb"; +const string ADAPTER_NAME_INTERNAL = "internal"; class AudioHdiCaptureAttrTest : public testing::Test { public: @@ -52,97 +51,77 @@ public: static void TearDownTestCase(void); void SetUp(); void TearDown(); - struct AudioManager *(*GetAudioManager)() = nullptr; - void *handleSo = nullptr; - int32_t GetLoadAdapter(struct AudioManager manager, enum AudioPortDirection portType, - const string adapterName, struct AudioAdapter **adapter, struct AudioPort& audioPort) const; - int32_t AudioCreateCapture(enum AudioPortPin pins, struct AudioManager manager, - struct AudioPort capturePort, struct AudioAdapter *adapter, - struct AudioCapture **capture) const; + static TestAudioManager *(*GetAudioManager)(); + static void *handleSo; +#ifdef AUDIO_MPI_SO + static int32_t (*SdkInit)(); + static void (*SdkExit)(); + static void *sdkSo; +#endif int32_t AudioCaptureStart(const string path, struct AudioCapture *capture) const; }; -void AudioHdiCaptureAttrTest::SetUpTestCase(void) {} +using THREAD_FUNC = void *(*)(void *); -void AudioHdiCaptureAttrTest::TearDownTestCase(void) {} +TestAudioManager *(*AudioHdiCaptureAttrTest::GetAudioManager)() = nullptr; +void *AudioHdiCaptureAttrTest::handleSo = nullptr; +#ifdef AUDIO_MPI_SO + int32_t (*AudioHdiCaptureAttrTest::SdkInit)() = nullptr; + void (*AudioHdiCaptureAttrTest::SdkExit)() = nullptr; + void *AudioHdiCaptureAttrTest::sdkSo = nullptr; +#endif -void AudioHdiCaptureAttrTest::SetUp(void) +void AudioHdiCaptureAttrTest::SetUpTestCase(void) { - char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; - handleSo = dlopen(resolvedPath, RTLD_LAZY); - if (handleSo == nullptr) { +#ifdef AUDIO_MPI_SO + char sdkResolvedPath[] = "//system/lib/libhdi_audio_interface_lib_render.z.so"; + sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY); + if (sdkSo == nullptr) { return; } - GetAudioManager = (struct AudioManager *(*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); - if (GetAudioManager == nullptr) { + SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit")); + if (SdkInit == nullptr) { return; } -} - -void AudioHdiCaptureAttrTest::TearDown(void) -{ - if (GetAudioManager != nullptr) { - GetAudioManager = nullptr; - } -} - -int32_t AudioHdiCaptureAttrTest::GetLoadAdapter(struct AudioManager manager, enum AudioPortDirection portType, - const string adapterName, struct AudioAdapter **adapter, struct AudioPort& audioPort) const -{ - int32_t ret = -1; - int size = 0; - struct AudioAdapterDescriptor *desc = nullptr; - struct AudioAdapterDescriptor *descs = nullptr; - if (adapter == nullptr) { - return HDF_FAILURE; - } - ret = manager.GetAllAdapters(&manager, &descs, &size); - if (ret < 0 || descs == nullptr || size == 0) { - return HDF_FAILURE; - } else { - int index = SwitchAdapter(descs, adapterName, portType, audioPort, size); - if (index < 0) { - return HDF_FAILURE; - } else { - desc = &descs[index]; - } + SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit")); + if (SdkExit == nullptr) { + return; } - if (desc == nullptr) { - return HDF_FAILURE; - } else { - ret = manager.LoadAdapter(&manager, desc, adapter); + SdkInit(); +#endif + handleSo = dlopen(RESOLVED_PATH.c_str(), RTLD_LAZY); + if (handleSo == nullptr) { + return; } - if (ret < 0 || adapter == nullptr) { - return HDF_FAILURE; + GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str())); + if (GetAudioManager == nullptr) { + return; } - return HDF_SUCCESS; } -int32_t AudioHdiCaptureAttrTest::AudioCreateCapture(enum AudioPortPin pins, struct AudioManager manager, - struct AudioPort capturePort, struct AudioAdapter *adapter, struct AudioCapture **capture) const +void AudioHdiCaptureAttrTest::TearDownTestCase(void) { - int32_t ret = -1; - struct AudioSampleAttributes attrs = {}; - struct AudioDeviceDescriptor devDesc = {}; - if (adapter == nullptr || adapter->CreateCapture == nullptr || capture == nullptr) { - return HDF_FAILURE; +#ifdef AUDIO_MPI_SO + SdkExit(); + if (sdkSo != nullptr) { + dlclose(sdkSo); + sdkSo = nullptr; } - ret = InitAttrs(attrs); - if (ret < 0) { - return HDF_FAILURE; + if (SdkInit != nullptr) { + SdkInit = nullptr; } - ret = InitDevDesc(devDesc, capturePort.portId, pins); - if (ret < 0) { - return HDF_FAILURE; + if (SdkExit != nullptr) { + SdkExit = nullptr; } - ret = adapter->CreateCapture(adapter, &devDesc, &attrs, capture); - if (ret < 0 || *capture == nullptr) { - manager.UnloadAdapter(&manager, adapter); - return HDF_FAILURE; +#endif + if (GetAudioManager != nullptr) { + GetAudioManager = nullptr; } - return HDF_SUCCESS; } +void AudioHdiCaptureAttrTest::SetUp(void) {} +void AudioHdiCaptureAttrTest::TearDown(void) {} + int32_t AudioHdiCaptureAttrTest::AudioCaptureStart(const string path, struct AudioCapture *capture) const { int32_t ret = -1; @@ -182,33 +161,17 @@ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_ int32_t ret = -1; uint32_t ret1 = 1; uint32_t ret2 = 8000; - struct AudioPort capturePort = {}; - struct AudioAdapter *adapter = {}; struct AudioSampleAttributes attrs = {}; struct AudioSampleAttributes attrsValue = {}; + struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioManager manager = *GetAudioManager(); - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 8000); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - attrs.type = AUDIO_IN_MEDIA; - attrs.format = AUDIO_FORMAT_PCM_16_BIT; - attrs.sampleRate = 8000; - attrs.channelCount = 1; - - ret = capture->attr.SetSampleAttributes(capture, &attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->attr.GetSampleAttributes(capture, &attrsValue); + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); @@ -233,33 +196,17 @@ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_ int32_t ret = -1; uint32_t ret1 = 2; uint32_t ret2 = 11025; - struct AudioPort capturePort = {}; - struct AudioAdapter *adapter = {}; struct AudioSampleAttributes attrs = {}; struct AudioSampleAttributes attrsValue = {}; + struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioManager manager = *GetAudioManager(); - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 11025); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - attrs.type = AUDIO_IN_MEDIA; - attrs.format = AUDIO_FORMAT_PCM_24_BIT; - attrs.sampleRate = 11025; - attrs.channelCount = 2; - - ret = capture->attr.SetSampleAttributes(capture, &attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->attr.GetSampleAttributes(capture, &attrsValue); + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); @@ -284,33 +231,17 @@ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_ int32_t ret = -1; uint32_t ret1 = 1; uint32_t ret2 = 22050; - struct AudioPort capturePort = {}; - struct AudioAdapter *adapter = {}; struct AudioSampleAttributes attrs = {}; struct AudioSampleAttributes attrsValue = {}; + struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioManager manager = *GetAudioManager(); - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 22050); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - attrs.type = AUDIO_IN_MEDIA; - attrs.format = AUDIO_FORMAT_PCM_16_BIT; - attrs.sampleRate = 22050; - attrs.channelCount = 1; - - ret = capture->attr.SetSampleAttributes(capture, &attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->attr.GetSampleAttributes(capture, &attrsValue); + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); @@ -335,33 +266,17 @@ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_ int32_t ret = -1; uint32_t ret1 = 2; uint32_t ret2 = 32000; - struct AudioPort capturePort = {}; - struct AudioAdapter *adapter = {}; struct AudioSampleAttributes attrs = {}; struct AudioSampleAttributes attrsValue = {}; + struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioManager manager = *GetAudioManager(); - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 32000); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - attrs.type = AUDIO_IN_MEDIA; - attrs.format = AUDIO_FORMAT_PCM_24_BIT; - attrs.sampleRate = 32000; - attrs.channelCount = 2; - - ret = capture->attr.SetSampleAttributes(capture, &attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->attr.GetSampleAttributes(capture, &attrsValue); + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); @@ -386,33 +301,17 @@ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_ int32_t ret = -1; uint32_t ret1 = 1; uint32_t ret2 = 44100; - struct AudioPort capturePort = {}; - struct AudioAdapter *adapter = {}; struct AudioSampleAttributes attrs = {}; struct AudioSampleAttributes attrsValue = {}; + struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioManager manager = *GetAudioManager(); - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 44100); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - attrs.type = AUDIO_IN_MEDIA; - attrs.format = AUDIO_FORMAT_PCM_16_BIT; - attrs.sampleRate = 44100; - attrs.channelCount = 1; - - ret = capture->attr.SetSampleAttributes(capture, &attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->attr.GetSampleAttributes(capture, &attrsValue); + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); @@ -437,35 +336,19 @@ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_ int32_t ret = -1; uint32_t ret1 = 2; uint32_t ret2 = 48000; - struct AudioPort capturePort = {}; - struct AudioAdapter *adapter = {}; struct AudioSampleAttributes attrs = {}; struct AudioSampleAttributes attrsValue = {}; + struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioManager manager = *GetAudioManager(); - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 48000); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - attrs.type = AUDIO_IN_COMMUNICATION; - attrs.format = AUDIO_FORMAT_PCM_24_BIT; - attrs.sampleRate = 48000; - attrs.channelCount = 2; - - ret = capture->attr.SetSampleAttributes(capture, &attrs); + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->attr.GetSampleAttributes(capture, &attrsValue); - EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_EQ(AUDIO_IN_COMMUNICATION, attrsValue.type); + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); EXPECT_EQ(ret2, attrsValue.sampleRate); EXPECT_EQ(ret1, attrsValue.channelCount); @@ -482,28 +365,15 @@ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0007, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - struct AudioAdapter *adapter = {}; struct AudioSampleAttributes attrs = {}; + struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; struct AudioCapture *captureNull = nullptr; - struct AudioManager manager = *GetAudioManager(); - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - attrs.type = AUDIO_IN_MEDIA; - attrs.format = AUDIO_FORMAT_PCM_16_BIT; - attrs.sampleRate = AUDIO_SAMPLE_RATE_MASK_8000; - attrs.channelCount = 1; + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 8000); ret = capture->attr.SetSampleAttributes(captureNull, &attrs); EXPECT_EQ(HDF_FAILURE, ret); @@ -514,273 +384,181 @@ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_ manager.UnloadAdapter(&manager, adapter); } /** -* @tc.name Test AudioCaptureSetSampleAttributes API via illegal input. +* @tc.name Test AudioCaptureSetSampleAttributes API via legal input. * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0008 * @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. * attrs.type = AUDIO_IN_MEDIA; -* attrs.format = AUDIO_FORMAT_PCM_16/24_BIT; -* attrs.sampleRate = 12000/16000/24000; -* attrs.channelCount = 1/2; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = 12000; +* attrs.channelCount = 1; * @tc.author: ZHANGHAILIN */ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0008, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - struct AudioAdapter *adapter = {}; - struct AudioSampleAttributes attrs1 = {}; - struct AudioSampleAttributes attrs2 = {}; - struct AudioSampleAttributes attrs3 = {}; + uint32_t ret1 = 1; + uint32_t ret2 = 12000; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioManager manager = *GetAudioManager(); - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - attrs1.type = AUDIO_IN_MEDIA; - attrs1.format = AUDIO_FORMAT_PCM_16_BIT; - attrs1.sampleRate = 12000; - attrs1.channelCount = 1; - ret = capture->attr.SetSampleAttributes(capture, &attrs1); - EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 12000); - attrs2.type = AUDIO_IN_MEDIA; - attrs2.format = AUDIO_FORMAT_PCM_24_BIT; - attrs2.sampleRate = 16000; - attrs2.channelCount = 1; - ret = capture->attr.SetSampleAttributes(capture, &attrs2); - EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_SUCCESS, ret); - attrs3.type = AUDIO_IN_MEDIA; - attrs3.format = AUDIO_FORMAT_PCM_16_BIT; - attrs3.sampleRate = 24000; - attrs3.channelCount = 2; - ret = capture->attr.SetSampleAttributes(capture, &attrs3); - EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(ret2, attrsValue.sampleRate); + EXPECT_EQ(ret1, attrsValue.channelCount); adapter->DestroyCapture(adapter, capture); manager.UnloadAdapter(&manager, adapter); } /** -* @tc.name Test AudioCaptureSetSampleAttributes API via illegal input. +* @tc.name Test AudioCaptureSetSampleAttributes API via legal input. * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0009 * @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. * attrs.type = AUDIO_IN_MEDIA; -* attrs.format = AUDIO_FORMAT_PCM_16/24_BIT; -* attrs.sampleRate = 64000/96000/0xFFFFFFFFu; -* attrs.channelCount = 1/2; +* attrs.format = AUDIO_FORMAT_PCM_24_BIT; +* attrs.sampleRate = 16000; +* attrs.channelCount = 1; * @tc.author: ZHANGHAILIN */ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0009, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - struct AudioAdapter *adapter = {}; - struct AudioSampleAttributes attrs1 = {}; - struct AudioSampleAttributes attrs2 = {}; - struct AudioSampleAttributes attrs3 = {}; + uint32_t ret1 = 1; + uint32_t ret2 = 16000; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioManager manager = *GetAudioManager(); - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - attrs1.type = AUDIO_IN_MEDIA; - attrs1.format = AUDIO_FORMAT_PCM_16_BIT; - attrs1.sampleRate = 64000; - attrs1.channelCount = 1; - ret = capture->attr.SetSampleAttributes(capture, &attrs1); - EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 16000); - attrs2.type = AUDIO_IN_MEDIA; - attrs2.format = AUDIO_FORMAT_PCM_24_BIT; - attrs2.sampleRate = 96000; - attrs2.channelCount = 1; - ret = capture->attr.SetSampleAttributes(capture, &attrs2); - EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_SUCCESS, ret); - attrs3.type = AUDIO_IN_MEDIA; - attrs3.format = AUDIO_FORMAT_PCM_16_BIT; - attrs3.sampleRate = 0xFFFFFFFFu; - attrs3.channelCount = 2; - ret = capture->attr.SetSampleAttributes(capture, &attrs3); - EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(ret2, attrsValue.sampleRate); + EXPECT_EQ(ret1, attrsValue.channelCount); adapter->DestroyCapture(adapter, capture); manager.UnloadAdapter(&manager, adapter); } /** -* @tc.name Test AudioCaptureSetSampleAttributes API via illegal input. +* @tc.name Test AudioCaptureSetSampleAttributes API via legal input. * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0010 * @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. * attrs.type = AUDIO_IN_MEDIA; -* attrs.format = AUDIO_FORMAT_PCM_8/32_BIT/AAC_MAIN; -* attrs.sampleRate = 8000/11025/22050; -* attrs.channelCount = 1/2; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = 24000; +* attrs.channelCount = 2; * @tc.author: ZHANGHAILIN */ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0010, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - struct AudioAdapter *adapter = {}; - struct AudioSampleAttributes attrs1 = {}; - struct AudioSampleAttributes attrs2 = {}; - struct AudioSampleAttributes attrs3 = {}; + uint32_t ret1 = 2; + uint32_t ret2 = 24000; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioManager manager = *GetAudioManager(); - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - attrs1.type = AUDIO_IN_MEDIA; - attrs1.format = AUDIO_FORMAT_PCM_8_BIT; - attrs1.sampleRate = 8000; - attrs1.channelCount = 1; - ret = capture->attr.SetSampleAttributes(capture, &attrs1); - EXPECT_EQ(HDF_FAILURE, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 2, 24000); - attrs2.type = AUDIO_IN_MEDIA; - attrs2.format = AUDIO_FORMAT_PCM_32_BIT; - attrs2.sampleRate = 11025; - attrs2.channelCount = 2; - ret = capture->attr.SetSampleAttributes(capture, &attrs2); - EXPECT_EQ(HDF_FAILURE, ret); + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_SUCCESS, ret); - attrs3.type = AUDIO_IN_MEDIA; - attrs3.format = AUDIO_FORMAT_AAC_MAIN; - attrs3.sampleRate = 22050; - attrs3.channelCount = 1; - ret = capture->attr.SetSampleAttributes(capture, &attrs3); - EXPECT_EQ(HDF_FAILURE, ret); + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(ret2, attrsValue.sampleRate); + EXPECT_EQ(ret1, attrsValue.channelCount); adapter->DestroyCapture(adapter, capture); manager.UnloadAdapter(&manager, adapter); } /** -* @tc.name Test AudioCaptureSetSampleAttributes API via illegal input. +* @tc.name Test AudioCaptureSetSampleAttributes API via legal input. * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0011 * @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. * attrs.type = AUDIO_IN_MEDIA; -* attrs.format = AUDIO_FORMAT_AAC_LC/LD/ELD; -* attrs.sampleRate = 32000/44100/48000; -* attrs.channelCount = 1/2; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = 64000; +* attrs.channelCount = 1; * @tc.author: ZHANGHAILIN */ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0011, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - struct AudioAdapter *adapter = {}; - struct AudioSampleAttributes attrs1 = {}; - struct AudioSampleAttributes attrs2 = {}; - struct AudioSampleAttributes attrs3 = {}; + uint32_t ret1 = 1; + uint32_t ret2 = 64000; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioManager manager = *GetAudioManager(); - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 64000); - attrs1.type = AUDIO_IN_MEDIA; - attrs1.format = AUDIO_FORMAT_AAC_LC; - attrs1.sampleRate = 32000; - attrs1.channelCount = 2; - ret = capture->attr.SetSampleAttributes(capture, &attrs1); - EXPECT_EQ(HDF_FAILURE, ret); - - attrs2.type = AUDIO_IN_MEDIA; - attrs2.format = AUDIO_FORMAT_AAC_LD; - attrs2.sampleRate = 44100; - attrs2.channelCount = 1; - ret = capture->attr.SetSampleAttributes(capture, &attrs2); - EXPECT_EQ(HDF_FAILURE, ret); + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_SUCCESS, ret); - attrs3.type = AUDIO_IN_MEDIA; - attrs3.format = AUDIO_FORMAT_AAC_ELD; - attrs3.sampleRate = 48000; - attrs3.channelCount = 2; - ret = capture->attr.SetSampleAttributes(capture, &attrs3); - EXPECT_EQ(HDF_FAILURE, ret); + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(ret2, attrsValue.sampleRate); + EXPECT_EQ(ret1, attrsValue.channelCount); adapter->DestroyCapture(adapter, capture); manager.UnloadAdapter(&manager, adapter); } /** -* @tc.name Test AudioCaptureSetSampleAttributes API via illegal input. +* @tc.name Test AudioCaptureSetSampleAttributes API via legal input. * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0012 * @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. * attrs.type = AUDIO_IN_MEDIA; -* attrs.format = AUDIO_FORMAT_AAC_HE_V1/V2 -* attrs.sampleRate = 8000/44100; -* attrs.channelCount = 1/2; +* attrs.format = AUDIO_FORMAT_PCM_24_BIT; +* attrs.sampleRate = 96000; +* attrs.channelCount = 1; * @tc.author: ZHANGHAILIN */ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0012, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - struct AudioAdapter *adapter = {}; - struct AudioSampleAttributes attrs1 = {}; - struct AudioSampleAttributes attrs2 = {}; + uint32_t ret1 = 1; + uint32_t ret2 = 96000; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioManager manager = *GetAudioManager(); - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 96000); - attrs1.type = AUDIO_IN_MEDIA; - attrs1.format = AUDIO_FORMAT_AAC_HE_V1; - attrs1.sampleRate = 8000; - attrs1.channelCount = 1; - ret = capture->attr.SetSampleAttributes(capture, &attrs1); - EXPECT_EQ(HDF_FAILURE, ret); + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_SUCCESS, ret); - attrs2.type = AUDIO_IN_MEDIA; - attrs2.format = AUDIO_FORMAT_AAC_HE_V2; - attrs2.sampleRate = 44100; - attrs2.channelCount = 2; - ret = capture->attr.SetSampleAttributes(capture, &attrs2); - EXPECT_EQ(HDF_FAILURE, ret); + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(ret2, attrsValue.sampleRate); + EXPECT_EQ(ret1, attrsValue.channelCount); adapter->DestroyCapture(adapter, capture); manager.UnloadAdapter(&manager, adapter); @@ -790,87 +568,195 @@ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_ * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0013 * @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. * attrs.type = AUDIO_IN_MEDIA; -* attrs.format = AUDIO_FORMAT_PCM_16_BIT -* attrs.sampleRate = 8000; -* attrs.channelCount = 5; +* attrs.format = AUDIO_FORMAT_PCM_16; +* attrs.sampleRate = 0xFFFFFFFFu; +* attrs.channelCount = 2; * @tc.author: ZHANGHAILIN */ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0013, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - struct AudioAdapter *adapter = {}; struct AudioSampleAttributes attrs = {}; + struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioManager manager = *GetAudioManager(); - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 2, 0xFFFFFFFFu); - attrs.type = AUDIO_IN_MEDIA; - attrs.format = AUDIO_FORMAT_PCM_16_BIT; - attrs.sampleRate = 8000; - attrs.channelCount = 5; ret = capture->attr.SetSampleAttributes(capture, &attrs); - EXPECT_EQ(HDF_FAILURE, ret); + EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); adapter->DestroyCapture(adapter, capture); manager.UnloadAdapter(&manager, adapter); } /** -* @tc.name Test AudioCaptureGetSampleAttributes API via legal input. -* @tc.number SUB_Audio_HDI_AudioCaptureGetSampleAttributes_0001 -* @tc.desc Test AudioCaptureGetSampleAttributes ,the setting parameters are as follows. +* @tc.name Test AudioCaptureSetSampleAttributes API via illegal input. +* @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0014 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. * attrs.type = AUDIO_IN_MEDIA; -* attrs.format = AUDIO_FORMAT_PCM_16_BIT; -* attrs.sampleRate = 8000; -* attrs.channelCount = 1; +* attrs.format = AUDIO_FORMAT_PCM_8/32_BIT/AAC_MAIN; +* attrs.sampleRate = 8000/11025/22050; +* attrs.channelCount = 1/2; * @tc.author: ZHANGHAILIN */ -HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureGetSampleAttributes_0001, TestSize.Level1) +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0014, TestSize.Level1) { int32_t ret = -1; - uint32_t ret1 = 8000; - uint32_t ret2 = 1; - struct AudioPort capturePort = {}; - struct AudioAdapter *adapter = {}; - struct AudioSampleAttributes attrs = {}; - struct AudioSampleAttributes attrsValue = {}; + struct AudioSampleAttributes attrs1 = {}; + struct AudioSampleAttributes attrs2 = {}; + struct AudioSampleAttributes attrs3 = {}; + struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); + ASSERT_EQ(HDF_SUCCESS, ret); + + InitAttrsUpdate(attrs1, AUDIO_FORMAT_PCM_8_BIT, 1, 8000); + ret = capture->attr.SetSampleAttributes(capture, &attrs1); + EXPECT_EQ(HDF_FAILURE, ret); + + InitAttrsUpdate(attrs2, AUDIO_FORMAT_PCM_32_BIT, 2, 11025); + ret = capture->attr.SetSampleAttributes(capture, &attrs2); + EXPECT_EQ(HDF_FAILURE, ret); + + InitAttrsUpdate(attrs3, AUDIO_FORMAT_AAC_MAIN, 1, 22050); + ret = capture->attr.SetSampleAttributes(capture, &attrs3); + EXPECT_EQ(HDF_FAILURE, ret); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via illegal input. +* @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0015 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_AAC_LC/LD/ELD; +* attrs.sampleRate = 32000/44100/48000; +* attrs.channelCount = 1/2; +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0015, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioSampleAttributes attrs1 = {}; + struct AudioSampleAttributes attrs2 = {}; + struct AudioSampleAttributes attrs3 = {}; + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = capture->attr.GetSampleAttributes(capture, &attrsValue); - EXPECT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs1, AUDIO_FORMAT_AAC_LC, 2, 32000); + ret = capture->attr.SetSampleAttributes(capture, &attrs1); + EXPECT_EQ(HDF_FAILURE, ret); + + InitAttrsUpdate(attrs2, AUDIO_FORMAT_AAC_LD, 1, 44100); + ret = capture->attr.SetSampleAttributes(capture, &attrs2); + EXPECT_EQ(HDF_FAILURE, ret); + + InitAttrsUpdate(attrs3, AUDIO_FORMAT_AAC_ELD, 2, 48000); + ret = capture->attr.SetSampleAttributes(capture, &attrs3); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via illegal input. +* @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0016 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_AAC_HE_V1/V2 +* attrs.sampleRate = 8000/44100; +* attrs.channelCount = 1/2; +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0016, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioSampleAttributes attrs1 = {}; + struct AudioSampleAttributes attrs2 = {}; + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); + ASSERT_EQ(HDF_SUCCESS, ret); + + InitAttrsUpdate(attrs1, AUDIO_FORMAT_AAC_HE_V1, 1, 8000); + ret = capture->attr.SetSampleAttributes(capture, &attrs1); + EXPECT_EQ(HDF_FAILURE, ret); + + InitAttrsUpdate(attrs2, AUDIO_FORMAT_AAC_HE_V2, 2, 44100); + ret = capture->attr.SetSampleAttributes(capture, &attrs2); + EXPECT_EQ(HDF_FAILURE, ret); - attrs.type = AUDIO_IN_MEDIA; - attrs.format = AUDIO_FORMAT_PCM_16_BIT; - attrs.sampleRate = 8000; - attrs.channelCount = 1; + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via illegal input. +* @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0017 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT +* attrs.sampleRate = 8000; +* attrs.channelCount = 5; +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0017, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioSampleAttributes attrs = {}; + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); + ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 5, 8000); ret = capture->attr.SetSampleAttributes(capture, &attrs); - EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureGetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_AudioCaptureGetSampleAttributes_0001 +* @tc.desc Test AudioCaptureGetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = 8000; +* attrs.channelCount = 1; +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureGetSampleAttributes_0001, TestSize.Level1) +{ + int32_t ret = -1; + uint32_t ret1 = 32000; + uint32_t ret2 = 1; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); + ASSERT_EQ(HDF_SUCCESS, ret); ret = capture->attr.GetSampleAttributes(capture, &attrsValue); EXPECT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 32000); + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); EXPECT_EQ(ret1, attrsValue.sampleRate); @@ -888,29 +774,15 @@ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureGetSampleAttributes_ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureGetSampleAttributes_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - struct AudioAdapter *adapter = {}; struct AudioSampleAttributes attrs = {}; + struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; struct AudioCapture *captureNull = nullptr; - struct AudioManager manager = *GetAudioManager(); - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0 || capture == nullptr) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - ASSERT_NE(nullptr, capture); - } - - attrs.type = AUDIO_IN_MEDIA; - attrs.format = AUDIO_FORMAT_PCM_24_BIT; - attrs.sampleRate = 48000; - attrs.channelCount = 1; + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 48000); ret = capture->attr.GetSampleAttributes(captureNull, &attrs); EXPECT_EQ(HDF_FAILURE, ret); @@ -929,23 +801,14 @@ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureGetSampleAttributes_ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameSize_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioAdapter* adapter = nullptr; - struct AudioCapture* capture = nullptr; uint64_t size = 0; - + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (capture == nullptr || ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = capture->attr.GetFrameSize((AudioHandle)capture, &size); + ret = capture->attr.GetFrameSize(capture, &size); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_GT(size, INITIAL_VALUE); @@ -961,25 +824,16 @@ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameSize_0001, TestSi HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameSize_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioAdapter* adapter = nullptr; - struct AudioCapture* capture = nullptr; - struct AudioCapture* captureNull = nullptr; uint64_t size = 0; - + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + struct AudioCapture *captureNull = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (capture == nullptr || ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = capture->attr.GetFrameSize((AudioHandle)captureNull, &size); + ret = capture->attr.GetFrameSize(captureNull, &size); EXPECT_EQ(HDF_FAILURE, ret); adapter->DestroyCapture(adapter, capture); @@ -994,29 +848,160 @@ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameSize_0002, TestSi HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameSize_0003, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioAdapter* adapter = nullptr; - struct AudioCapture* capture = nullptr; - uint64_t* sizeNull = nullptr; - + uint64_t *sizeNull = nullptr; + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (capture == nullptr || ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = capture->attr.GetFrameSize((AudioHandle)capture, sizeNull); + ret = capture->attr.GetFrameSize(capture, sizeNull); EXPECT_EQ(HDF_FAILURE, ret); adapter->DestroyCapture(adapter, capture); manager.UnloadAdapter(&manager, adapter); } +/** + * @tc.name Test CaptureGetFrameSize API via define format to different values + * @tc.number SUB_Audio_hdi_CaptureGetFrameSize_0004 + * @tc.desc Test CaptureGetFrameSize interface,return 0 if get framesize define format as different values + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameSize_0004, TestSize.Level1) +{ + int32_t ret = -1; + uint64_t size = 0; + uint64_t channelCountExp = 2; + uint32_t sampleRateExp = 48000; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); + ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 48000); + + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); + EXPECT_EQ(channelCountExp, attrsValue.channelCount); + + ret = capture->attr.GetFrameSize(capture, &size); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(size, INITIAL_VALUE); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test CaptureGetFrameSize API via define sampleRate to different values + * @tc.number SUB_Audio_hdi_CaptureGetFrameSize_0005 + * @tc.desc Test CaptureGetFrameSize interface,return 0 if get framesize define sampleRate as different values + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameSize_0005, TestSize.Level1) +{ + int32_t ret = -1; + uint64_t size = 0; + uint64_t channelCountExp = 1; + uint32_t sampleRateExp = 48000; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); + ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 48000); + + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); + EXPECT_EQ(channelCountExp, attrsValue.channelCount); + + ret = capture->attr.GetFrameSize(capture, &size); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(size, INITIAL_VALUE); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test CaptureGetFrameSize API via define channelCount to different values + * @tc.number SUB_Audio_hdi_CaptureGetFrameSize_0006 + * @tc.desc Test CaptureGetFrameSize interface,return 0 if get framesize define channelCount as different values + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameSize_0006, TestSize.Level1) +{ + int32_t ret = -1; + uint64_t size = 0; + uint64_t channelCountExp = 2; + uint32_t sampleRateExp = 44100; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); + ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 44100); + + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); + EXPECT_EQ(channelCountExp, attrsValue.channelCount); + + ret = capture->attr.GetFrameSize(capture, &size); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(size, INITIAL_VALUE); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test CaptureGetFrameSize API via define sampleRate to different value + * @tc.number SUB_Audio_hdi_CaptureGetFrameSize_0007 + * @tc.desc Test CaptureGetFrameSize interface,return 0 if get framesize define sampleRate as different values + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameSize_0007, TestSize.Level1) +{ + int32_t ret = -1; + uint64_t size = 0; + uint64_t channelCountExp = 1; + uint32_t sampleRateExp = 48000; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); + ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 48000); + + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); + EXPECT_EQ(channelCountExp, attrsValue.channelCount); + + ret = capture->attr.GetFrameSize(capture, &size); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(size, INITIAL_VALUE); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} /** * @tc.name Test AudioCaptureGetFrameCount API via legal input * @tc.number SUB_Audio_hdi_CaptureGetFrameCount_0001 @@ -1026,27 +1011,18 @@ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameSize_0003, TestSi HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameCount_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioAdapter* adapter = nullptr; - struct AudioCapture* capture = nullptr; uint64_t count = 0; - + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (capture == nullptr || ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = capture->attr.GetFrameCount((AudioHandle)capture, &count); + + ret = capture->attr.GetFrameCount(capture, &count); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(count, INITIAL_VALUE); - capture->control.Stop((AudioHandle)capture); adapter->DestroyCapture(adapter, capture); manager.UnloadAdapter(&manager, adapter); } @@ -1059,26 +1035,18 @@ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameCount_0001, TestS HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameCount_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioAdapter* adapter = nullptr; - struct AudioCapture* capture = nullptr; uint64_t count = 0; - + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (capture == nullptr || ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->attr.GetFrameCount((AudioHandle)capture, &count); + ret = capture->attr.GetFrameCount(capture, &count); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_GT(count, INITIAL_VALUE); @@ -1095,33 +1063,22 @@ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameCount_0002, TestS HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameCount_0003, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioAdapter* adapter = nullptr; - struct AudioCapture* capture = nullptr; - struct AudioCapture* captureNull = nullptr; uint64_t count = 0; - + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + struct AudioCapture *captureNull = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (capture == nullptr || ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->attr.GetFrameCount((AudioHandle)captureNull, &count); + ret = capture->attr.GetFrameCount(captureNull, &count); EXPECT_EQ(HDF_FAILURE, ret); - capture->control.Stop((AudioHandle)capture); adapter->DestroyCapture(adapter, capture); manager.UnloadAdapter(&manager, adapter); } + /** * @tc.name Test AudioCaptureGetFrameCount API via setting the parameter handle is nullptr * @tc.number SUB_Audio_hdi_CaptureGetFrameCount_0004 @@ -1131,60 +1088,195 @@ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameCount_0003, TestS HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameCount_0004, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioAdapter* adapter = nullptr; - struct AudioCapture* capture = nullptr; - uint64_t* countNull = nullptr; - + uint64_t *countNull = nullptr; + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (capture == nullptr || ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->attr.GetFrameCount((AudioHandle)capture, countNull); + ret = capture->attr.GetFrameCount(capture, countNull); EXPECT_EQ(HDF_FAILURE, ret); - capture->control.Stop((AudioHandle)capture); adapter->DestroyCapture(adapter, capture); manager.UnloadAdapter(&manager, adapter); } /** - * @tc.name Test CaptureGetCurrentChannelId API via legal input - * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_0001 - * @tc.desc Test GetCurrentChannelId, return 0 if the default CurrentChannelId is obtained successfully + * @tc.name Test CaptureGetFrameCount API via define channelCount to different value + * @tc.number SUB_Audio_hdi_CaptureGetFrameCount_0005 + * @tc.desc Test CaptureGetFrameCount interface,return 0 if get framesize define channelCount as different values * @tc.author: tiansuli */ -HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetCurrentChannelId_0001, TestSize.Level1) +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameCount_0005, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioAdapter* adapter = nullptr; - struct AudioCapture* capture = nullptr; - uint32_t channelId = 0; - uint32_t channelIdValue = CHANNELCOUNT; - + uint64_t count = 0; + uint64_t channelCountExp = 2; + uint32_t sampleRateExp = 8000; + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (capture == nullptr || ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = capture->attr.GetCurrentChannelId(capture, &channelId); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 8000); + + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); + EXPECT_EQ(channelCountExp, attrsValue.channelCount); + + ret = AudioCaptureStartAndOneFrame(capture); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->attr.GetFrameCount(capture, &count); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(count, INITIAL_VALUE); + + ret = capture->control.Stop((AudioHandle)capture); + EXPECT_EQ(HDF_SUCCESS, ret); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test CaptureGetFrameCount API via define format to different value + * @tc.number SUB_Audio_hdi_CaptureGetFrameCount_0006 + * @tc.desc Test CaptureGetFrameCount interface,return 0 if get framesize define format as different values + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameCount_0006, TestSize.Level1) +{ + int32_t ret = -1; + uint64_t count = 0; + uint64_t channelCountExp = 2; + uint32_t sampleRateExp = 8000; + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); + ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 2, 8000); + + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); + EXPECT_EQ(channelCountExp, attrsValue.channelCount); + + ret = AudioCaptureStartAndOneFrame(capture); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->attr.GetFrameCount(capture, &count); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(count, INITIAL_VALUE); + + ret = capture->control.Stop((AudioHandle)capture); + EXPECT_EQ(HDF_SUCCESS, ret); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test CaptureGetFrameCount API via define channelCount to different value + * @tc.number SUB_Audio_hdi_CaptureGetFrameCount_0007 + * @tc.desc Test CaptureGetFrameCount interface,return 0 if get framesize define channelCount to different values + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameCount_0007, TestSize.Level1) +{ + int32_t ret = -1; + uint64_t count = 0; + uint64_t channelCountExp = 1; + uint32_t sampleRateExp = 44100; + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); + ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 44100); + + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); + EXPECT_EQ(channelCountExp, attrsValue.channelCount); + + ret = AudioCaptureStartAndOneFrame(capture); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->attr.GetFrameCount(capture, &count); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(count, INITIAL_VALUE); + + ret = capture->control.Stop((AudioHandle)capture); + EXPECT_EQ(HDF_SUCCESS, ret); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test CaptureGetFrameCount API via define format to different value + * @tc.number SUB_Audio_hdi_CaptureGetFrameCount_0008 + * @tc.desc Test CaptureGetFrameCount interface,return 0 if get framesize define format as different values + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameCount_0008, TestSize.Level1) +{ + int32_t ret = -1; + uint64_t count = 0; + uint64_t channelCountExp = 1; + uint32_t sampleRateExp = 32000; + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); + ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 32000); + + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); + EXPECT_EQ(channelCountExp, attrsValue.channelCount); + + ret = AudioCaptureStartAndOneFrame(capture); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->attr.GetFrameCount(capture, &count); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(count, INITIAL_VALUE); + + ret = capture->control.Stop((AudioHandle)capture); + EXPECT_EQ(HDF_SUCCESS, ret); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test CaptureGetCurrentChannelId API via legal input + * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_0001 + * @tc.desc Test GetCurrentChannelId, return 0 if the default CurrentChannelId is obtained successfully + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetCurrentChannelId_0001, TestSize.Level1) +{ + int32_t ret = -1; + uint32_t channelId = 0; + uint32_t channelIdValue = CHANNELCOUNT; + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); + ASSERT_EQ(HDF_SUCCESS, ret); + + ret = capture->attr.GetCurrentChannelId(capture, &channelId); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(channelIdValue, channelId); @@ -1200,34 +1292,21 @@ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetCurrentChannelId_0001, HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetCurrentChannelId_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioAdapter* adapter = nullptr; - struct AudioCapture* capture = nullptr; uint32_t channelId = 0; uint32_t channelIdExp = 1; uint32_t channelCountExp = 1; struct AudioSampleAttributes attrs = {}; struct AudioSampleAttributes attrsValue = {}; - + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (capture == nullptr || ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - attrs.type = AUDIO_IN_MEDIA; - attrs.format = AUDIO_FORMAT_PCM_16_BIT; - attrs.sampleRate = 48000; - attrs.channelCount = 1; - ret = capture->attr.SetSampleAttributes(capture, &attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->attr.GetSampleAttributes(capture, &attrsValue); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 48000); + + ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(channelCountExp, attrsValue.channelCount); @@ -1247,23 +1326,14 @@ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetCurrentChannelId_0002, HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetCurrentChannelId_0003, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioAdapter* adapter = nullptr; - struct AudioCapture* capture = nullptr; uint32_t channelId = 0; uint32_t channelIdExp = 2; - + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (capture == nullptr || ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); EXPECT_EQ(HDF_SUCCESS, ret); @@ -1284,23 +1354,14 @@ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetCurrentChannelId_0003, HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetCurrentChannelId_0004, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioAdapter* adapter = nullptr; - struct AudioCapture* capture = nullptr; - struct AudioCapture* captureNull = nullptr; uint32_t channelId = 0; - + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + struct AudioCapture *captureNull = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (capture == nullptr || ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = capture->attr.GetCurrentChannelId(captureNull, &channelId); EXPECT_EQ(HDF_FAILURE, ret); @@ -1317,28 +1378,379 @@ HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetCurrentChannelId_0004, HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetCurrentChannelId_0005, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioAdapter* adapter = nullptr; - struct AudioCapture* capture = nullptr; - struct AudioCapture* captureNull = nullptr; uint32_t *channelIdNull = nullptr; + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); + ASSERT_EQ(HDF_SUCCESS, ret); + + ret = capture->attr.GetCurrentChannelId(capture, channelIdNull); + EXPECT_EQ(HDF_FAILURE, ret); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +#if defined (AUDIO_ADM_SERVICE) || defined (AUDIO_ADM_SO) +/** + * @tc.name Test CaptureSetExtraParams API via setting ExtraParams during playback + * @tc.number SUB_Audio_HDI_CaptureSetExtraParams_0001 + * @tc.desc Test CaptureSetExtraParams interface,return 0 if the ExtraParams is set during playback + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureSetExtraParams_0001, TestSize.Level1) +{ + int32_t ret = -1; + char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000"; + char keyValueListValue[256] = {}; + int32_t listLenth = 256; + uint64_t FILESIZE = 1024; + struct PrepareAudioPara audiopara = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE + }; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (capture == nullptr || ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); + sleep(1); + if (audiopara.capture != nullptr) { + ret = audiopara.capture->attr.SetExtraParams((AudioHandle)audiopara.capture, keyValueList); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.capture->attr.GetExtraParams((AudioHandle)audiopara.capture, keyValueListValue, listLenth); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_STREQ(keyValueList, keyValueListValue); } - ret = capture->attr.GetCurrentChannelId(captureNull, channelIdNull); + ret = ThreadRelease(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); +} +/** + * @tc.name Test CaptureSetExtraParams API via setting some parameters after playing + * @tc.number SUB_Audio_HDI_CaptureSetExtraParams_0002 + * @tc.desc Test CaptureSetExtraParams interface,return 0 if some parameters is set after playing + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureSetExtraParams_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = {}; + struct AudioCapture *capture = nullptr; + char keyValueListOne[] = "attr-route=1;"; + char keyValueListOneExp[] = "attr-route=1;attr-format=16;attr-channels=2;attr-frame-count=4096;\ +attr-sampling-rate=48000"; + char keyValueListTwo[] = "attr-route=0;attr-format=32;"; + char keyValueListTwoExp[] = "attr-route=0;attr-format=32;attr-channels=2;attr-frame-count=4096;\ +attr-sampling-rate=48000"; + char keyValueListThr[] = "attr-route=1;attr-format=24;attr-channels=1;"; + char keyValueListThrExp[] = "attr-route=1;attr-format=24;attr-channels=1;attr-frame-count=4096;\ +attr-sampling-rate=48000"; + char keyValueListFour[] = "attr-format=32;attr-channels=2;attr-frame-count=4096;attr-sampling-rate=48000"; + char keyValueListFourExp[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=4096;\ +attr-sampling-rate=48000"; + char keyValueListValueOne[256] = {}; + char keyValueListValueTwo[256] = {}; + char keyValueListValueThr[256] = {}; + char keyValueListValueFour[256] = {}; + int32_t listLenth = 256; + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB); + ASSERT_EQ(HDF_SUCCESS, ret); + + ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueListOne); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValueOne, listLenth); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_STREQ(keyValueListOneExp, keyValueListValueOne); + ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueListTwo); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValueTwo, listLenth); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_STREQ(keyValueListTwoExp, keyValueListValueTwo); + ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueListThr); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValueThr, listLenth); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_STREQ(keyValueListThrExp, keyValueListValueThr); + ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueListFour); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValueFour, listLenth); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_STREQ(keyValueListFourExp, keyValueListValueFour); + + ret = capture->control.Stop((AudioHandle)capture); + EXPECT_EQ(HDF_SUCCESS, ret); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test CaptureSetExtraParams API via setting keyvaluelist to a value outside the range + * @tc.number SUB_Audio_HDI_CaptureSetExtraParams_0003 + * @tc.desc Test CaptureSetExtraParams interface,return -1 if the Keyvaluelist is a value out of range + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureSetExtraParams_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = {}; + struct AudioCapture *capture = nullptr; + char keyValueList[] = "attr-para=abc;"; + + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueList); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test CaptureSetExtraParams API via adding parameters to keyvaluelist + * @tc.number SUB_Audio_HDI_CaptureSetExtraParams_0004 + * @tc.desc Test CaptureSetExtraParams interface,return -1 if adding parameters to keyvaluelist + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureSetExtraParams_0004, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = {}; + struct AudioCapture *capture = nullptr; + char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000;\ +attr-para=abc"; + + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueList); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test CaptureSetExtraParams API via setting ExtraParams When the key is the same and the value is + different + * @tc.number SUB_Audio_HDI_CaptureSetExtraParams_0005 + * @tc.desc Test CaptureSetExtraParams interface,return 0 if set ExtraParams When the key is the same and the value + is different + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureSetExtraParams_0005, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = {}; + struct AudioCapture *capture = nullptr; + char keyValueList[] = "attr-route=1;attr-format=32;"; + char keyValueListExp[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=4096;\ +attr-sampling-rate=48000"; + char keyValueListValue[256] = {}; + int32_t listLenth = 256; + + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueList); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValue, listLenth); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_STREQ(keyValueListExp, keyValueListValue); + + ret = capture->control.Stop((AudioHandle)capture); + EXPECT_EQ(HDF_SUCCESS, ret); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test CaptureSetExtraParams API via setting the parameter in keyvaluelist as an abnormal value + * @tc.number SUB_Audio_HDI_CaptureSetExtraParams_0006 + * @tc.desc Test CaptureSetExtraParams interface,return -1 if set the parameter in keyvaluelist as an abnormal value + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureSetExtraParams_0006, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = {}; + struct AudioCapture *capture = nullptr; + char attrSamplingRateError[] = "attr-sampling-rate=1234567;"; + char attrChannelsError[] = "attr-channels=3;"; + char attrFrameCountError[] = "attr-frame-count=111111111111111111111;"; + char attrRouteError[] = "attr-route=5;"; + char attrFormateError[] = "attr-formate=12;"; + + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = capture->attr.SetExtraParams((AudioHandle)capture, attrSamplingRateError); + EXPECT_EQ(HDF_FAILURE, ret); + ret = capture->attr.SetExtraParams((AudioHandle)capture, attrChannelsError); + EXPECT_EQ(HDF_FAILURE, ret); + ret = capture->attr.SetExtraParams((AudioHandle)capture, attrFrameCountError); + EXPECT_EQ(HDF_FAILURE, ret); + ret = capture->attr.SetExtraParams((AudioHandle)capture, attrRouteError); + EXPECT_EQ(HDF_FAILURE, ret); + ret = capture->attr.SetExtraParams((AudioHandle)capture, attrFormateError); EXPECT_EQ(HDF_FAILURE, ret); adapter->DestroyCapture(adapter, capture); manager.UnloadAdapter(&manager, adapter); } +/** + * @tc.name Test CaptureSetExtraParams API via setting the parameter render is nullptr + * @tc.number SUB_Audio_HDI_CaptureSetExtraParams_0007 + * @tc.desc Test CaptureSetExtraParams interface,return -1 if set the parameter render is nullptr + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureSetExtraParams_0007, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = {}; + struct AudioCapture *capture = nullptr; + struct AudioCapture *captureNull = nullptr; + char keyValueList[] = "attr-format=2;"; + + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = capture->attr.SetExtraParams((AudioHandle)captureNull, keyValueList); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test CaptureSetExtraParams API via setting the format of ExtraParams is nullptr + * @tc.number SUB_Audio_HDI_CaptureSetExtraParams_0008 + * @tc.desc Test CaptureSetExtraParams interface,return -1 if set the format of ExtraParams is nullptr + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureSetExtraParams_0008, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = {}; + struct AudioCapture *capture = nullptr; + char keyValueListNull[] = "attr-format=;"; + + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueListNull); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test CaptureGetExtraParams API via legal input + * @tc.number SUB_Audio_HDI_CaptureGetExtraParams_0001 + * @tc.desc Test CaptureGetExtraParams interface,return 0 if the RenderGetExtraParams was obtained successfully + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetExtraParams_0001, TestSize.Level1) +{ + int32_t ret = -1; + uint64_t count = 0; + struct AudioAdapter *adapter = {}; + struct AudioCapture *capture = nullptr; + struct AudioSampleAttributes attrsValue = {}; + char keyValueList[] = "attr-format=24;"; + char keyValueListExp[] = "attr-route=0;attr-format=24;attr-channels=2;attr-frame-count=4096;\ +attr-sampling-rate=48000"; + char keyValueListValue[256] = {}; + int32_t listLenth = 256; + int32_t formatExp = 3; + uint32_t sampleRateExp = 48000; + uint32_t channelCountExp = 2; + uint32_t frameCountExp = 4096; + + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueList); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValue, listLenth); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_STREQ(keyValueListExp, keyValueListValue); + + ret = capture->attr.GetSampleAttributes(capture, &attrsValue); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(formatExp, attrsValue.format); + EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); + EXPECT_EQ(channelCountExp, attrsValue.channelCount); + ret = capture->attr.GetFrameCount(capture, &count); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(count, frameCountExp); + + ret = capture->control.Stop((AudioHandle)capture); + EXPECT_EQ(HDF_SUCCESS, ret); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test CaptureGetExtraParams API via setting the parameter render is nullptr + * @tc.number SUB_Audio_HDI_CaptureGetExtraParams_0002 + * @tc.desc Test CaptureGetExtraParams interface,return 0 if set the parameter render is nullptr + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetExtraParams_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = {}; + struct AudioCapture *capture = nullptr; + struct AudioCapture *captureNull = nullptr; + char keyValueList[] = "attr-format=32;"; + char keyValueListValue[256] = {}; + int32_t listLenth = 256; + + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueList); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->attr.GetExtraParams((AudioHandle)captureNull, keyValueListValue, listLenth); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test CaptureGetExtraParams API via setting listlength to be less than the actual length + * @tc.number SUB_Audio_HDI_CaptureGetExtraParams_0003 + * @tc.desc Test CaptureGetExtraParams interface,return 0 if set listlength to be less than the actual length + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetExtraParams_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = {}; + struct AudioCapture *capture = nullptr; + char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000;"; + char keyValueListValue[256] = {}; + int32_t listLenth = 8; + + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueList); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValue, listLenth); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); } +#endif +} \ No newline at end of file diff --git a/audio/test/systemtest/hdi/capture/src/audio_hdicapture_control_test.cpp b/audio/test/systemtest/hdi/capture/src/audio_hdicapture_control_test.cpp index 2542dab01f..1ec21b8d28 100755 --- a/audio/test/systemtest/hdi/capture/src/audio_hdicapture_control_test.cpp +++ b/audio/test/systemtest/hdi/capture/src/audio_hdicapture_control_test.cpp @@ -17,7 +17,7 @@ * @addtogroup Audio * @{ * - * @brief Defines audio-related APIs, including custom data types and functions for capture drivers funtion. + * @brief Defines audio-related APIs, including custom data types and functions for capture drivers function. * accessing a driver adapter, and capturing audios. * * @since 1.0 @@ -41,10 +41,9 @@ using namespace testing::ext; using namespace HMOS::Audio; namespace { -const string AUDIO_CAPTURE_FILE = "//bin/audiocapturetest.wav"; -const string ADAPTER_NAME = "hdmi"; -const string ADAPTER_NAME2 = "usb"; -const string ADAPTER_NAME3 = "internal"; +const string ADAPTER_NAME_HDMI = "hdmi"; +const string ADAPTER_NAME_USB = "usb"; +const string ADAPTER_NAME_INTERNAL = "internal"; class AudioHdiCaptureControlTest : public testing::Test { public: @@ -52,145 +51,74 @@ public: static void TearDownTestCase(void); void SetUp(); void TearDown(); - struct AudioManager *(*GetAudioManager)() = nullptr; - void *handleSo = nullptr; - int32_t GetLoadAdapter(struct AudioManager manager, enum AudioPortDirection portType, - const string adapterName, struct AudioAdapter **adapter, struct AudioPort& audioPort) const; - int32_t AudioCreateCapture(enum AudioPortPin pins, struct AudioManager manager, - struct AudioPort capturePort, struct AudioAdapter *adapter, - struct AudioCapture **capture) const; - int32_t AudioCreateRender(enum AudioPortPin pins, struct AudioManager manager, struct AudioAdapter *adapter, - const struct AudioPort renderPort, struct AudioRender **render) const; - int32_t AudioCaptureStart(const string path, struct AudioCapture *capture) const; + static TestAudioManager *(*GetAudioManager)(); + static void *handleSo; +#ifdef AUDIO_MPI_SO + static int32_t (*SdkInit)(); + static void (*SdkExit)(); + static void *sdkSo; +#endif }; -void AudioHdiCaptureControlTest::SetUpTestCase(void) {} +TestAudioManager *(*AudioHdiCaptureControlTest::GetAudioManager)() = nullptr; +void *AudioHdiCaptureControlTest::handleSo = nullptr; +#ifdef AUDIO_MPI_SO + int32_t (*AudioHdiCaptureControlTest::SdkInit)() = nullptr; + void (*AudioHdiCaptureControlTest::SdkExit)() = nullptr; + void *AudioHdiCaptureControlTest::sdkSo = nullptr; +#endif -void AudioHdiCaptureControlTest::TearDownTestCase(void) {} - -void AudioHdiCaptureControlTest::SetUp(void) +void AudioHdiCaptureControlTest::SetUpTestCase(void) { - char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; - handleSo = dlopen(resolvedPath, RTLD_LAZY); - if (handleSo == nullptr) { +#ifdef AUDIO_MPI_SO + char sdkResolvedPath[] = "//system/lib/libhdi_audio_interface_lib_render.z.so"; + sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY); + if (sdkSo == nullptr) { return; } - GetAudioManager = (struct AudioManager *(*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); - if (GetAudioManager == nullptr) { + SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit")); + if (SdkInit == nullptr) { return; } -} - -void AudioHdiCaptureControlTest::TearDown(void) -{ - if (GetAudioManager != nullptr) { - GetAudioManager = nullptr; - } -} - -int32_t AudioHdiCaptureControlTest::GetLoadAdapter(struct AudioManager manager, enum AudioPortDirection portType, - const string adapterName, struct AudioAdapter **adapter, struct AudioPort& audioPort) const -{ - int32_t ret = -1; - int size = 0; - struct AudioAdapterDescriptor *desc = nullptr; - struct AudioAdapterDescriptor *descs = nullptr; - if (adapter == nullptr) { - return HDF_FAILURE; - } - ret = manager.GetAllAdapters(&manager, &descs, &size); - if (ret < 0 || descs == nullptr || size == 0) { - return HDF_FAILURE; - } else { - int index = SwitchAdapter(descs, adapterName, portType, audioPort, size); - if (index < 0) { - return HDF_FAILURE; - } else { - desc = &descs[index]; - } - } - if (desc == nullptr) { - return HDF_FAILURE; - } else { - ret = manager.LoadAdapter(&manager, desc, adapter); - } - if (ret < 0 || adapter == nullptr) { - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t AudioHdiCaptureControlTest::AudioCreateCapture(enum AudioPortPin pins, struct AudioManager manager, - struct AudioPort capturePort, struct AudioAdapter *adapter, struct AudioCapture **capture) const -{ - int32_t ret = -1; - struct AudioSampleAttributes attrs = {}; - struct AudioDeviceDescriptor devDesc = {}; - if (adapter == nullptr || capture == nullptr) { - return HDF_FAILURE; - } - ret = InitAttrs(attrs); - if (ret < 0) { - return HDF_FAILURE; + SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit")); + if (SdkExit == nullptr) { + return; } - ret = InitDevDesc(devDesc, capturePort.portId, pins); - if (ret < 0) { - return HDF_FAILURE; + SdkInit(); +#endif + handleSo = dlopen(RESOLVED_PATH.c_str(), RTLD_LAZY); + if (handleSo == nullptr) { + return; } - ret = adapter->CreateCapture(adapter, &devDesc, &attrs, capture); - if (ret < 0 || *capture == nullptr) { - manager.UnloadAdapter(&manager, adapter); - return HDF_FAILURE; + GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str())); + if (GetAudioManager == nullptr) { + return; } - return HDF_SUCCESS; } -int32_t AudioHdiCaptureControlTest::AudioCreateRender(enum AudioPortPin pins, struct AudioManager manager, - struct AudioAdapter *adapter, const struct AudioPort renderPort, struct AudioRender **render) const +void AudioHdiCaptureControlTest::TearDownTestCase(void) { - int32_t ret = -1; - struct AudioSampleAttributes attrs = {}; - struct AudioDeviceDescriptor devDesc = {}; - if (adapter == nullptr || adapter->CreateRender == nullptr || render == nullptr) { - return HDF_FAILURE; +#ifdef AUDIO_MPI_SO + SdkExit(); + if (sdkSo != nullptr) { + dlclose(sdkSo); + sdkSo = nullptr; } - ret = InitAttrs(attrs); - if (ret < 0) { - return HDF_FAILURE; + if (SdkInit != nullptr) { + SdkInit = nullptr; } - ret = InitDevDesc(devDesc, renderPort.portId, pins); - if (ret < 0) { - return HDF_FAILURE; + if (SdkExit != nullptr) { + SdkExit = nullptr; } - ret = adapter->CreateRender(adapter, &devDesc, &attrs, render); - if (ret < 0 || *render == nullptr) { - manager.UnloadAdapter(&manager, adapter); - return HDF_FAILURE; +#endif + if (GetAudioManager != nullptr) { + GetAudioManager = nullptr; } - return HDF_SUCCESS; } -int32_t AudioHdiCaptureControlTest::AudioCaptureStart(const string path, struct AudioCapture *capture) const -{ - int32_t ret = -1; - struct AudioSampleAttributes attrs = {}; +void AudioHdiCaptureControlTest::SetUp(void) {} - ret = InitAttrs(attrs); - if (ret < 0) { - return HDF_FAILURE; - } - FILE *file = fopen(path.c_str(), "wb+"); - if (file == nullptr) { - return HDF_FAILURE; - } - ret = FrameStartCapture(capture, file, attrs); - if (ret < 0) { - fclose(file); - return HDF_FAILURE; - } - fclose(file); - return HDF_SUCCESS; -} +void AudioHdiCaptureControlTest::TearDown(void) {} /** * @tc.name Test AudioCreateCapture API via legal input @@ -201,23 +129,55 @@ int32_t AudioHdiCaptureControlTest::AudioCaptureStart(const string path, struct HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; enum AudioPortPin pins = PIN_IN_MIC; struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; + TestAudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + ret = AudioCreateCapture(manager, pins, ADAPTER_NAME_USB, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCreateCapture API via creating a capture object when a render object was created +* @tc.number SUB_Audio_HDI_AudioCreateCapture_0002 +* @tc.desc test AudioCreateCapture interface: + (1)service mode:Returns 0,if the AudioCapture object can be created successfully which was created + (2)passthrough mode: Returns -1,if the AudioCapture object can't be created which was created +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0002, TestSize.Level1) +{ + int32_t ret = -1; + enum AudioPortDirection portType = PORT_OUT_IN; + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *firstCapture = nullptr; + struct AudioCapture *secondCapture = nullptr; + struct AudioPort audioPort = {}; + struct AudioSampleAttributes attrs = {}; + struct AudioDeviceDescriptor DevDesc = {}; + + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME_USB, &adapter, audioPort); + ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrs(attrs); + InitDevDesc(DevDesc, audioPort.portId, PIN_IN_MIC); + ret = adapter->CreateCapture(adapter, &DevDesc, &attrs, &firstCapture); if (ret < 0) { manager.UnloadAdapter(&manager, adapter); ASSERT_EQ(HDF_SUCCESS, ret); } + ret = adapter->CreateCapture(adapter, &DevDesc, &attrs, &secondCapture); +#if defined (AUDIO_ADM_SERVICE) || defined (AUDIO_MPI_SERVICE) EXPECT_EQ(HDF_SUCCESS, ret); - adapter->DestroyCapture(adapter, capture); + adapter->DestroyCapture(adapter, secondCapture); +#endif +#if defined (AUDIO_ADM_SO) || defined (AUDIO_MPI_SO) || defined (__LITEOS__) + EXPECT_EQ(HDF_FAILURE, ret); + adapter->DestroyCapture(adapter, firstCapture); +#endif manager.UnloadAdapter(&manager, adapter); } /** @@ -229,24 +189,28 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0001, Test HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0003, TestSize.Level1) { int32_t ret = -1; - struct AudioPort audioPort = {}; enum AudioPortDirection portType = PORT_OUT_IN; - enum AudioPortPin pinsRender = PIN_OUT_SPEAKER; - enum AudioPortPin pinsCapture = PIN_IN_MIC; struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; struct AudioCapture *capture = nullptr; + struct AudioPort audioPort = {}; + struct AudioSampleAttributes attrs = {}; + struct AudioDeviceDescriptor renderDevDesc = {}; + struct AudioDeviceDescriptor captureDevDesc = {}; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, audioPort); + TestAudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME_USB, &adapter, audioPort); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(pinsRender, manager, adapter, audioPort, &render); + InitAttrs(attrs); + InitDevDesc(renderDevDesc, audioPort.portId, PIN_OUT_SPEAKER); + InitDevDesc(captureDevDesc, audioPort.portId, PIN_IN_MIC); + ret = adapter->CreateRender(adapter, &renderDevDesc, &attrs, &render); if (ret < 0) { manager.UnloadAdapter(&manager, adapter); ASSERT_EQ(HDF_SUCCESS, ret); } - ret = AudioCreateCapture(pinsCapture, manager, audioPort, adapter, &capture); + ret = adapter->CreateCapture(adapter, &captureDevDesc, &attrs, &capture); if (ret < 0) { adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); @@ -265,9 +229,6 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0003, Test HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0004, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePortFirst = {}; - struct AudioPort capturePortSecond = {}; - enum AudioPortDirection portType = PORT_IN; enum AudioPortPin pins = PIN_IN_MIC; struct AudioAdapter *adapterFirst = nullptr; struct AudioAdapter *adapterSecond = nullptr; @@ -275,25 +236,13 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0004, Test struct AudioCapture *captureSecond = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapterFirst, capturePortFirst); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, pins, ADAPTER_NAME_USB, &adapterFirst, &captureFirst); ASSERT_EQ(HDF_SUCCESS, ret); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME3, &adapterSecond, capturePortSecond); - if (ret < 0){ - manager.UnloadAdapter(&manager, adapterFirst); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioCreateCapture(pins, manager, capturePortFirst, adapterFirst, &captureFirst); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapterFirst); - manager.UnloadAdapter(&manager, adapterSecond); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioCreateCapture(pins, manager, capturePortSecond, adapterSecond, &captureSecond); + ret = AudioCreateCapture(manager, pins, ADAPTER_NAME_INTERNAL, &adapterSecond, &captureSecond); if (ret < 0) { adapterFirst->DestroyCapture(adapterFirst, captureFirst); manager.UnloadAdapter(&manager, adapterFirst); - manager.UnloadAdapter(&manager, adapterSecond); ASSERT_EQ(HDF_SUCCESS, ret); } adapterFirst->DestroyCapture(adapterFirst, captureFirst); @@ -320,8 +269,8 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0005, Test struct AudioCapture *capture = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME_USB, &adapter, capturePort); ASSERT_EQ(HDF_SUCCESS, ret); ret = InitAttrs(attrs); EXPECT_EQ(HDF_SUCCESS, ret); @@ -349,8 +298,8 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0006, Test struct AudioCapture *capture = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME_USB, &adapter, capturePort); ASSERT_EQ(HDF_SUCCESS, ret); ret = InitAttrs(attrs); EXPECT_EQ(HDF_SUCCESS, ret); @@ -377,8 +326,8 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0007, Test struct AudioCapture *capture = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME_USB, &adapter, capturePort); ASSERT_EQ(HDF_SUCCESS, ret); ret = InitDevDesc(devDesc, capturePort.portId, pins); EXPECT_EQ(HDF_SUCCESS, ret); @@ -405,8 +354,8 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0008, Test struct AudioCapture **capture = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME_USB, &adapter, capturePort); ASSERT_EQ(HDF_SUCCESS, ret); ret = InitAttrs(attrs); EXPECT_EQ(HDF_SUCCESS, ret); @@ -434,8 +383,8 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0009, Test struct AudioCapture *capture = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME_HDMI, &adapter, capturePort); ASSERT_EQ(HDF_SUCCESS, ret); ret = InitAttrs(attrs); EXPECT_EQ(HDF_SUCCESS, ret); @@ -455,21 +404,14 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0009, Test HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioDestroyCapture_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; enum AudioPortPin pins = PIN_IN_MIC; struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; + TestAudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + ret = AudioCreateCapture(manager, pins, ADAPTER_NAME_USB, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - }; ret = adapter->DestroyCapture(adapter, capture); EXPECT_EQ(HDF_SUCCESS, ret); manager.UnloadAdapter(&manager, adapter); @@ -483,22 +425,15 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioDestroyCapture_0001, Tes HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioDestroyCapture_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; enum AudioPortPin pins = PIN_IN_MIC; struct AudioAdapter *adapter = nullptr; struct AudioAdapter *adapterNull = nullptr; struct AudioCapture *capture = nullptr; + TestAudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + ret = AudioCreateCapture(manager, pins, ADAPTER_NAME_USB, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = adapter->DestroyCapture(adapterNull, capture); EXPECT_EQ(HDF_FAILURE, ret); ret = adapter->DestroyCapture(adapter, capture); @@ -520,8 +455,8 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioDestroyCapture_0003, Tes struct AudioCapture *capture = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME_USB, &adapter, capturePort); ASSERT_EQ(HDF_SUCCESS, ret); ret = adapter->DestroyCapture(adapter, capture); EXPECT_EQ(HDF_FAILURE, ret); @@ -536,24 +471,15 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioDestroyCapture_0003, Tes HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStart_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; + TestAudioManager manager = {}; enum AudioPortPin pins = PIN_IN_MIC; struct AudioAdapter *adapter = nullptr; - struct AudioPort capturePort = {}; struct AudioCapture *capture = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME3, &adapter, capturePort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateCapture(manager, pins, ADAPTER_NAME_USB, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = capture->control.Start((AudioHandle)capture); EXPECT_EQ(HDF_SUCCESS, ret); @@ -570,24 +496,16 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStart_0001, TestSize.L HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStart_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; + TestAudioManager manager = {}; enum AudioPortPin pins = PIN_IN_MIC; struct AudioAdapter *adapter = nullptr; - struct AudioPort capturePort = {}; struct AudioCapture *capture = nullptr; struct AudioCapture *captureNull = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME3, &adapter, capturePort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateCapture(manager, pins, ADAPTER_NAME_USB, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = capture->control.Start((AudioHandle)captureNull); EXPECT_EQ(HDF_FAILURE, ret); @@ -604,26 +522,17 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStart_0002, TestSize.L HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStart_0003, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; + TestAudioManager manager = {}; enum AudioPortPin pins = PIN_IN_MIC; struct AudioAdapter *adapter = nullptr; - struct AudioPort capturePort = {}; struct AudioCapture *capture = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME3, &adapter, capturePort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateCapture(manager, pins, ADAPTER_NAME_USB, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = capture->control.Start((AudioHandle)capture); EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->control.Start((AudioHandle)capture); EXPECT_EQ(HDF_FAILURE, ret); @@ -640,24 +549,14 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStart_0003, TestSize.L HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStop_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - enum AudioPortPin pins = PIN_IN_MIC; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort capturePort = {}; struct AudioCapture *capture = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME3, &adapter, capturePort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->control.Stop((AudioHandle)capture); EXPECT_EQ(HDF_SUCCESS, ret); @@ -673,26 +572,14 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStop_0001, TestSize.Le HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStop_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - enum AudioPortPin pins = PIN_IN_MIC; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort capturePort = {}; struct AudioCapture *capture = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME3, &adapter, capturePort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->control.Stop((AudioHandle)capture); EXPECT_EQ(HDF_SUCCESS, ret); ret = capture->control.Stop((AudioHandle)capture); @@ -710,29 +597,16 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStop_0002, TestSize.Le HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStop_0003, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - enum AudioPortPin pins = PIN_IN_MIC; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort capturePort = {}; struct AudioCapture *capture = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME3, &adapter, capturePort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->control.Stop((AudioHandle)capture); EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->control.Start((AudioHandle)capture); EXPECT_EQ(HDF_SUCCESS, ret); @@ -749,28 +623,45 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStop_0003, TestSize.Le HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStop_0004, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; + TestAudioManager manager = {}; enum AudioPortPin pins = PIN_IN_MIC; struct AudioAdapter *adapter = nullptr; - struct AudioPort capturePort = {}; struct AudioCapture *capture = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME3, &adapter, capturePort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateCapture(manager, pins, ADAPTER_NAME_USB, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = capture->control.Stop((AudioHandle)capture); EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret); adapter->DestroyCapture(adapter, capture); manager.UnloadAdapter(&manager, adapter); } +/** +* @tc.name Test CaptureStop API via setting the incoming parameter handle is nullptr +* @tc.number SUB_Audio_HDI_CaptureStop_0005 +* @tc.desc Test CaptureStop interface, return -1 if the incoming parameter handle is nullptr +* @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStop_0005, TestSize.Level1) +{ + int32_t ret = -1; + TestAudioManager manager = {}; + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + struct AudioCapture *captureNull = nullptr; + + manager = *GetAudioManager(); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = capture->control.Stop((AudioHandle)captureNull); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} /** * @tc.name Test CapturePause API via legal input * @tc.number SUB_Audio_HDI_CapturePause_0001 @@ -780,23 +671,14 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStop_0004, TestSize.Le HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CapturePause_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - enum AudioPortPin pins = PIN_IN_MIC; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort capturePort = {}; struct AudioCapture *capture = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME3, &adapter, capturePort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); - EXPECT_EQ(HDF_SUCCESS, ret); ret = capture->control.Pause((AudioHandle)capture); EXPECT_EQ(HDF_SUCCESS, ret); @@ -814,26 +696,16 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CapturePause_0001, TestSize.L HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CapturePause_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - enum AudioPortPin pins = PIN_IN_MIC; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort capturePort = {}; struct AudioCapture *capture = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME3, &adapter, capturePort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); - EXPECT_EQ(HDF_SUCCESS, ret); ret = capture->control.Pause((AudioHandle)capture); EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->control.Pause((AudioHandle)capture); EXPECT_EQ(HDF_FAILURE, ret); @@ -851,25 +723,15 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CapturePause_0002, TestSize.L HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CapturePause_0003, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - enum AudioPortPin pins = PIN_IN_MIC; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort capturePort = {}; struct AudioCapture *capture = nullptr; struct AudioCapture *captureNull = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME3, &adapter, capturePort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->control.Pause((AudioHandle)captureNull); EXPECT_EQ(HDF_FAILURE, ret); @@ -887,22 +749,15 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CapturePause_0003, TestSize.L HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CapturePause_0004, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; + TestAudioManager manager = {}; enum AudioPortPin pins = PIN_IN_MIC; struct AudioAdapter *adapter = nullptr; - struct AudioPort capturePort = {}; struct AudioCapture *capture = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME3, &adapter, capturePort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateCapture(manager, pins, ADAPTER_NAME_USB, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = capture->control.Pause((AudioHandle)capture); EXPECT_EQ(HDF_FAILURE, ret); @@ -918,26 +773,16 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CapturePause_0004, TestSize.L HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CapturePause_0005, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - enum AudioPortPin pins = PIN_IN_MIC; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort capturePort = {}; struct AudioCapture *capture = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); + ASSERT_NE(nullptr, GetAudioManager); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME3, &adapter, capturePort); + ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); - EXPECT_EQ(HDF_SUCCESS, ret); ret = capture->control.Stop((AudioHandle)capture); EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->control.Pause((AudioHandle)capture); EXPECT_EQ(HDF_FAILURE, ret); @@ -953,23 +798,14 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CapturePause_0005, TestSize.L HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - enum AudioPortPin pins = PIN_IN_MIC; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort capturePort = {}; struct AudioCapture *capture = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME3, &adapter, capturePort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); - EXPECT_EQ(HDF_SUCCESS, ret); ret = capture->control.Pause((AudioHandle)capture); EXPECT_EQ(HDF_SUCCESS, ret); ret = capture->control.Resume((AudioHandle)capture); @@ -988,28 +824,18 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0001, TestSize. HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - enum AudioPortPin pins = PIN_IN_MIC; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort capturePort = {}; struct AudioCapture *capture = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME3, &adapter, capturePort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); - EXPECT_EQ(HDF_SUCCESS, ret); ret = capture->control.Pause((AudioHandle)capture); EXPECT_EQ(HDF_SUCCESS, ret); ret = capture->control.Resume((AudioHandle)capture); EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->control.Resume((AudioHandle)capture); EXPECT_EQ(HDF_FAILURE, ret); @@ -1018,6 +844,7 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0002, TestSize. adapter->DestroyCapture(adapter, capture); manager.UnloadAdapter(&manager, adapter); } + /** * @tc.name Test CaptureResume API via the capture is resumed after started * @tc.number SUB_Audio_HDI_CaptureResume_0003 @@ -1027,24 +854,14 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0002, TestSize. HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0003, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - enum AudioPortPin pins = PIN_IN_MIC; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort capturePort = {}; struct AudioCapture *capture = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME3, &adapter, capturePort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->control.Resume((AudioHandle)capture); EXPECT_EQ(HDF_FAILURE, ret); @@ -1062,27 +879,17 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0003, TestSize. HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0004, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - enum AudioPortPin pins = PIN_IN_MIC; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort capturePort = {}; struct AudioCapture *capture = nullptr; struct AudioCapture *captureNull = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME3, &adapter, capturePort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); - EXPECT_EQ(HDF_SUCCESS, ret); ret = capture->control.Pause((AudioHandle)capture); EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->control.Resume((AudioHandle)captureNull); EXPECT_EQ(HDF_FAILURE, ret); @@ -1100,26 +907,16 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0004, TestSize. HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0005, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - enum AudioPortPin pins = PIN_IN_MIC; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort capturePort = {}; struct AudioCapture *capture = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME3, &adapter, capturePort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); - EXPECT_EQ(HDF_SUCCESS, ret); ret = capture->control.Stop((AudioHandle)capture); EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->control.Resume((AudioHandle)capture); EXPECT_EQ(HDF_FAILURE, ret); @@ -1135,29 +932,19 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0005, TestSize. HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0006, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - enum AudioPortPin pins = PIN_IN_MIC; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort capturePort = {}; struct AudioCapture *capture = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME3, &adapter, capturePort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); - EXPECT_EQ(HDF_SUCCESS, ret); ret = capture->control.Pause((AudioHandle)capture); EXPECT_EQ(HDF_SUCCESS, ret); ret = capture->control.Resume((AudioHandle)capture); EXPECT_EQ(HDF_SUCCESS, ret); - - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); + ret = capture->control.Start((AudioHandle)capture); EXPECT_EQ(HDF_FAILURE, ret); capture->control.Stop((AudioHandle)capture); @@ -1172,51 +959,34 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0006, TestSize. */ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0007, TestSize.Level1) { - struct AudioManager manager = {}; + int32_t ret1 = -1; + int32_t ret2 = -1; + TestAudioManager manager = {}; struct AudioAdapter *adapterOne = nullptr; struct AudioAdapter *adapterSec = nullptr; - struct AudioPort capturePortOne = {}; - struct AudioPort capturePortSec = {}; struct AudioCapture *captureOne = nullptr; struct AudioCapture *captureSec = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - int32_t ret1 = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME2, &adapterOne, capturePortOne); + ASSERT_NE(nullptr, GetAudioManager); + ret1 = AudioCreateStartCapture(manager, &captureOne, &adapterOne, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret1); - int32_t ret2 = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME3, &adapterSec, capturePortSec); - ASSERT_EQ(HDF_SUCCESS, ret2); - ret1 = AudioCreateCapture(PIN_IN_MIC, manager, capturePortOne, adapterOne, &captureOne); - if (ret1 < 0) { - manager.UnloadAdapter(&manager, adapterOne); - manager.UnloadAdapter(&manager, adapterSec); - ASSERT_EQ(HDF_SUCCESS, ret1); - } - ret2 = AudioCreateCapture(PIN_IN_MIC, manager, capturePortSec, adapterSec, &captureSec); - if (ret2 < 0) { - adapterOne->DestroyCapture(adapterOne, captureOne); - manager.UnloadAdapter(&manager, adapterOne); - manager.UnloadAdapter(&manager, adapterSec); - ASSERT_EQ(HDF_SUCCESS, ret2); - } - ret1 = AudioCaptureStart(AUDIO_CAPTURE_FILE, captureOne); - EXPECT_EQ(HDF_SUCCESS, ret1); - ret2 = AudioCaptureStart(AUDIO_CAPTURE_FILE, captureSec); - EXPECT_EQ(HDF_SUCCESS, ret2); ret1 = captureOne->control.Pause((AudioHandle)captureOne); EXPECT_EQ(HDF_SUCCESS, ret1); - ret2 = captureSec->control.Pause((AudioHandle)captureSec); - EXPECT_EQ(HDF_SUCCESS, ret2); ret1 = captureOne->control.Resume((AudioHandle)captureOne); EXPECT_EQ(HDF_SUCCESS, ret1); - ret2 = captureSec->control.Resume((AudioHandle)captureSec); - EXPECT_EQ(HDF_SUCCESS, ret2); ret1 = captureOne->control.Stop((AudioHandle)captureOne); EXPECT_EQ(HDF_SUCCESS, ret1); + adapterOne->DestroyCapture(adapterOne, captureOne); + manager.UnloadAdapter(&manager, adapterOne); + ret2 = AudioCreateStartCapture(manager, &captureSec, &adapterSec, ADAPTER_NAME_USB); + ASSERT_EQ(HDF_SUCCESS, ret2); + ret2 = captureSec->control.Pause((AudioHandle)captureSec); + EXPECT_EQ(HDF_SUCCESS, ret2); + ret2 = captureSec->control.Resume((AudioHandle)captureSec); + EXPECT_EQ(HDF_SUCCESS, ret2); ret2 = captureSec->control.Stop((AudioHandle)captureSec); EXPECT_EQ(HDF_SUCCESS, ret2); - adapterOne->DestroyCapture(adapterOne, captureOne); adapterSec->DestroyCapture(adapterSec, captureSec); - manager.UnloadAdapter(&manager, adapterOne); manager.UnloadAdapter(&manager, adapterSec); } /** @@ -1228,26 +998,16 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0007, TestSize. HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureFlush_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - enum AudioPortPin pins = PIN_IN_MIC; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort capturePort = {}; struct AudioCapture *capture = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME3, &adapter, capturePort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); - EXPECT_EQ(HDF_SUCCESS, ret); ret = capture->control.Stop((AudioHandle)capture); EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->control.Flush((AudioHandle)capture); EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); @@ -1263,27 +1023,17 @@ HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureFlush_0001, TestSize.L HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureFlush_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - enum AudioPortPin pins = PIN_IN_MIC; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort capturePort = {}; struct AudioCapture *capture = nullptr; struct AudioCapture *captureNull = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME3, &adapter, capturePort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); - EXPECT_EQ(HDF_SUCCESS, ret); ret = capture->control.Stop((AudioHandle)capture); EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->control.Flush((AudioHandle)captureNull); EXPECT_EQ(HDF_FAILURE, ret); diff --git a/audio/test/systemtest/hdi/capture/src/audio_hdicapture_scene_test.cpp b/audio/test/systemtest/hdi/capture/src/audio_hdicapture_scene_test.cpp index 7ecfdc29d3..cfa0474295 100755 --- a/audio/test/systemtest/hdi/capture/src/audio_hdicapture_scene_test.cpp +++ b/audio/test/systemtest/hdi/capture/src/audio_hdicapture_scene_test.cpp @@ -17,7 +17,7 @@ * @addtogroup Audio * @{ * - * @brief Defines audio-related APIs, including custom data types and functions for capture drivers funtion. + * @brief Defines audio-related APIs, including custom data types and functions for capture drivers function. * accessing a driver adapter, and capturing audios. * * @since 1.0 @@ -41,10 +41,9 @@ using namespace testing::ext; using namespace HMOS::Audio; namespace { -const string AUDIO_CAPTURE_FILE = "//bin/audiocapturetest.wav"; -const string ADAPTER_NAME = "hdmi"; -const string ADAPTER_NAME2 = "usb"; -const string ADAPTER_NAME3 = "internal"; +const string ADAPTER_NAME_HDMI = "hdmi"; +const string ADAPTER_NAME_USB = "usb"; +const string ADAPTER_NAME_INTERNAL = "internal"; class AudioHdiCaptureSceneTest : public testing::Test { public: @@ -52,97 +51,71 @@ public: static void TearDownTestCase(void); void SetUp(); void TearDown(); - struct AudioManager *(*GetAudioManager)() = nullptr; - void *handleSo = nullptr; - int32_t GetLoadAdapter(struct AudioManager manager, enum AudioPortDirection portType, - const string adapterName, struct AudioAdapter **adapter, struct AudioPort& audioPort) const; - int32_t AudioCreateCapture(enum AudioPortPin pins, struct AudioManager manager, - struct AudioPort capturePort, struct AudioAdapter *adapter, - struct AudioCapture **capture) const; + static TestAudioManager *(*GetAudioManager)(); + static void *handleSo; +#ifdef AUDIO_MPI_SO + static int32_t (*SdkInit)(); + static void (*SdkExit)(); + static void *sdkSo; +#endif int32_t AudioCaptureStart(const string path, struct AudioCapture *capture) const; }; -void AudioHdiCaptureSceneTest::SetUpTestCase(void) {} +TestAudioManager *(*AudioHdiCaptureSceneTest::GetAudioManager)() = nullptr; +void *AudioHdiCaptureSceneTest::handleSo = nullptr; +#ifdef AUDIO_MPI_SO + int32_t (*AudioHdiCaptureSceneTest::SdkInit)() = nullptr; + void (*AudioHdiCaptureSceneTest::SdkExit)() = nullptr; + void *AudioHdiCaptureSceneTest::sdkSo = nullptr; +#endif -void AudioHdiCaptureSceneTest::TearDownTestCase(void) {} - -void AudioHdiCaptureSceneTest::SetUp(void) +void AudioHdiCaptureSceneTest::SetUpTestCase(void) { - char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; - handleSo = dlopen(resolvedPath, RTLD_LAZY); - if (handleSo == nullptr) { +#ifdef AUDIO_MPI_SO + char sdkResolvedPath[] = "//system/lib/libhdi_audio_interface_lib_render.z.so"; + sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY); + if (sdkSo == nullptr) { return; } - GetAudioManager = (struct AudioManager *(*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); - if (GetAudioManager == nullptr) { + SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit")); + if (SdkInit == nullptr) { return; } -} - -void AudioHdiCaptureSceneTest::TearDown(void) -{ - if (GetAudioManager != nullptr) { - GetAudioManager = nullptr; - } -} - -int32_t AudioHdiCaptureSceneTest::GetLoadAdapter(struct AudioManager manager, enum AudioPortDirection portType, - const string adapterName, struct AudioAdapter **adapter, struct AudioPort& audioPort) const -{ - int32_t ret = -1; - int size = 0; - struct AudioAdapterDescriptor *desc = nullptr; - struct AudioAdapterDescriptor *descs = nullptr; - if (adapter == nullptr) { - return HDF_FAILURE; - } - ret = manager.GetAllAdapters(&manager, &descs, &size); - if (ret < 0 || descs == nullptr || size == 0) { - return HDF_FAILURE; - } else { - int index = SwitchAdapter(descs, adapterName, portType, audioPort, size); - if (index < 0) { - return HDF_FAILURE; - } else { - desc = &descs[index]; - } + SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit")); + if (SdkExit == nullptr) { + return; } - if (desc == nullptr) { - return HDF_FAILURE; - } else { - ret = manager.LoadAdapter(&manager, desc, adapter); + SdkInit(); +#endif + handleSo = dlopen(RESOLVED_PATH.c_str(), RTLD_LAZY); + if (handleSo == nullptr) { + return; } - if (ret < 0 || adapter == nullptr) { - return HDF_FAILURE; + GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str())); + if (GetAudioManager == nullptr) { + return; } - return HDF_SUCCESS; } -int32_t AudioHdiCaptureSceneTest::AudioCreateCapture(enum AudioPortPin pins, struct AudioManager manager, - struct AudioPort capturePort, struct AudioAdapter *adapter, struct AudioCapture **capture) const +void AudioHdiCaptureSceneTest::TearDownTestCase(void) { - int32_t ret = -1; - struct AudioSampleAttributes attrs = {}; - struct AudioDeviceDescriptor devDesc = {}; - if (adapter == nullptr || adapter->CreateCapture == nullptr || capture == nullptr) { - return HDF_FAILURE; +#ifdef AUDIO_MPI_SO + SdkExit(); + if (sdkSo != nullptr) { + dlclose(sdkSo); + sdkSo = nullptr; } - ret = InitAttrs(attrs); - if (ret < 0) { - return HDF_FAILURE; + if (SdkInit != nullptr) { + SdkInit = nullptr; } - ret = InitDevDesc(devDesc, capturePort.portId, pins); - if (ret < 0) { - return HDF_FAILURE; + if (SdkExit != nullptr) { + SdkExit = nullptr; } - ret = adapter->CreateCapture(adapter, &devDesc, &attrs, capture); - if (ret < 0 || *capture == nullptr) { - manager.UnloadAdapter(&manager, adapter); - return HDF_FAILURE; +#endif + if (GetAudioManager != nullptr) { + GetAudioManager = nullptr; } - return HDF_SUCCESS; } - int32_t AudioHdiCaptureSceneTest::AudioCaptureStart(const string path, struct AudioCapture *capture) const { int32_t ret = -1; @@ -164,6 +137,8 @@ int32_t AudioHdiCaptureSceneTest::AudioCaptureStart(const string path, struct Au fclose(file); return HDF_SUCCESS; } +void AudioHdiCaptureSceneTest::SetUp(void) {} +void AudioHdiCaptureSceneTest::TearDown(void) {} /** * @tc.name Test AudioCaptureCheckSceneCapability API and check scene's capability @@ -175,24 +150,13 @@ HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_CaptureCheckSceneCapability_000 { int32_t ret = -1; bool supported = false; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; + struct AudioSceneDescriptor scenes = {}; struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioSceneDescriptor scenes = {}; - - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } scenes.scene.id = 0; scenes.desc.pins = PIN_IN_MIC; ret = capture->scene.CheckSceneCapability(capture, &scenes, &supported); @@ -203,33 +167,22 @@ HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_CaptureCheckSceneCapability_000 manager.UnloadAdapter(&manager, adapter); } /** -* @tc.name Test checking scene's capability where the scene is not configed in the josn. +* @tc.name Test checking scene's capability where the scene is not configured in the json. * @tc.number SUB_Audio_HDI_CaptureCheckSceneCapability_0002 -* @tc.desc Test AudioCreateCapture interface,return -1 if the scene is not configed in the josn. +* @tc.desc Test AudioCreateCapture interface,return -1 if the scene is not configured in the json. * @tc.author: ZHANGHAILIN */ HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_CaptureCheckSceneCapability_0002, TestSize.Level1) { int32_t ret = -1; bool supported = true; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; + struct AudioSceneDescriptor scenes = {}; struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioSceneDescriptor scenes = {}; - - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } scenes.scene.id = 5; scenes.desc.pins = PIN_IN_MIC; ret = capture->scene.CheckSceneCapability(capture, &scenes, &supported); @@ -248,25 +201,14 @@ HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_CaptureCheckSceneCapability_000 { int32_t ret = -1; bool supported = true; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; + struct AudioSceneDescriptor scenes = {}; struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; struct AudioCapture *captureNull = nullptr; - struct AudioSceneDescriptor scenes = {}; - - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } scenes.scene.id = 0; scenes.desc.pins = PIN_IN_MIC; ret = capture->scene.CheckSceneCapability(captureNull, &scenes, &supported); @@ -289,25 +231,14 @@ HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_CaptureCheckSceneCapability_000 { int32_t ret = -1; bool supported = true; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; + struct AudioSceneDescriptor *scenes = nullptr; struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioSceneDescriptor *scenes = nullptr; - - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = capture->scene.CheckSceneCapability(capture, scenes, &supported); EXPECT_EQ(HDF_FAILURE, ret); @@ -327,33 +258,19 @@ HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_CaptureCheckSceneCapability_000 HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_CaptureCheckSceneCapability_0005, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; + struct AudioSceneDescriptor scenes = {}; struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioSceneDescriptor scenes = {}; - - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } scenes.scene.id = 0; scenes.desc.pins = PIN_IN_MIC; ret = capture->scene.CheckSceneCapability(capture, &scenes, nullptr); EXPECT_EQ(HDF_FAILURE, ret); - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); - EXPECT_EQ(HDF_SUCCESS, ret); - - capture->control.Stop((AudioHandle)capture); adapter->DestroyCapture(adapter, capture); manager.UnloadAdapter(&manager, adapter); } @@ -366,24 +283,13 @@ HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_CaptureCheckSceneCapability_000 HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_AudioCaptureSelectScene_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; + struct AudioSceneDescriptor scenes = {}; struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioSceneDescriptor scenes = {}; - - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } scenes.scene.id = 0; scenes.desc.pins = PIN_IN_MIC; ret = capture->scene.SelectScene(capture, &scenes); @@ -401,25 +307,14 @@ HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_AudioCaptureSelectScene_0001, T HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_AudioCaptureSelectScene_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; + struct AudioSceneDescriptor scenes = {}; struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioSceneDescriptor scenes = {}; - - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); EXPECT_EQ(HDF_SUCCESS, ret); @@ -441,25 +336,15 @@ HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_AudioCaptureSelectScene_0002, T HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_AudioCaptureSelectScene_0003, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; + struct AudioSceneDescriptor scenes = {}; struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; struct AudioCapture *captureNull = nullptr; - struct AudioSceneDescriptor scenes = {}; - - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } scenes.scene.id = 0; scenes.desc.pins = PIN_IN_MIC; ret = capture->scene.SelectScene(captureNull, &scenes); @@ -477,25 +362,14 @@ HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_AudioCaptureSelectScene_0003, T HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_AudioCaptureSelectScene_0004, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; + struct AudioSceneDescriptor *scenes = nullptr; struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioSceneDescriptor *scenes = nullptr; - - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = capture->scene.SelectScene(capture, scenes); EXPECT_EQ(HDF_FAILURE, ret); @@ -503,32 +377,22 @@ HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_AudioCaptureSelectScene_0004, T manager.UnloadAdapter(&manager, adapter); } /** -* @tc.name Test AudioCaptureSelectScene API where the scene is not configed in the josn. +* @tc.name Test AudioCaptureSelectScene API where the scene is not configured in the json. * @tc.number SUB_Audio_HDI_AudioCaptureSelectScene_0005 -* @tc.desc Test AudioCaptureSelectScene, return -1 if the scene is not configed in the josn. +* @tc.desc Test AudioCaptureSelectScene, return -1 if the scene is not configured in the json. * @tc.author: ZHANGHAILIN */ HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_AudioCaptureSelectScene_0005, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; + struct AudioSceneDescriptor scenes = {}; struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioSceneDescriptor scenes = {}; - - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } scenes.scene.id = 5; scenes.desc.pins = PIN_OUT_HDMI; ret = capture->scene.SelectScene(capture, &scenes); diff --git a/audio/test/systemtest/hdi/capture/src/audio_hdicapture_test.cpp b/audio/test/systemtest/hdi/capture/src/audio_hdicapture_test.cpp index c09f54a732..7c25cd2dfb 100755 --- a/audio/test/systemtest/hdi/capture/src/audio_hdicapture_test.cpp +++ b/audio/test/systemtest/hdi/capture/src/audio_hdicapture_test.cpp @@ -41,14 +41,12 @@ using namespace testing::ext; using namespace HMOS::Audio; namespace { -const string AUDIO_CAPTURE_FILE = "//bin/audiocapturetest.wav"; -const string ADAPTER_NAME = "hdmi"; -const string ADAPTER_NAME2 = "usb"; -const string ADAPTER_NAME3 = "internal"; +const string ADAPTER_NAME_HDMI = "hdmi"; +const string ADAPTER_NAME_USB = "usb"; +const string ADAPTER_NAME_INTERNAL = "internal"; const int BUFFER_SIZE = 16384; const int BUFFER_SIZE_LITTLE = 0; -const uint64_t FILESIZE = 2048; -const int64_t SECTONSEC = 1000000000; +const uint64_t FILESIZE = 1024; class AudioHdiCaptureTest : public testing::Test { public: @@ -56,144 +54,80 @@ public: static void TearDownTestCase(void); void SetUp(); void TearDown(); - struct AudioManager *(*GetAudioManager)() = nullptr; - void *handleSo = nullptr; - int32_t GetLoadAdapter(struct AudioManager manager, enum AudioPortDirection portType, - const string adapterName, struct AudioAdapter **adapter, struct AudioPort& audioPort) const; - int32_t AudioCreateCapture(enum AudioPortPin pins, struct AudioManager manager, - struct AudioPort capturePort, struct AudioAdapter *adapter, - struct AudioCapture **capture) const; - int32_t AudioCaptureStart(const string path, struct AudioCapture *capture) const; + static TestAudioManager *(*GetAudioManager)(); + static void *handleSo; +#ifdef AUDIO_MPI_SO + static int32_t (*SdkInit)(); + static void (*SdkExit)(); + static void *sdkSo; +#endif + static int32_t GetLoadAdapterAudioPara(struct PrepareAudioPara& audiopara); - static int32_t RecordAudio(struct PrepareAudioPara& audiopara); }; using THREAD_FUNC = void *(*)(void *); -void AudioHdiCaptureTest::SetUpTestCase(void) {} - -void AudioHdiCaptureTest::TearDownTestCase(void) {} +TestAudioManager *(*AudioHdiCaptureTest::GetAudioManager)() = nullptr; +void *AudioHdiCaptureTest::handleSo = nullptr; +#ifdef AUDIO_MPI_SO + int32_t (*AudioHdiCaptureTest::SdkInit)() = nullptr; + void (*AudioHdiCaptureTest::SdkExit)() = nullptr; + void *AudioHdiCaptureTest::sdkSo = nullptr; +#endif -void AudioHdiCaptureTest::SetUp(void) +void AudioHdiCaptureTest::SetUpTestCase(void) { - char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; - handleSo = dlopen(resolvedPath, RTLD_LAZY); - if (handleSo == nullptr) { +#ifdef AUDIO_MPI_SO + char sdkResolvedPath[] = "//system/lib/libhdi_audio_interface_lib_render.z.so"; + sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY); + if (sdkSo == nullptr) { return; } - GetAudioManager = (struct AudioManager *(*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); - if (GetAudioManager == nullptr) { + SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit")); + if (SdkInit == nullptr) { return; } -} - -void AudioHdiCaptureTest::TearDown(void) -{ - // step 2: input testsuit teardown step - if (GetAudioManager != nullptr) { - GetAudioManager = nullptr; - } -} - -int32_t AudioHdiCaptureTest::GetLoadAdapter(struct AudioManager manager, enum AudioPortDirection portType, - const string adapterName, struct AudioAdapter **adapter, struct AudioPort& audioPort) const -{ - int32_t ret = -1; - int size = 0; - struct AudioAdapterDescriptor *desc = nullptr; - struct AudioAdapterDescriptor *descs = nullptr; - if (adapter == nullptr) { - return HDF_FAILURE; - } - ret = manager.GetAllAdapters(&manager, &descs, &size); - if (ret < 0 || descs == nullptr || size == 0) { - return HDF_FAILURE; - } else { - int index = SwitchAdapter(descs, adapterName, portType, audioPort, size); - if (index < 0) { - return HDF_FAILURE; - } else { - desc = &descs[index]; - } + SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit")); + if (SdkExit == nullptr) { + return; } - if (desc == nullptr) { - return HDF_FAILURE; - } else { - ret = manager.LoadAdapter(&manager, desc, adapter); + SdkInit(); +#endif + handleSo = dlopen(RESOLVED_PATH.c_str(), RTLD_LAZY); + if (handleSo == nullptr) { + return; } - if (ret < 0 || adapter == nullptr) { - return HDF_FAILURE; + GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str())); + if (GetAudioManager == nullptr) { + return; } - return HDF_SUCCESS; } -int32_t AudioHdiCaptureTest::AudioCreateCapture(enum AudioPortPin pins, struct AudioManager manager, - struct AudioPort capturePort, struct AudioAdapter *adapter, struct AudioCapture **capture) const +void AudioHdiCaptureTest::TearDownTestCase(void) { - int32_t ret = -1; - struct AudioSampleAttributes attrs = {}; - struct AudioDeviceDescriptor devDesc = {}; - if (adapter == nullptr || capture == nullptr) { - return HDF_FAILURE; +#ifdef AUDIO_MPI_SO + SdkExit(); + if (sdkSo != nullptr) { + dlclose(sdkSo); + sdkSo = nullptr; } - ret = InitAttrs(attrs); - if (ret < 0) { - return HDF_FAILURE; + if (SdkInit != nullptr) { + SdkInit = nullptr; } - ret = InitDevDesc(devDesc, capturePort.portId, pins); - if (ret < 0) { - return HDF_FAILURE; + if (SdkExit != nullptr) { + SdkExit = nullptr; } - ret = adapter->CreateCapture(adapter, &devDesc, &attrs, capture); - if (ret < 0 || *capture == nullptr) { - manager.UnloadAdapter(&manager, adapter); - return HDF_FAILURE; +#endif + if (GetAudioManager != nullptr) { + GetAudioManager = nullptr; } - return HDF_SUCCESS; } -int32_t AudioHdiCaptureTest::AudioCaptureStart(const string path, struct AudioCapture *capture) const -{ - int32_t ret = -1; - struct AudioSampleAttributes attrs = {}; - ret = InitAttrs(attrs); - if (ret < 0) { - return HDF_FAILURE; - } - FILE *file = fopen(path.c_str(), "wb+"); - if (file == nullptr) { - return HDF_FAILURE; - } - ret = FrameStartCapture(capture, file, attrs); - if (ret < 0) { - fclose(file); - return HDF_FAILURE; - } - fclose(file); - return HDF_SUCCESS; -} +void AudioHdiCaptureTest::SetUp(void) {} + +void AudioHdiCaptureTest::TearDown(void) {} -struct PrepareAudioPara { - struct AudioManager *manager; - enum AudioPortDirection portType; - const char *adapterName; - struct AudioAdapter *adapter; - struct AudioPort audioPort; - void *self; - enum AudioPortPin pins; - const char *path; - struct AudioRender *render; - struct AudioCapture *capture; - struct AudioHeadInfo headInfo; - struct AudioAdapterDescriptor *desc; - struct AudioAdapterDescriptor *descs; - char *frame; - uint64_t requestBytes; - uint64_t replyBytes; - uint64_t fileSize; - struct AudioSampleAttributes attrs; -}; int32_t AudioHdiCaptureTest::GetLoadAdapterAudioPara(struct PrepareAudioPara& audiopara) { @@ -229,47 +163,6 @@ int32_t AudioHdiCaptureTest::GetLoadAdapterAudioPara(struct PrepareAudioPara& au return HDF_SUCCESS; } -int32_t AudioHdiCaptureTest::RecordAudio(struct PrepareAudioPara& audiopara) -{ - int32_t ret = -1; - struct AudioDeviceDescriptor devDesc = {}; - if (audiopara.adapter == nullptr || audiopara.manager == nullptr) { - return HDF_FAILURE; - } - ret = InitAttrs(audiopara.attrs); - - ret = InitDevDesc(devDesc, (&audiopara.audioPort)->portId, audiopara.pins); - - ret = audiopara.adapter->CreateCapture(audiopara.adapter, &devDesc, &(audiopara.attrs), &audiopara.capture); - if (ret < 0 || audiopara.capture == nullptr) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - return HDF_FAILURE; - } - bool isMute = false; - ret = audiopara.capture->volume.SetMute(audiopara.capture, isMute); - if (ret < 0) { - audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - return HDF_FAILURE; - } - - FILE *file = fopen(audiopara.path, "wb+"); - if (file == nullptr) { - audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - return HDF_FAILURE; - } - ret = StartRecord(audiopara.capture, file, audiopara.fileSize); - if (ret < 0) { - audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - fclose(file); - return HDF_FAILURE; - } - fclose(file); - return HDF_SUCCESS; -} - /** * @tc.name Test AudioCaptureCaptureFrame API via legal input * @tc.number SUB_Audio_HDI_AudioCaptureFrame_0001 @@ -281,26 +174,17 @@ HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0001, TestSize.Lev int32_t ret = -1; uint64_t replyBytes = 0; uint64_t requestBytes = BUFFER_SIZE; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; + TestAudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = capture->control.Start((AudioHandle)capture); EXPECT_EQ(HDF_SUCCESS, ret); char *frame = (char *)calloc(1, BUFFER_SIZE); EXPECT_NE(nullptr, frame); - ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes); EXPECT_EQ(HDF_SUCCESS, ret); @@ -323,22 +207,14 @@ HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0002, TestSize.Lev int32_t ret = -1; uint64_t replyBytes = 0; uint64_t requestBytes = BUFFER_SIZE; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; char *frame = nullptr; + TestAudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = capture->control.Start((AudioHandle)capture); EXPECT_EQ(HDF_SUCCESS, ret); ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes); @@ -358,22 +234,14 @@ HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0003, TestSize.Lev { int32_t ret = -1; uint64_t requestBytes = BUFFER_SIZE; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; uint64_t *replyBytes = nullptr; + TestAudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = capture->control.Start((AudioHandle)capture); EXPECT_EQ(HDF_SUCCESS, ret); char *frame = (char *)calloc(1, BUFFER_SIZE); @@ -400,22 +268,14 @@ HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0004, TestSize.Lev int32_t ret = -1; uint64_t requestBytes = BUFFER_SIZE; uint64_t replyBytes = 0; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; struct AudioCapture *captureNull = nullptr; + TestAudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = capture->control.Start((AudioHandle)capture); EXPECT_EQ(HDF_SUCCESS, ret); char *frame = (char *)calloc(1, BUFFER_SIZE); @@ -441,22 +301,14 @@ HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0005, TestSize.Lev { int32_t ret = -1; uint64_t requestBytes = BUFFER_SIZE; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; uint64_t replyBytes = 0; + TestAudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } char *frame = (char *)calloc(1, BUFFER_SIZE); EXPECT_NE(nullptr, frame); ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes); @@ -482,21 +334,13 @@ HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0006, TestSize.Lev int32_t ret = -1; uint64_t requestBytes = BUFFER_SIZE_LITTLE; uint64_t replyBytes = 0; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; + TestAudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = capture->control.Start((AudioHandle)capture); EXPECT_EQ(HDF_SUCCESS, ret); char *frame = (char *)calloc(1, BUFFER_SIZE); @@ -525,19 +369,15 @@ HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0001, int64_t timeExp = 0; struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; struct PrepareAudioPara audiopara = { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .self = this, .pins = PIN_IN_MIC, + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); - ret = GetLoadAdapterAudioPara(audiopara); + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } sleep(1); if (audiopara.capture != nullptr) { ret = audiopara.capture->GetCapturePosition(audiopara.capture, &frames, &time); @@ -546,14 +386,8 @@ HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0001, EXPECT_GT(frames, INITIAL_VALUE); } - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.capture->control.Stop((AudioHandle)(audiopara.capture)); + ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); } /** * @tc.name Test GetCapturePosition API via get CapturePosition after the audiois Paused and resumed @@ -564,23 +398,19 @@ HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0001, HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0002, TestSize.Level1) { int32_t ret = -1; - uint64_t frames = 0; int64_t timeExp = 0; + uint64_t frames = 0; struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; struct PrepareAudioPara audiopara = { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .self = this, .pins = PIN_IN_MIC, + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); - ret = GetLoadAdapterAudioPara(audiopara); + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } sleep(1); if (audiopara.capture != nullptr) { ret = audiopara.capture->control.Pause((AudioHandle)(audiopara.capture)); @@ -597,14 +427,8 @@ HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0002, EXPECT_GT(frames, INITIAL_VALUE); } - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.capture->control.Stop((AudioHandle)(audiopara.capture)); + ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); } /** * @tc.name Test GetCapturePosition API via get CapturePosition after the audio file is stopped @@ -615,39 +439,26 @@ HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0002, HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0003, TestSize.Level1) { int32_t ret = -1; + TestAudioManager manager = {}; + struct AudioAdapter *adapter = {}; + struct AudioCapture *capture = nullptr; uint64_t frames = 0; - int64_t timeExp = 0; struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; - struct PrepareAudioPara audiopara = { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .self = this, .pins = PIN_IN_MIC, - .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE - }; - - ret = GetLoadAdapterAudioPara(audiopara); - ASSERT_EQ(HDF_SUCCESS, ret); - - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - sleep(1); - if (audiopara.capture != nullptr) { - ret = audiopara.capture->GetCapturePosition(audiopara.capture, &frames, &time); - EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp); - EXPECT_GT(frames, INITIAL_VALUE); - } + int64_t timeExp = 0; - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; + manager = *GetAudioManager(); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.capture->control.Stop((AudioHandle)(audiopara.capture)); + ret = capture->control.Stop((AudioHandle)capture); EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); + ret = capture->GetCapturePosition(capture, &frames, &time); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp); + EXPECT_GT(frames, INITIAL_VALUE); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); } /** * @tc.name Test GetCapturePosition API via get CapturePosition after the object is created @@ -658,23 +469,17 @@ HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0003, HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0004, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioPort capturePort = {}; + enum AudioPortPin pins = PIN_IN_MIC; struct AudioAdapter *adapter = {}; struct AudioCapture *capture = nullptr; uint64_t frames = 0; struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; int64_t timeExp = 0; + TestAudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME2, &adapter, capturePort); + ret = AudioCreateCapture(manager, pins, ADAPTER_NAME_USB, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(PIN_IN_MIC, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = capture->GetCapturePosition(capture, &frames, &time); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp); @@ -691,26 +496,17 @@ HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0004, HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0005, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioPort capturePort = {}; + TestAudioManager manager = {}; struct AudioAdapter *adapter = {}; struct AudioCapture *capture = nullptr; struct AudioCapture *captureNull = nullptr; uint64_t frames = 0; struct AudioTimeStamp time = {}; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME2, &adapter, capturePort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(PIN_IN_MIC, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->GetCapturePosition(captureNull, &frames, &time); EXPECT_EQ(HDF_FAILURE, ret); @@ -727,25 +523,16 @@ HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0005, HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0006, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioPort capturePort = {}; + TestAudioManager manager = {}; struct AudioAdapter *adapter = {}; struct AudioCapture *capture = nullptr; uint64_t *framesNull = nullptr; struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME2, &adapter, capturePort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(PIN_IN_MIC, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->GetCapturePosition(capture, framesNull, &time); EXPECT_EQ(HDF_FAILURE, ret); @@ -762,25 +549,16 @@ HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0006, HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0007, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioPort capturePort = {}; + TestAudioManager manager = {}; struct AudioAdapter *adapter = {}; struct AudioCapture *capture = nullptr; uint64_t frames = 0; struct AudioTimeStamp *timeNull = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME2, &adapter, capturePort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(PIN_IN_MIC, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->GetCapturePosition(capture, &frames, timeNull); EXPECT_EQ(HDF_FAILURE, ret); @@ -797,34 +575,25 @@ HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0007, HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0008, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioPort capturePort = {}; + TestAudioManager manager = {}; struct AudioAdapter *adapter = {}; struct AudioCapture *capture = nullptr; uint64_t frames = 0; - struct AudioTimeStamp time = {.tvSec = 0}; - struct AudioTimeStamp timeSec = {.tvNSec = 1}; + struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; + struct AudioTimeStamp timeSec = {.tvSec = 0, .tvNSec = 0}; int64_t timeExp = 0; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME2, &adapter, capturePort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(PIN_IN_MIC, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = capture->GetCapturePosition(capture, &frames, &time); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp); EXPECT_GT(frames, INITIAL_VALUE); ret = capture->GetCapturePosition(capture, &frames, &timeSec); EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_GT(timeSec.tvNSec, timeExp); + EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp); EXPECT_GT(frames, INITIAL_VALUE); capture->control.Stop((AudioHandle)capture); @@ -840,25 +609,20 @@ HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0008, HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0009, TestSize.Level1) { int32_t ret = -1; - struct AudioAdapter *adapter = nullptr; - struct AudioPort capturePort = {}; - struct AudioCapture *capture = nullptr; - struct AudioSampleAttributes attrs = {}; - struct AudioSampleAttributes attrsValue = {}; uint64_t channelCountExp = 2; uint32_t sampleRateExp = 48000; uint64_t frames = 0; int64_t timeExp = 0; - struct AudioTimeStamp time = {.tvNSec = 1}; - struct AudioManager manager = *GetAudioManager(); + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; + TestAudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME2, &adapter, capturePort); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(PIN_IN_MIC, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + InitAttrs(attrs); attrs.type = AUDIO_IN_MEDIA; attrs.interleaved = false; attrs.format = AUDIO_FORMAT_PCM_16_BIT; @@ -868,15 +632,15 @@ HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0009, EXPECT_EQ(HDF_SUCCESS, ret); ret = capture->attr.GetSampleAttributes(capture, &attrsValue); EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); EXPECT_EQ(channelCountExp, attrsValue.channelCount); - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); + ret = AudioCaptureStartAndOneFrame(capture); EXPECT_EQ(HDF_SUCCESS, ret); ret = capture->GetCapturePosition(capture, &frames, &time); EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_GT(time.tvNSec, timeExp); + EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp); EXPECT_GT(frames, INITIAL_VALUE); capture->control.Stop((AudioHandle)capture); @@ -892,25 +656,20 @@ HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0009, HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0010, TestSize.Level1) { int32_t ret = -1; - struct AudioAdapter *adapter = nullptr; - struct AudioPort capturePort = {}; - struct AudioCapture *capture = nullptr; struct AudioSampleAttributes attrs = {}; struct AudioSampleAttributes attrsValue = {}; + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; uint64_t channelCountExp = 2; uint32_t sampleRateExp = 48000; uint64_t frames = 0; int64_t timeExp = 0; - struct AudioTimeStamp time = {.tvNSec = 1}; - struct AudioManager manager = *GetAudioManager(); + struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; + TestAudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME2, &adapter, capturePort); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(PIN_IN_MIC, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + InitAttrs(attrs); attrs.type = AUDIO_IN_MEDIA; attrs.interleaved = false; attrs.format = AUDIO_FORMAT_PCM_24_BIT; @@ -921,14 +680,14 @@ HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0010, ret = capture->attr.GetSampleAttributes(capture, &attrsValue); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); - EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); EXPECT_EQ(channelCountExp, attrsValue.channelCount); + EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); + ret = AudioCaptureStartAndOneFrame(capture); EXPECT_EQ(HDF_SUCCESS, ret); ret = capture->GetCapturePosition(capture, &frames, &time); EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_GT(time.tvNSec, timeExp); + EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp); EXPECT_GT(frames, INITIAL_VALUE); capture->control.Stop((AudioHandle)capture); @@ -944,25 +703,20 @@ HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0010, HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0011, TestSize.Level1) { int32_t ret = -1; - struct AudioAdapter *adapter = nullptr; - struct AudioPort capturePort = {}; struct AudioCapture *capture = nullptr; + struct AudioAdapter *adapter = nullptr; struct AudioSampleAttributes attrs = {}; struct AudioSampleAttributes attrsValue = {}; uint64_t channelCountExp = 1; uint32_t sampleRateExp = 48000; uint64_t frames = 0; int64_t timeExp = 0; - struct AudioTimeStamp time = {.tvNSec = 1}; - struct AudioManager manager = *GetAudioManager(); + struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; + TestAudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME2, &adapter, capturePort); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(PIN_IN_MIC, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + InitAttrs(attrs); attrs.type = AUDIO_IN_MEDIA; attrs.interleaved = false; attrs.format = AUDIO_FORMAT_PCM_16_BIT; @@ -976,11 +730,11 @@ HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0011, EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); EXPECT_EQ(channelCountExp, attrsValue.channelCount); - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); + ret = AudioCaptureStartAndOneFrame(capture); EXPECT_EQ(HDF_SUCCESS, ret); ret = capture->GetCapturePosition(capture, &frames, &time); EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_GT(time.tvNSec, timeExp); + EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp); EXPECT_GT(frames, INITIAL_VALUE); capture->control.Stop((AudioHandle)capture); @@ -996,25 +750,20 @@ HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0011, HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0012, TestSize.Level1) { int32_t ret = -1; - struct AudioAdapter *adapter = nullptr; - struct AudioPort capturePort = {}; - struct AudioCapture *capture = nullptr; - struct AudioSampleAttributes attrs = {}; - struct AudioSampleAttributes attrsValue = {}; uint64_t channelCountExp = 1; uint32_t sampleRateExp = 48000; uint64_t frames = 0; int64_t timeExp = 0; - struct AudioTimeStamp time = {.tvNSec = 1}; - struct AudioManager manager = *GetAudioManager(); + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; + TestAudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME2, &adapter, capturePort); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(PIN_IN_MIC, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + InitAttrs(attrs); attrs.type = AUDIO_IN_MEDIA; attrs.interleaved = false; attrs.format = AUDIO_FORMAT_PCM_24_BIT; @@ -1024,15 +773,15 @@ HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0012, EXPECT_EQ(HDF_SUCCESS, ret); ret = capture->attr.GetSampleAttributes(capture, &attrsValue); EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(channelCountExp, attrsValue.channelCount); EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); - EXPECT_EQ(channelCountExp, attrsValue.channelCount); - ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); + ret = AudioCaptureStartAndOneFrame(capture); EXPECT_EQ(HDF_SUCCESS, ret); ret = capture->GetCapturePosition(capture, &frames, &time); EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_GT(time.tvNSec, timeExp); + EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp); EXPECT_GT(frames, INITIAL_VALUE); capture->control.Stop((AudioHandle)capture); diff --git a/audio/test/systemtest/hdi/capture/src/audio_hdicapture_volume_test.cpp b/audio/test/systemtest/hdi/capture/src/audio_hdicapture_volume_test.cpp index e02d79af7a..e571b9e6d9 100755 --- a/audio/test/systemtest/hdi/capture/src/audio_hdicapture_volume_test.cpp +++ b/audio/test/systemtest/hdi/capture/src/audio_hdicapture_volume_test.cpp @@ -41,10 +41,9 @@ using namespace testing::ext; using namespace HMOS::Audio; namespace { -const string AUDIO_CAPTURE_FILE = "//bin/audiocapturetest.wav"; -const string ADAPTER_NAME = "hdmi"; -const string ADAPTER_NAME2 = "usb"; -const string ADAPTER_NAME3 = "internal"; +const string ADAPTER_NAME_HDMI = "hdmi"; +const string ADAPTER_NAME_USB = "usb"; +const string ADAPTER_NAME_INTERNAL = "internal"; class AudioHdiCaptureVolumeTest : public testing::Test { public: @@ -52,97 +51,75 @@ public: static void TearDownTestCase(void); void SetUp(); void TearDown(); - struct AudioManager *(*GetAudioManager)() = nullptr; - void *handleSo = nullptr; - int32_t GetLoadAdapter(struct AudioManager manager, enum AudioPortDirection portType, - const string adapterName, struct AudioAdapter **adapter, struct AudioPort& audioPort) const; - int32_t AudioCreateCapture(enum AudioPortPin pins, struct AudioManager manager, - struct AudioPort capturePort, struct AudioAdapter *adapter, - struct AudioCapture **capture) const; + static TestAudioManager *(*GetAudioManager)(); + static void *handleSo; +#ifdef AUDIO_MPI_SO + static int32_t (*SdkInit)(); + static void (*SdkExit)(); + static void *sdkSo; +#endif int32_t AudioCaptureStart(const string path, struct AudioCapture *capture) const; }; -void AudioHdiCaptureVolumeTest::SetUpTestCase(void) {} +TestAudioManager *(*AudioHdiCaptureVolumeTest::GetAudioManager)() = nullptr; +void *AudioHdiCaptureVolumeTest::handleSo = nullptr; +#ifdef AUDIO_MPI_SO + int32_t (*AudioHdiCaptureVolumeTest::SdkInit)() = nullptr; + void (*AudioHdiCaptureVolumeTest::SdkExit)() = nullptr; + void *AudioHdiCaptureVolumeTest::sdkSo = nullptr; +#endif -void AudioHdiCaptureVolumeTest::TearDownTestCase(void) {} - -void AudioHdiCaptureVolumeTest::SetUp(void) +void AudioHdiCaptureVolumeTest::SetUpTestCase(void) { - char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; - handleSo = dlopen(resolvedPath, RTLD_LAZY); - if (handleSo == nullptr) { +#ifdef AUDIO_MPI_SO + char sdkResolvedPath[] = "//system/lib/libhdi_audio_interface_lib_render.z.so"; + sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY); + if (sdkSo == nullptr) { return; } - GetAudioManager = (struct AudioManager *(*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); - if (GetAudioManager == nullptr) { + SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit")); + if (SdkInit == nullptr) { return; } -} - -void AudioHdiCaptureVolumeTest::TearDown(void) -{ - if (GetAudioManager != nullptr) { - GetAudioManager = nullptr; - } -} - -int32_t AudioHdiCaptureVolumeTest::GetLoadAdapter(struct AudioManager manager, enum AudioPortDirection portType, - const string adapterName, struct AudioAdapter **adapter, struct AudioPort& audioPort) const -{ - int32_t ret = -1; - int size = 0; - struct AudioAdapterDescriptor *desc = nullptr; - struct AudioAdapterDescriptor *descs = nullptr; - if (adapter == nullptr) { - return HDF_FAILURE; - } - ret = manager.GetAllAdapters(&manager, &descs, &size); - if (ret < 0 || descs == nullptr || size == 0) { - return HDF_FAILURE; - } else { - int index = SwitchAdapter(descs, adapterName, portType, audioPort, size); - if (index < 0) { - return HDF_FAILURE; - } else { - desc = &descs[index]; - } + SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit")); + if (SdkExit == nullptr) { + return; } - if (desc == nullptr) { - return HDF_FAILURE; - } else { - ret = manager.LoadAdapter(&manager, desc, adapter); + SdkInit(); +#endif + handleSo = dlopen(RESOLVED_PATH.c_str(), RTLD_LAZY); + if (handleSo == nullptr) { + return; } - if (ret < 0 || adapter == nullptr) { - return HDF_FAILURE; + GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str())); + if (GetAudioManager == nullptr) { + return; } - return HDF_SUCCESS; } -int32_t AudioHdiCaptureVolumeTest::AudioCreateCapture(enum AudioPortPin pins, struct AudioManager manager, - struct AudioPort capturePort, struct AudioAdapter *adapter, struct AudioCapture **capture) const +void AudioHdiCaptureVolumeTest::TearDownTestCase(void) { - int32_t ret = -1; - struct AudioSampleAttributes attrs = {}; - struct AudioDeviceDescriptor devDesc = {}; - if (adapter == nullptr || adapter->CreateCapture == nullptr || capture == nullptr) { - return HDF_FAILURE; +#ifdef AUDIO_MPI_SO + SdkExit(); + if (sdkSo != nullptr) { + dlclose(sdkSo); + sdkSo = nullptr; } - ret = InitAttrs(attrs); - if (ret < 0) { - return HDF_FAILURE; + if (SdkInit != nullptr) { + SdkInit = nullptr; } - ret = InitDevDesc(devDesc, capturePort.portId, pins); - if (ret < 0) { - return HDF_FAILURE; + if (SdkExit != nullptr) { + SdkExit = nullptr; } - ret = adapter->CreateCapture(adapter, &devDesc, &attrs, capture); - if (ret < 0 || *capture == nullptr) { - manager.UnloadAdapter(&manager, adapter); - return HDF_FAILURE; +#endif + if (GetAudioManager != nullptr) { + GetAudioManager = nullptr; } - return HDF_SUCCESS; } +void AudioHdiCaptureVolumeTest::SetUp(void) {} +void AudioHdiCaptureVolumeTest::TearDown(void) {} + int32_t AudioHdiCaptureVolumeTest::AudioCaptureStart(const string path, struct AudioCapture *capture) const { int32_t ret = -1; @@ -178,23 +155,13 @@ HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_HDI_AudioCaptureSetMute_0001, Test int32_t ret = -1; bool muteTrue = true; bool muteFalse = false; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioPort capturePort = {}; struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = capture->volume.SetMute(capture, muteTrue); EXPECT_EQ(HDF_SUCCESS, ret); @@ -223,23 +190,13 @@ HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_HDI_AudioCaptureSetMute_0002, Test bool muteTrue = true; bool muteFalse = false; int32_t ret = -1; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioPort capturePort = {}; struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; struct AudioCapture *captureNull = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = capture->volume.SetMute(captureNull, muteTrue); EXPECT_EQ(HDF_FAILURE, ret); @@ -259,23 +216,13 @@ HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_HDI_AudioCaptureSetMute_0003, Test { bool muteValue = 2; int32_t ret = -1; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioPort capturePort = {}; struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = capture->volume.SetMute(capture, muteValue); EXPECT_EQ(HDF_SUCCESS, ret); @@ -294,27 +241,17 @@ HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_HDI_AudioCaptureSetMute_0003, Test */ HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_HDI_AudioCaptureGetMute_0001, TestSize.Level1) { + int32_t ret = -1; bool muteTrue = true; bool muteFalse = false; bool defaultmute = true; - int32_t ret = -1; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioPort capturePort = {}; struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = capture->volume.GetMute(capture, &muteTrue); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(muteTrue, defaultmute); @@ -340,23 +277,13 @@ HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_HDI_AudioCaptureGetMute_0002, Test int32_t ret = -1; bool muteTrue = true; bool muteFalse = false; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioPort capturePort = {}; struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; struct AudioCapture *captureNull = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = capture->volume.GetMute(captureNull, &muteTrue); EXPECT_EQ(HDF_FAILURE, ret); @@ -386,19 +313,12 @@ HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_HDI_AudioCaptureSetVolume_0001, Te float volumeMidExpc = 0.40; float volumeHigh = 0.70; float volumeHighExpc = 0.70; - struct AudioPort capturePort = {}; struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - - ret = AudioCreateCapture(PIN_IN_MIC, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = capture->volume.SetVolume(capture, volumeInit); EXPECT_EQ(HDF_SUCCESS, ret); ret = capture->volume.GetVolume(capture, &volumeInit); @@ -438,23 +358,13 @@ HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_HDI_AudioCaptureSetVolume_0002, Te float volumeMaxExpc = 1.0; float volumeMinBoundary = -1; float volumeMaxBoundary = 1.1; - struct AudioPort capturePort = {}; - struct AudioAdapter *adapter = {}; + struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioManager manager = *GetAudioManager(); - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - ASSERT_NE(nullptr, GetAudioManager); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = capture->volume.SetVolume(capture, volumeMin); EXPECT_EQ(HDF_SUCCESS, ret); ret = capture->volume.GetVolume(capture, &volumeMin); @@ -486,24 +396,14 @@ HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_HDI_AudioCaptureSetVolume_0003, Te { int32_t ret = -1; float volume = 0; - struct AudioPort capturePort = {}; - struct AudioAdapter *adapter = {}; + struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; struct AudioCapture *captureNull = nullptr; - struct AudioManager manager = *GetAudioManager(); - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - ASSERT_NE(nullptr, GetAudioManager); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = capture->volume.SetVolume(captureNull, volume); EXPECT_EQ(HDF_FAILURE, ret); @@ -521,22 +421,13 @@ HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_HDI_AudioCaptureGetVolume_001, Tes int32_t ret = -1; float volume = 0.60; float defaultVolume = 0.60; - struct AudioPort capturePort = {}; - struct AudioAdapter *adapter = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; + struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = capture->volume.SetVolume(capture, volume); EXPECT_EQ(HDF_SUCCESS, ret); ret = capture->volume.GetVolume(capture, &volume); @@ -557,22 +448,12 @@ HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_HDI_AudioCaptureGetVolume_002, Tes int32_t ret = -1; float volume = 0.60; float defaultVolume = 0.60; - struct AudioPort capturePort = {}; - struct AudioAdapter *adapter = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; + struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); EXPECT_EQ(HDF_SUCCESS, ret); @@ -597,24 +478,14 @@ HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_HDI_AudioCaptureGetVolume_0003, Te { int32_t ret = -1; float volume = 0.30; - struct AudioPort capturePort = {}; - struct AudioAdapter *adapter = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; + struct AudioAdapter *adapter = nullptr; struct AudioCapture *capture = nullptr; struct AudioCapture *captureNull = nullptr; - struct AudioManager manager = *GetAudioManager(); - ASSERT_NE(nullptr, GetAudioManager); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = capture->volume.GetVolume(captureNull, &volume); EXPECT_EQ(HDF_FAILURE, ret); @@ -630,23 +501,14 @@ HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_HDI_AudioCaptureGetVolume_0003, Te HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_hdi_CaptureGetGainThreshold_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioAdapter* adapter = nullptr; - struct AudioCapture* capture = nullptr; float min = 0; float max = 0; - + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = capture->volume.GetGainThreshold((AudioHandle)capture, &min, &max); EXPECT_EQ(HDF_SUCCESS, ret); @@ -665,24 +527,15 @@ HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_hdi_CaptureGetGainThreshold_0001, HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_hdi_CaptureGetGainThreshold_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioAdapter* adapter = nullptr; - struct AudioCapture* capture = nullptr; - struct AudioCapture* captureNull = nullptr; float min = 0; float max = 0; - + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + struct AudioCapture *captureNull = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = capture->volume.GetGainThreshold((AudioHandle)captureNull, &min, &max); EXPECT_EQ(HDF_FAILURE, ret); @@ -699,23 +552,14 @@ HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_hdi_CaptureGetGainThreshold_0002, HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_hdi_CaptureGetGainThreshold_0003, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioAdapter* adapter = nullptr; - struct AudioCapture* capture = nullptr; float max = 0; float* minNull = nullptr; - + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = capture->volume.GetGainThreshold((AudioHandle)capture, minNull, &max); EXPECT_EQ(HDF_FAILURE, ret); @@ -732,23 +576,14 @@ HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_hdi_CaptureGetGainThreshold_0003, HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_hdi_CaptureGetGainThreshold_0004, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioAdapter* adapter = nullptr; - struct AudioCapture* capture = nullptr; float min = 0; float* maxNull = nullptr; - + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = capture->volume.GetGainThreshold((AudioHandle)capture, &min, maxNull); EXPECT_EQ(HDF_FAILURE, ret); @@ -765,22 +600,15 @@ HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_hdi_CaptureGetGainThreshold_0004, HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_hdi_CaptureSetGain_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioAdapter* adapter = nullptr; - struct AudioCapture* capture = nullptr; float min = 0; float max = 0; + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + ret = capture->volume.GetGainThreshold((AudioHandle)capture, &min, &max); EXPECT_EQ(HDF_SUCCESS, ret); float gain = max - 1; @@ -819,23 +647,14 @@ HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_hdi_CaptureSetGain_0001, TestSize. HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_hdi_CaptureSetGain_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioAdapter* adapter = nullptr; - struct AudioCapture* capture = nullptr; float min = 0; float max = 0; - + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = capture->volume.GetGainThreshold((AudioHandle)capture, &min, &max); EXPECT_EQ(HDF_SUCCESS, ret); @@ -859,23 +678,14 @@ HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_hdi_CaptureSetGain_0002, TestSize. HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_hdi_CaptureSetGain_0003, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioAdapter* adapter = nullptr; - struct AudioCapture* capture = nullptr; - struct AudioCapture* captureNull = nullptr; float gain = 0; - + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + struct AudioCapture *captureNull = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = capture->volume.SetGain((AudioHandle)captureNull, gain); EXPECT_EQ(HDF_FAILURE, ret); @@ -892,23 +702,14 @@ HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_hdi_CaptureSetGain_0003, TestSize. HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_hdi_CaptureGetGain_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioAdapter* adapter = nullptr; - struct AudioCapture* capture = nullptr; float min = 0; float max = 0; - + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = capture->volume.GetGainThreshold((AudioHandle)capture, &min, &max); EXPECT_EQ(HDF_SUCCESS, ret); @@ -933,23 +734,14 @@ HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_hdi_CaptureGetGain_0001, TestSize. HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_hdi_CaptureGetGain_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioAdapter* adapter = nullptr; - struct AudioCapture* capture = nullptr; - struct AudioCapture* captureNull = nullptr; float gainValue = 0; - + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + struct AudioCapture *captureNull = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = capture->volume.GetGain((AudioHandle)captureNull, &gainValue); EXPECT_EQ(HDF_FAILURE, ret); adapter->DestroyCapture(adapter, capture); @@ -964,23 +756,14 @@ HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_hdi_CaptureGetGain_0002, TestSize. HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_hdi_CaptureGetGain_0003, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioAdapter* adapter = nullptr; - struct AudioCapture* capture = nullptr; float gain = GAIN_MAX-1; float gainOne = GAIN_MAX-1; - + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = capture->volume.SetGain((AudioHandle)capture, gain); EXPECT_EQ(HDF_SUCCESS, ret); @@ -1000,22 +783,13 @@ HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_hdi_CaptureGetGain_0003, TestSize. HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_hdi_CaptureGetGain_0004, TestSize.Level1) { int32_t ret = -1; - struct AudioPort capturePort = {}; - enum AudioPortDirection portType = PORT_IN; - enum AudioPortPin pins = PIN_IN_MIC; - struct AudioAdapter* adapter = nullptr; - struct AudioCapture* capture = nullptr; + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; float *gainNull = nullptr; - ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = capture->volume.GetGain((AudioHandle)capture, gainNull); EXPECT_EQ(HDF_FAILURE, ret); diff --git a/audio/test/systemtest/hdi/hdiperformace/BUILD.gn b/audio/test/systemtest/hdi/hdiperformace/BUILD.gn new file mode 100755 index 0000000000..39564653f6 --- /dev/null +++ b/audio/test/systemtest/hdi/hdiperformace/BUILD.gn @@ -0,0 +1,214 @@ +# 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. + +if (defined(ohos_lite)) { + import("//build/lite/config/test.gni") +} else { + import("//build/test.gni") + import("//drivers/adapter/uhdf2/uhdf.gni") + import("//drivers/peripheral/audio/audio.gni") +} + +if (defined(ohos_lite)) { +###########################LITEOS########################################## +###########################hdf_audio_hdi_render_performace_test##################### + unittest("hdf_audio_hdi_render_performace_test") { + sources = [ + "src/audio_hdirender_performace_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] + + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/include", + "//drivers/framework/core/sec/include", + "//drivers/framework/core/shared/include", + "//drivers/framework/core/host/include", + "//drivers/framework/core/manager/include", + "//drivers/framework/core/common/include/host/", + "//third_party/bounds_checking_function/include", + "//drivers/adapter/khdf/liteos/osal/include", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/adapter/uhdf2/include/hdi/", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/hdiperformace/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + } + ###########################end########################### + ###########################hdf_audio_hdi_capture_performace_test##################### + unittest("hdf_audio_hdi_capture_performace_test") { + sources = [ + "src/audio_hdicapture_performace_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] + + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/include", + "//drivers/framework/core/sec/include", + "//drivers/framework/core/shared/include", + "//drivers/framework/core/host/include", + "//drivers/framework/core/manager/include", + "//drivers/framework/core/common/include/host/", + "//third_party/bounds_checking_function/include", + "//drivers/adapter/khdf/liteos/osal/include", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/adapter/uhdf2/include/hdi/", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/hdiperformace/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + } +} else { + ###########################SystemTest########################################## + module_output_path = "hdf/audio" + ###########################hdf_audio_hdi_render_performace_test##################### + ohos_systemtest("hdf_audio_hdi_render_performace_test") { + module_out_path = module_output_path + sources = [ + "src/audio_hdirender_performace_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] + + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/include", + "//third_party/bounds_checking_function/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/adapter/uhdf2/osal/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/hdiperformace/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + deps = [ + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + defines = [] + if (enable_audio_adm_so) { + defines += [ "AUDIO_ADM_SO" ] + } + if (enable_audio_mpi_so) { + defines += [ "AUDIO_MPI_SO" ] + } + if (enable_audio_adm_service) { + defines += [ "AUDIO_ADM_SERVICE" ] + } + if (enable_audio_mpi_service) { + defines += [ "AUDIO_MPI_SERVICE" ] + } + } + ###########################end########################### + ###########################hdf_audio_hdi_capture_performace_test##################### + ohos_systemtest("hdf_audio_hdi_capture_performace_test") { + module_out_path = module_output_path + sources = [ + "src/audio_hdicapture_performace_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] + + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/include", + "//third_party/bounds_checking_function/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/adapter/uhdf2/osal/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/hdiperformace/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + deps = [ + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + defines = [] + if (enable_audio_adm_so) { + defines += [ "AUDIO_ADM_SO" ] + } + if (enable_audio_mpi_so) { + defines += [ "AUDIO_MPI_SO" ] + } + if (enable_audio_adm_service) { + defines += [ "AUDIO_ADM_SERVICE" ] + } + if (enable_audio_mpi_service) { + defines += [ "AUDIO_MPI_SERVICE" ] + } + } +} +###########################end########################### \ No newline at end of file diff --git a/audio/test/systemtest/hdi/hdiperformace/include/audio_hdicapture_performace_test.h b/audio/test/systemtest/hdi/hdiperformace/include/audio_hdicapture_performace_test.h new file mode 100755 index 0000000000..a8a47f5c1e --- /dev/null +++ b/audio/test/systemtest/hdi/hdiperformace/include/audio_hdicapture_performace_test.h @@ -0,0 +1,19 @@ +/* + * 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 AUDIO_HDICAPTURE_PERFORMACE_TEST_H +#define AUDIO_HDICAPTURE_PERFORMACE_TEST_H +#include +#endif diff --git a/audio/test/systemtest/hdi/hdiperformace/include/audio_hdirender_performace_test.h b/audio/test/systemtest/hdi/hdiperformace/include/audio_hdirender_performace_test.h new file mode 100755 index 0000000000..4d7b5435f6 --- /dev/null +++ b/audio/test/systemtest/hdi/hdiperformace/include/audio_hdirender_performace_test.h @@ -0,0 +1,19 @@ +/* + * 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 AUDIO_HDIRENDER_PERFORMACE_TEST_H +#define AUDIO_HDIRENDER_PERFORMACE_TEST_H +#include +#endif diff --git a/audio/test/systemtest/hdi/hdiperformace/src/audio_hdicapture_performace_test.cpp b/audio/test/systemtest/hdi/hdiperformace/src/audio_hdicapture_performace_test.cpp new file mode 100755 index 0000000000..70d6a0a599 --- /dev/null +++ b/audio/test/systemtest/hdi/hdiperformace/src/audio_hdicapture_performace_test.cpp @@ -0,0 +1,925 @@ +/* + * 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. + */ + +/** + * @addtogroup Audio + * @{ + * + * @brief Test audio recording interface delayTime. + * + * @since 1.0 + * @version 1.0 + */ + +/** + * @file audio_hdi_common.h + * + * @brief Declares APIs for operations related to the audio delayTime. + * + * @since 1.0 + * @version 1.0 + */ + +#include "audio_hdi_common.h" +#include "audio_hdicapture_performace_test.h" + +using namespace std; +using namespace testing::ext; +using namespace HMOS::Audio; + +namespace { +const string ADAPTER_NAME_USB = "usb"; +const float COUNT = 1000; +const long LOWLATENCY = 10000; +const long NORMALLATENCY = 30000; +const long HIGHLATENCY = 60000; +const int BUFFER = 1024 * 4; + +class AudioHdiCapturePerformaceTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + static TestAudioManager *(*GetAudioManager)(); + static void *handleSo; +#ifdef AUDIO_MPI_SO + static int32_t (*SdkInit)(); + static void (*SdkExit)(); + static void *sdkSo; +#endif +}; + +TestAudioManager *(*AudioHdiCapturePerformaceTest::GetAudioManager)() = nullptr; +void *AudioHdiCapturePerformaceTest::handleSo = nullptr; +#ifdef AUDIO_MPI_SO + int32_t (*AudioHdiCapturePerformaceTest::SdkInit)() = nullptr; + void (*AudioHdiCapturePerformaceTest::SdkExit)() = nullptr; + void *AudioHdiCapturePerformaceTest::sdkSo = nullptr; +#endif + +void AudioHdiCapturePerformaceTest::SetUpTestCase(void) +{ +#ifdef AUDIO_MPI_SO + char sdkResolvedPath[] = "//system/lib/libhdi_audio_interface_lib_render.z.so"; + sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY); + if (sdkSo == nullptr) { + return; + } + SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit")); + if (SdkInit == nullptr) { + return; + } + SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit")); + if (SdkExit == nullptr) { + return; + } + SdkInit(); +#endif + handleSo = dlopen(RESOLVED_PATH.c_str(), RTLD_LAZY); + if (handleSo == nullptr) { + return; + } + GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str())); + if (GetAudioManager == nullptr) { + return; + } +} + +void AudioHdiCapturePerformaceTest::TearDownTestCase(void) +{ +#ifdef AUDIO_MPI_SO + if (SdkExit != nullptr) { + SdkExit(); + } + if (sdkSo != nullptr) { + dlclose(sdkSo); + sdkSo = nullptr; + } + if (SdkInit != nullptr) { + SdkInit = nullptr; + } + if (SdkExit != nullptr) { + SdkExit = nullptr; + } +#endif + if (GetAudioManager != nullptr) { + GetAudioManager = nullptr; + } +} + +void AudioHdiCapturePerformaceTest::SetUp(void) {} + +void AudioHdiCapturePerformaceTest::TearDown(void) {} + +/** +* @tc.name the performace of AudioCreateCapture +* @tc.number SUB_Audio_HDI_AudioCreateCapture_Performance_0001 +* @tc.devDesc tests the performace of AudioCreateCapture interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCreateCapture_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = GetLoadAdapter(*audiopara.manager, audiopara.portType, audiopara.adapterName, + &audiopara.adapter, audiopara.audioPort); + ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrs(audiopara.attrs); + InitDevDesc(audiopara.devDesc, audiopara.audioPort.portId, audiopara.pins); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.adapter->CreateCapture(audiopara.adapter, &audiopara.devDesc, &audiopara.attrs, + &audiopara.capture); + gettimeofday(&audiopara.end, NULL); + if (ret < 0 || audiopara.capture == nullptr) { + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); + ASSERT_EQ(HDF_SUCCESS, ret); + } + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); + EXPECT_EQ(HDF_SUCCESS, ret); + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(HIGHLATENCY, audiopara.averageDelayTime); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudioDestroyCapture +* @tc.number SUB_Audio_HDI_AudioDestroyCapture_Performance_0001 +* @tc.devDesc tests the performace of AudioDestroyCapture interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioDestroyCapture_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + for (int i = 0; i < COUNT; ++i) { + ret = AudioCreateCapture(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.capture); + ASSERT_EQ(HDF_SUCCESS, ret); + gettimeofday(&audiopara.start, NULL); + ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); +} + +/** +* @tc.name the performace of AudioCaptureStart +* @tc.number SUB_Audio_HDI_AudioCaptureStart_Performance_0001 +* @tc.devDesc tests the performace of AudioCaptureStart interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureStart_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + for (int i = 0; i < COUNT; ++i) { + ret = AudioCreateCapture(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.capture); + ASSERT_EQ(HDF_SUCCESS, ret); + gettimeofday(&audiopara.start, NULL); + ret = audiopara.capture->control.Start((AudioHandle)audiopara.capture); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + ret = StopAudio(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); +} +/** +* @tc.name the performace of AudioCapturePause +* @tc.number SUB_Audio_HDI_AudioCapturePause_Performance_0001 +* @tc.devDesc tests the performace of AudioCapturePause interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCapturePause_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateCapture(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.capture); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = audiopara.capture->control.Start((AudioHandle)audiopara.capture); + EXPECT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.capture->control.Pause((AudioHandle)audiopara.capture); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.capture->control.Resume((AudioHandle)audiopara.capture); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + ret = StopAudio(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); +} + +/** +* @tc.name the performace of AudioCaptureResume +* @tc.number SUB_Audio_HDI_AudioCaptureResume_Performance_0001 +* @tc.devDesc tests the performace of AudioCaptureResume interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureResume_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateCapture(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.capture); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = audiopara.capture->control.Start((AudioHandle)audiopara.capture); + EXPECT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + ret = audiopara.capture->control.Pause((AudioHandle)audiopara.capture); + EXPECT_EQ(HDF_SUCCESS, ret); + gettimeofday(&audiopara.start, NULL); + ret = audiopara.capture->control.Resume((AudioHandle)audiopara.capture); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + ret = StopAudio(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); +} +/** +* @tc.name the performace of AudioCaptureCaptureFrame +* @tc.number SUB_Audio_HDI_AudioCaptureCaptureFrame_Performance_0001 +* @tc.devDesc tests the performace of AudioCaptureCaptureFrame interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureCaptureFrame_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0, + .requestBytes = BUFFER_LENTH + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + audiopara.frame = (char *)calloc(1, BUFFER_LENTH); + ASSERT_NE(nullptr, audiopara.frame); + for (int i = 0; i < COUNT; ++i) { + ret = GetLoadAdapter(*audiopara.manager, audiopara.portType, audiopara.adapterName, &(audiopara.adapter), + audiopara.audioPort); + if (ret < 0 || audiopara.adapter == nullptr) { + free(audiopara.frame); + audiopara.frame = nullptr; + ASSERT_EQ(HDF_SUCCESS, ret); + } + InitAttrs(audiopara.attrs); + audiopara.attrs.silenceThreshold = BUFFER; + InitDevDesc(audiopara.devDesc, (&audiopara.audioPort)->portId, audiopara.pins); + ret = audiopara.adapter->CreateCapture(audiopara.adapter, &audiopara.devDesc, &audiopara.attrs, + &audiopara.capture); + if (ret < 0) { + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); + free(audiopara.frame); + audiopara.frame = nullptr; + ASSERT_EQ(HDF_SUCCESS, ret); + } + ret = audiopara.capture->control.Start((AudioHandle)audiopara.capture); + EXPECT_EQ(HDF_SUCCESS, ret); + gettimeofday(&audiopara.start, NULL); + ret = audiopara.capture->CaptureFrame(audiopara.capture, audiopara.frame, audiopara.requestBytes, + &audiopara.replyBytes); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + ret = StopAudio(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(NORMALLATENCY, audiopara.averageDelayTime); + free(audiopara.frame); + audiopara.frame = nullptr; +} +/** +* @tc.name the performace of AudioCaptureGetSampleAttributes +* @tc.number SUB_Audio_HDI_AudioCaptureGetSampleAttributes_Performance_0001 +* @tc.devDesc tests the performace of AudioCaptureGetSampleAttributes interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureGetSampleAttributes_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateCapture(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.capture); + ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrs(audiopara.attrs); + ret = audiopara.capture->attr.SetSampleAttributes(audiopara.capture, &audiopara.attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.capture->attr.GetSampleAttributes(audiopara.capture, &audiopara.attrsValue); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudioCaptureSetMute +* @tc.number SUB_Audio_HDI_AudioCaptureSetMute_Performance_0001 +* @tc.devDesc tests the performace of AudioCaptureSetMute interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureSetMute_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateCapture(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.capture); + ASSERT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.capture->volume.SetMute(audiopara.capture, false); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + ret = audiopara.capture->volume.GetMute(audiopara.capture, &audiopara.character.getmute); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_FALSE(audiopara.character.getmute); + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudioCaptureGetMute +* @tc.number SUB_Audio_HDI_AudioCaptureGetMute_Performance_0001 +* @tc.devDesc tests the performace of AudioCaptureGetMute interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureGetMute_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateCapture(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.capture); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = audiopara.capture->volume.SetMute(audiopara.capture, false); + EXPECT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.capture->volume.GetMute(audiopara.capture, &audiopara.character.getmute); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_FALSE(audiopara.character.getmute); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudioCaptureSetVolume +* @tc.number SUB_Audio_HDI_AudioCaptureSetVolume_Performance_0001 +* @tc.devDesc tests the performace of AudioCaptureSetVolume interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureSetVolume_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0, + .character.setvolume = 0.7 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateCapture(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.capture); + ASSERT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.capture->volume.SetVolume(audiopara.capture, audiopara.character.setvolume); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.capture->volume.GetVolume(audiopara.capture, &audiopara.character.getvolume); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(audiopara.character.setvolume, audiopara.character.getvolume); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudioCaptureGetVolume +* @tc.number SUB_Audio_HDI_AudioCaptureGetVolume_Performance_0001 +* @tc.devDesc tests the performace of AudioCaptureGetVolume interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureGetVolume_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0, + .character.setvolume = 0.8 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateCapture(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.capture); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = audiopara.capture->volume.SetVolume(audiopara.capture, audiopara.character.setvolume); + EXPECT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.capture->volume.GetVolume(audiopara.capture, &audiopara.character.getvolume); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(audiopara.character.setvolume, audiopara.character.getvolume); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudioCaptureGetGain +* @tc.number SUB_Audio_HDI_AudioCaptureGetGain_Performance_0001 +* @tc.devDesc tests the performace of AudioCaptureGetGain interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureGetGain_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0, + .character.setgain = 7 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateCapture(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.capture); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = audiopara.capture->volume.SetGain(audiopara.capture, audiopara.character.setgain); + EXPECT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.capture->volume.GetGain(audiopara.capture, &audiopara.character.getgain); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(audiopara.character.setgain, audiopara.character.getgain); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudioCaptureSetGain +* @tc.number SUB_Audio_HDI_AudioCaptureSetGain_Performance_0001 +* @tc.devDesc tests the performace of AudioCaptureSetGain interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureSetGain_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0, + .character.setgain = 8 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateCapture(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.capture); + ASSERT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.capture->volume.SetGain(audiopara.capture, audiopara.character.setgain); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.capture->volume.GetGain(audiopara.capture, &audiopara.character.getgain); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(audiopara.character.setgain, audiopara.character.getgain); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudioCaptureGetCurrentChannelId +* @tc.number SUB_Audio_HDI_AudioCaptureGetCurrentChannelId_Performance_0001 +* @tc.devDesc tests the performace of AudioCaptureGetCurrentChannelId interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureGetCurrentChannelId_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateCapture(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.capture); + ASSERT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.capture->attr.GetCurrentChannelId(audiopara.capture, &audiopara.character.getcurrentchannelId); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudioCaptureGetFrameCount +* @tc.number SUB_Audio_HDI_AudioCaptureGetFrameCount_Performance_0001 +* @tc.devDesc tests the performace of AudioCaptureGetFrameCount interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureGetFrameCount_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateCapture(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.capture); + ASSERT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.capture->attr.GetFrameCount(audiopara.capture, &audiopara.character.getframecount); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(INITIAL_VALUE, audiopara.character.getframecount); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudioCaptureGetFrameSize +* @tc.number SUB_Audio_HDI_AudioCaptureGetFrameSize_Performance_0001 +* @tc.devDesc tests the performace of AudioCaptureGetFrameSize interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureGetFrameSize_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateCapture(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.capture); + ASSERT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.capture->attr.GetFrameSize(audiopara.capture, &audiopara.character.getframesize); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(audiopara.character.getframesize, INITIAL_VALUE); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudioCaptureFlush +* @tc.number SUB_Audio_HDI_AudioCaptureFlush_Performance_0001 +* @tc.devDesc tests the performace of AudioCaptureFlush interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureFlush_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + for (int i = 0; i < COUNT; ++i) { + ret = AudioCreateCapture(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.capture); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = audiopara.capture->control.Start((AudioHandle)audiopara.capture); + EXPECT_EQ(HDF_SUCCESS, ret); + gettimeofday(&audiopara.start, NULL); + ret = audiopara.capture->control.Flush((AudioHandle)audiopara.capture); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + ret = StopAudio(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); +} + +/** +* @tc.name the performace of AudioCaptureGetGainThreshold +* @tc.number SUB_Audio_HDI_AudioCaptureGetGainThreshold_Performance_0001 +* @tc.devDesc tests the performace of AudioCaptureGetGainThreshold interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureGetGainThreshold_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateCapture(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.capture); + ASSERT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.capture->volume.GetGainThreshold(audiopara.capture, &audiopara.character.gainthresholdmin, + &audiopara.character.gainthresholdmax); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(audiopara.character.gainthresholdmin, GAIN_MIN); + EXPECT_EQ(audiopara.character.gainthresholdmax, GAIN_MAX); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudioCaptureCheckSceneCapability +* @tc.number SUB_Audio_HDI_AudioCaptureCheckSceneCapability_Performance_0001 +* @tc.devDesc tests the performace of AudioCaptureCheckSceneCapability interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureCheckSceneCapability_Performance_0001, + TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0 + }; + struct AudioSceneDescriptor scenes = { .scene.id = 0, .desc.pins = PIN_IN_MIC }; + bool supported = false; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateCapture(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.capture); + ASSERT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.capture->scene.CheckSceneCapability(audiopara.capture, &scenes, &supported); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudioCaptureSelectScene +* @tc.number SUB_Audio_HDI_AudioCaptureSelectScene_Performance_0001 +* @tc.devDesc tests the performace of AudioCaptureSelectScene interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureSelectScene_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0 + }; + struct AudioSceneDescriptor scenes = { .scene.id = 0, .desc.pins = PIN_IN_MIC }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateCapture(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.capture); + ASSERT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.capture->scene.SelectScene(audiopara.capture, &scenes); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudioGetCapturePosition +* @tc.number SUB_Audio_HDI_AudioGetCapturePosition_Performance_0001 +* @tc.devDesc tests the performace of AudioCaptureGetCapturePosition interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioGetCapturePosition_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateCapture(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.capture); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = audiopara.capture->control.Start((AudioHandle)audiopara.capture); + EXPECT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.capture->GetCapturePosition(audiopara.capture, &audiopara.character.getframes, &audiopara.time); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + ret = StopAudio(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); +} +} diff --git a/audio/test/systemtest/hdi/hdiperformace/src/audio_hdirender_performace_test.cpp b/audio/test/systemtest/hdi/hdiperformace/src/audio_hdirender_performace_test.cpp new file mode 100755 index 0000000000..9222704c04 --- /dev/null +++ b/audio/test/systemtest/hdi/hdiperformace/src/audio_hdirender_performace_test.cpp @@ -0,0 +1,1375 @@ +/* + * 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. + */ + +/** + * @addtogroup Audio + * @{ + * + * @brief Test the delayTime of audio playback interface. + * + * @since 1.0 + * @version 1.0 + */ + +/** + * @file audio_hdi_common.h + * + * @brief Declares APIs for operations related to the audio delayTime. + * + * @since 1.0 + * @version 1.0 + */ + +#include "audio_hdi_common.h" +#include "audio_hdirender_performace_test.h" + +using namespace std; +using namespace testing::ext; +using namespace HMOS::Audio; + +namespace { +const string ADAPTER_NAME_USB = "usb"; +const float COUNT = 1000; +const long LOWLATENCY = 10000; +const long NORMALLATENCY = 30000; +const long HIGHLATENCY = 60000; + +class AudioHdiRenderPerformaceTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + static TestAudioManager *(*GetAudioManager)(); + static void *handleSo; +#ifdef AUDIO_MPI_SO + static int32_t (*SdkInit)(); + static void (*SdkExit)(); + static void *sdkSo; +#endif +}; + +TestAudioManager *(*AudioHdiRenderPerformaceTest::GetAudioManager)() = nullptr; +void *AudioHdiRenderPerformaceTest::handleSo = nullptr; +#ifdef AUDIO_MPI_SO + int32_t (*AudioHdiRenderPerformaceTest::SdkInit)() = nullptr; + void (*AudioHdiRenderPerformaceTest::SdkExit)() = nullptr; + void *AudioHdiRenderPerformaceTest::sdkSo = nullptr; +#endif + +void AudioHdiRenderPerformaceTest::SetUpTestCase(void) +{ +#ifdef AUDIO_MPI_SO + char sdkResolvedPath[] = "//system/lib/libhdi_audio_interface_lib_render.z.so"; + sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY); + if (sdkSo == nullptr) { + return; + } + SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit")); + if (SdkInit == nullptr) { + return; + } + SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit")); + if (SdkExit == nullptr) { + return; + } + SdkInit(); +#endif + handleSo = dlopen(RESOLVED_PATH.c_str(), RTLD_LAZY); + if (handleSo == nullptr) { + return; + } + GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str())); + if (GetAudioManager == nullptr) { + return; + } +} + +void AudioHdiRenderPerformaceTest::TearDownTestCase(void) +{ +#ifdef AUDIO_MPI_SO + if (SdkExit != nullptr) { + SdkExit(); + } + if (sdkSo != nullptr) { + dlclose(sdkSo); + sdkSo = nullptr; + } + if (SdkInit != nullptr) { + SdkInit = nullptr; + } + if (SdkExit != nullptr) { + SdkExit = nullptr; + } +#endif + if (GetAudioManager != nullptr) { + GetAudioManager = nullptr; + } +} + +void AudioHdiRenderPerformaceTest::SetUp(void) {} + +void AudioHdiRenderPerformaceTest::TearDown(void) {} + +/** +* @tc.name the performace of AudioManagerGetAllAdapters +* @tc.number SUB_Audio_HDI_AudioManagerGetAllAdapter_Performance_0001 +* @tc.desc tests the performace of AudioManagerGetAllAdapters interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudioManagerGetAllAdapters_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + int size = 0; + struct PrepareAudioPara audiopara = { .totalTime = 0 }; + + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.manager->GetAllAdapters(audiopara.manager, &audiopara.descs, &size); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); +} + +/** +* @tc.name the performace of AudioManagerLoadAdapter +* @tc.number SUB_Audio_HDI_AudioManagerLoadAdapter_Performance_0001 +* @tc.desc tests the performace of AudioManagerLoadAdapter interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudioManagerLoadAdapter_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + int size = 0; + struct PrepareAudioPara audiopara = { .totalTime = 0 }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = audiopara.manager->GetAllAdapters(audiopara.manager, &audiopara.descs, &size); + ASSERT_EQ(HDF_SUCCESS, ret); + audiopara.desc = &audiopara.descs[0]; + ASSERT_NE(nullptr, audiopara.desc); + + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.manager->LoadAdapter(audiopara.manager, audiopara.desc, &audiopara.adapter); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); +} + +/** +* @tc.name the performace of AudioManagerUnLoadAdapter +* @tc.number SUB_Audio_HDI_AudioManagerUnLoadAdapter_Performance_0001 +* @tc.desc tests the performace of AudioManagerLoadAdapter interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudioManagerUnLoadAdapter_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + int size = 0; + struct PrepareAudioPara audiopara = { .totalTime = 0 }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = audiopara.manager->GetAllAdapters(audiopara.manager, &audiopara.descs, &size); + ASSERT_EQ(HDF_SUCCESS, ret); + audiopara.desc = &audiopara.descs[0]; + ASSERT_NE(nullptr, audiopara.desc); + + for (int i = 0; i < COUNT; ++i) { + ret = audiopara.manager->LoadAdapter(audiopara.manager, audiopara.desc, &audiopara.adapter); + ASSERT_EQ(HDF_SUCCESS, ret); + gettimeofday(&audiopara.start, NULL); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); + gettimeofday(&audiopara.end, NULL); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); +} + +/** +* @tc.name the performace of AudioInitAllPorts +* @tc.number SUB_Audio_HDI_AudioManagerInitAllPorts_Performance_0001 +* @tc.desc tests the performace of AudioInitAllPorts interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudioManagerInitAllPorts_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = GetLoadAdapter(*audiopara.manager, audiopara.portType, audiopara.adapterName, + &audiopara.adapter, audiopara.audioPort); + ASSERT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.adapter->InitAllPorts(audiopara.adapter); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudioGetPortCapability +* @tc.number SUB_Audio_HDI_AudioGetPortCapability_Performance_0001 +* @tc.desc tests the performace of AudioGetPortCapability interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudioGetPortCapability_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = GetLoadAdapter(*audiopara.manager, audiopara.portType, audiopara.adapterName, + &audiopara.adapter, audiopara.audioPort); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = audiopara.adapter->InitAllPorts(audiopara.adapter); + EXPECT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.adapter->GetPortCapability(audiopara.adapter, &audiopara.audioPort, &audiopara.capability); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudioSetPassthroughMode +* @tc.number SUB_Audio_HDI_AudioSetPassthroughMode_Performance_0001 +* @tc.desc tests the performace of AudioSetPassthroughMode interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudioSetPassthroughMode_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .mode = PORT_PASSTHROUGH_LPCM, + .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = GetLoadAdapter(*audiopara.manager, audiopara.portType, audiopara.adapterName, + &audiopara.adapter, audiopara.audioPort); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = audiopara.adapter->InitAllPorts(audiopara.adapter); + EXPECT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.adapter->SetPassthroughMode(audiopara.adapter, &audiopara.audioPort, audiopara.mode); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + ret = audiopara.adapter->GetPassthroughMode(audiopara.adapter, &audiopara.audioPort, &audiopara.mode); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(PORT_PASSTHROUGH_LPCM, audiopara.mode); + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudioGetPassthroughMode +* @tc.number SUB_Audio_HDI_AudioGetPassthroughMode_Performance_0001 +* @tc.desc tests the performace of AudioGetPassthroughMode interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudioGetPassthroughMode_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .mode = PORT_PASSTHROUGH_LPCM, + .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = GetLoadAdapter(*audiopara.manager, audiopara.portType, audiopara.adapterName, + &audiopara.adapter, audiopara.audioPort); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = audiopara.adapter->InitAllPorts(audiopara.adapter); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.adapter->SetPassthroughMode(audiopara.adapter, &audiopara.audioPort, audiopara.mode); + EXPECT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.adapter->GetPassthroughMode(audiopara.adapter, &audiopara.audioPort, &audiopara.mode); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(PORT_PASSTHROUGH_LPCM, audiopara.mode); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudioRenderGetLatency +* @tc.number SUB_Audio_HDI_AudioRenderGetLatency_Performance_0001 +* @tc.desc tests the performace of AudioRenderGetLatency interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudioRenderGetLatency_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str(), .totalTime = 0 + }; + uint32_t latencyTimeExpc = 0; + uint32_t latencyTime = 0; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = PlayAudioFile(audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.render->GetLatency(audiopara.render, &latencyTime); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_LT(latencyTimeExpc, latencyTime); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + ret = StopAudio(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); +} + +/** +* @tc.name the performace of AudioCreateRender +* @tc.number SUB_Audio_HDI_AudioCreateRender_Performance_0001 +* @tc.desc tests the performace of AudioCreateRender interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudioCreateRender_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER, + .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = GetLoadAdapter(*audiopara.manager, audiopara.portType, audiopara.adapterName, + &audiopara.adapter, audiopara.audioPort); + ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrs(audiopara.attrs); + InitDevDesc(audiopara.devDesc, audiopara.audioPort.portId, audiopara.pins); + + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.adapter->CreateRender(audiopara.adapter, &audiopara.devDesc, &audiopara.attrs, + &audiopara.render); + gettimeofday(&audiopara.end, NULL); + if (ret < 0 || audiopara.render == nullptr) { + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); + ASSERT_EQ(HDF_SUCCESS, ret); + } + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(HIGHLATENCY, audiopara.averageDelayTime); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudioDestroyRender +* @tc.number SUB_Audio_HDI_AudioDestroyRender_Performance_0001 +* @tc.desc tests the performace of AudioDestroyRender interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudioDestroyRender_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER, + .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = GetLoadAdapter(*audiopara.manager, audiopara.portType, audiopara.adapterName, + &audiopara.adapter, audiopara.audioPort); + ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrs(audiopara.attrs); + InitDevDesc(audiopara.devDesc, audiopara.audioPort.portId, audiopara.pins); + for (int i = 0; i < COUNT; ++i) { + ret = audiopara.adapter->CreateRender(audiopara.adapter, &audiopara.devDesc, &audiopara.attrs, + &audiopara.render); + if (ret < 0 || audiopara.render == nullptr) { + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); + ASSERT_EQ(HDF_SUCCESS, ret); + } + gettimeofday(&audiopara.start, NULL); + audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); + gettimeofday(&audiopara.end, NULL); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudioRenderGetRenderPosition +* @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_Performance_0001 +* @tc.desc tests the performace of AudioRenderGetRenderPosition interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str(), .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = PlayAudioFile(audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.render->GetRenderPosition(audiopara.render, &audiopara.character.getframes, &audiopara.time); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + ret = StopAudio(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); +} + +/** +* @tc.name the performace of AudioRenderSetRenderSpeed +* @tc.number SUB_Audio_HDI_AudioRenderSetRenderSpeed_Performance_0001 +* @tc.desc tests the performace of AudioRenderSetRenderSpeed interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudioRenderSetRenderSpeed_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + float speedNormal = 30; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER, + .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateRender(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.render); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->control.Start((AudioHandle)audiopara.render); + EXPECT_EQ(HDF_SUCCESS, ret); + + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.render->SetRenderSpeed(audiopara.render, speedNormal); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); + ret = audiopara.render->GetRenderSpeed(audiopara.render, &speedNormal); + EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + ret = StopAudio(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); +} + +/** +* @tc.name the performace of AudioRenderGetRenderSpeed +* @tc.number SUB_Audio_HDI_AudioRenderGetRenderSpeed_Performance_0001 +* @tc.desc tests the performace of AudioRenderGetRenderSpeed interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudioRenderGetRenderSpeed_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + float speedValue = 30; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER, + .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateRender(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.render); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->control.Start((AudioHandle)audiopara.render); + EXPECT_EQ(HDF_SUCCESS, ret); + + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.render->GetRenderSpeed(audiopara.render, &speedValue); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + ret = StopAudio(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); +} + +/** +* @tc.name the performace of AudioRenderSetChannelMode +* @tc.number SUB_Audio_HDI_AudioRenderSetChannelMode_Performance_0001 +* @tc.desc tests the performace of AudioRenderSetChannelMode interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudioRenderSetChannelMode_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER, + .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateRender(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.render); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->control.Start((AudioHandle)audiopara.render); + EXPECT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.render->SetChannelMode(audiopara.render, mode); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + ret = audiopara.render->GetChannelMode(audiopara.render, &mode); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode); + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + ret = StopAudio(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); +} + +/** +* @tc.name the performace of AudioRenderGetChannelMode +* @tc.number SUB_Audio_HDI_AudioRenderGetChannelMode_Performance_0001 +* @tc.desc tests the performace of AudioRenderGetChannelMode interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudioRenderGetChannelMode_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER, + .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateRender(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.render); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->control.Start((AudioHandle)audiopara.render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->SetChannelMode(audiopara.render, mode); + EXPECT_EQ(HDF_SUCCESS, ret); + + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.render->GetChannelMode(audiopara.render, &mode); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + ret = StopAudio(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); +} + +/** +* @tc.name the performace of AudioRenderGetFrameCount +* @tc.number SUB_Audio_HDI_AudioRenderGetFrameCount_Performance_0001 +* @tc.desc tests the performace of AudioRenderGetFrameCount interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudioRenderGetFrameCount_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER, + .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateRender(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.render); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->control.Start((AudioHandle)audiopara.render); + EXPECT_EQ(HDF_SUCCESS, ret); + + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.render->attr.GetFrameCount(audiopara.render, &audiopara.character.getframecount); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + ret = StopAudio(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); +} + +/** +* @tc.name the performace of AudioRenderGetCurrentChannelId +* @tc.number SUB_Audio_HDI_AudioRenderGetCurrentChannelId_Performance_0001 +* @tc.desc tests the performace of AudioRenderGetCurrentChannelId interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudioRenderGetCurrentChannelId_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER, + .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateRender(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.render); + ASSERT_EQ(HDF_SUCCESS, ret); + + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.render->attr.GetCurrentChannelId(audiopara.render, &audiopara.character.getcurrentchannelId); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudioRenderFlush +* @tc.number SUB_Audio_HDI_AudioRenderFlush_Performance_0001 +* @tc.desc tests the performace of AudioRenderFlush interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudioRenderFlush_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER, + .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + + for (int i = 0; i < COUNT; ++i) { + ret = AudioCreateRender(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.render); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->control.Start((AudioHandle)audiopara.render); + EXPECT_EQ(HDF_SUCCESS, ret); + gettimeofday(&audiopara.start, NULL); + ret = audiopara.render->control.Flush((AudioHandle)audiopara.render); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + ret = StopAudio(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); +} + +/** +* @tc.name the performace of AudioRenderGetFrameSize +* @tc.number SUB_Audio_HDI_AudioRenderGetFrameSize_Performance_0001 +* @tc.desc tests the performace of AudioRenderGetFrameSize interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudioRenderGetFrameSize_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + uint64_t zero = 0; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER, + .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateRender(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.render); + ASSERT_EQ(HDF_SUCCESS, ret); + + for (int i = 0; i < COUNT; ++i) { + ret = audiopara.render->control.Start((AudioHandle)audiopara.render); + EXPECT_EQ(HDF_SUCCESS, ret); + gettimeofday(&audiopara.start, NULL); + ret = audiopara.render->attr.GetFrameSize(audiopara.render, &audiopara.character.getframesize); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(audiopara.character.getframesize, zero); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + ret = audiopara.render->control.Stop((AudioHandle)audiopara.render); + EXPECT_EQ(HDF_SUCCESS, ret); + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + + +/** +* @tc.name the performace of AudioRenderCheckSceneCapability +* @tc.number SUB_Audio_HDI_AudioRenderCheckSceneCapability_Performance_0001 +* @tc.desc tests the performace of AudioRenderCheckSceneCapability interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudioRenderCheckSceneCapability_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER, + .totalTime = 0 + }; + struct AudioSceneDescriptor scenes = {.scene.id = 0, .desc.pins = PIN_OUT_SPEAKER}; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateRender(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.render); + ASSERT_EQ(HDF_SUCCESS, ret); + + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.render->scene.CheckSceneCapability(audiopara.render, &scenes, &audiopara.character.supported); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudioRenderSelectScene +* @tc.number SUB_Audio_HDI_AudioRenderSelectScene_Performance_0001 +* @tc.desc tests the performace of AudioRenderSelectScene interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudioRenderSelectScene_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER, + .totalTime = 0 + }; + struct AudioSceneDescriptor scenes = {.scene.id = 0, .desc.pins = PIN_OUT_SPEAKER}; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateRender(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.render); + ASSERT_EQ(HDF_SUCCESS, ret); + + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.render->scene.SelectScene(audiopara.render, &scenes); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + ret = AudioRenderStartAndOneFrame(audiopara.render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->control.Stop((AudioHandle)audiopara.render); + EXPECT_EQ(HDF_SUCCESS, ret); + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudiorenderSetMute +* @tc.number SUB_Audio_HDI_AudiorenderSetMute_Performance_0001 +* @tc.desc tests the performace of AudiorenderSetMute interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudiorenderSetMute_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER, + .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateRender(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.render); + ASSERT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.render->volume.SetMute(audiopara.render, false); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + ret = audiopara.render->volume.GetMute(audiopara.render, &audiopara.character.getmute); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_FALSE(audiopara.character.getmute); + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudiorenderGetMute +* @tc.number SUB_Audio_HDI_AudiorenderGetMute_Performance_0001 +* @tc.desc tests the performace of AudiorenderGetMute interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudiorenderGetMute_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER, + .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateRender(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.render); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->volume.SetMute(audiopara.render, false); + EXPECT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.render->volume.GetMute(audiopara.render, &audiopara.character.getmute); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_FALSE(audiopara.character.getmute); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudiorenderSetVolume +* @tc.number SUB_Audio_HDI_AudiorenderSetVolume_Performance_0001 +* @tc.desc tests the performace of AudiorenderSetVolume interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudiorenderSetVolume_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER, + .character.setvolume = 0.8, .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateRender(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.render); + ASSERT_EQ(HDF_SUCCESS, ret); + + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.render->volume.SetVolume(audiopara.render, audiopara.character.setvolume); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + ret = audiopara.render->volume.GetVolume(audiopara.render, &audiopara.character.getvolume); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(audiopara.character.setvolume, audiopara.character.getvolume); + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudiorenderGetVolume +* @tc.number SUB_Audio_HDI_AudiorenderGetVolume_Performance_0001 +* @tc.desc tests the performace of AudiorenderGetVolume interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudiorenderGetVolume_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER, + .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateRender(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.render); + ASSERT_EQ(HDF_SUCCESS, ret); + + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.render->volume.GetVolume(audiopara.render, &audiopara.character.getvolume); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudiorenderGetGainThreshold +* @tc.number SUB_Audio_HDI_AudiorenderGetGainThreshold_Performance_0001 +* @tc.desc tests the performace of AudiorenderGetGainThreshold interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudiorenderGetGainThreshold_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER, + .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateRender(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.render); + ASSERT_EQ(HDF_SUCCESS, ret); + + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.render->volume.GetGainThreshold(audiopara.render, &audiopara.character.gainthresholdmin, + &audiopara.character.gainthresholdmax); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudiorenderGetGain +* @tc.number SUB_Audio_HDI_AudiorenderGetGain_Performance_0001 +* @tc.desc tests the performace of AudiorenderGetGain interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudiorenderGetGain_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER, + .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateRender(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.render); + ASSERT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.render->volume.GetGain(audiopara.render, &audiopara.character.getgain); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudiorenderSetGain +* @tc.number SUB_Audio_HDI_AudiorenderSetGain_Performance_0001 +* @tc.desc tests the performace of AudiorenderSetGain interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudiorenderSetGain_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER, + .character.setgain = 7, .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateRender(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.render); + ASSERT_EQ(HDF_SUCCESS, ret); + + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.render->volume.SetGain(audiopara.render, audiopara.character.setgain); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + ret = audiopara.render->volume.GetGain(audiopara.render, &audiopara.character.getgain); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(audiopara.character.setgain, audiopara.character.getgain); + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} + +/** +* @tc.name the performace of AudioRenderFrame +* @tc.number SUB_Audio_HDI_AudioRenderFrame_Performance_0001 +* @tc.desc tests the performace of AudioRenderFrame interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudioRenderFrame_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str(), .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + + for (int i = 0; i < COUNT; ++i) { + ret = AudioCreateRender(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.render); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->control.Start((AudioHandle)audiopara.render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = RenderFramePrepare(audiopara.path, audiopara.frame, audiopara.requestBytes); + EXPECT_EQ(HDF_SUCCESS, ret); + gettimeofday(&audiopara.start, NULL); + ret = audiopara.render->RenderFrame(audiopara.render, audiopara.frame, audiopara.requestBytes, + &audiopara.replyBytes); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + ret = StopAudio(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); + if (audiopara.frame != nullptr) { + free(audiopara.frame); + audiopara.frame = nullptr; + } + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(NORMALLATENCY, audiopara.averageDelayTime); +} + +/** +* @tc.name the performace of AudioRenderStart +* @tc.number SUB_Audio_HDI_AudioRenderStart_Performance_0001 +* @tc.desc tests the performace of AudioRenderStart interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudioRenderStart_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER, + .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + + for (int i = 0; i < COUNT; ++i) { + ret = AudioCreateRender(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.render); + ASSERT_EQ(HDF_SUCCESS, ret); + gettimeofday(&audiopara.start, NULL); + ret = audiopara.render->control.Start((AudioHandle)audiopara.render); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + ret = StopAudio(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); +} +/** +* @tc.name the performace of AudioRenderPause +* @tc.number SUB_Audio_HDI_AudioRenderPause_Performance_0001 +* @tc.desc tests the performace of AudioRenderPause interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudioRenderPause_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER, + .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateRender(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.render); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->control.Start((AudioHandle)audiopara.render); + EXPECT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.render->control.Pause((AudioHandle)audiopara.render); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->control.Resume((AudioHandle)audiopara.render); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + ret = StopAudio(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); +} + +/** +* @tc.name the performace of AudioRenderResume +* @tc.number SUB_Audio_HDI_AudioRenderResume_Performance_0001 +* @tc.desc tests the performace of AudioRenderResume interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudioRenderResume_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER, + .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateRender(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.render); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->control.Start((AudioHandle)audiopara.render); + EXPECT_EQ(HDF_SUCCESS, ret); + for (int i = 0; i < COUNT; ++i) { + ret = audiopara.render->control.Pause((AudioHandle)audiopara.render); + EXPECT_EQ(HDF_SUCCESS, ret); + gettimeofday(&audiopara.start, NULL); + ret = audiopara.render->control.Resume((AudioHandle)audiopara.render); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + ret = StopAudio(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); +} +/** +* @tc.name the performace of AudioRenderGetSampleAttributes +* @tc.number SUB_Audio_HDI_AudioRenderGetSampleAttributes_Performance_0001 +* @tc.desc tests the performace of AudioRenderGetSampleAttributes interface by executing 1000 times, +* and calculates the delay time and average of Delay Time. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiRenderPerformaceTest, SUB_Audio_HDI_AudioRenderGetSampleAttributes_Performance_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER, + .totalTime = 0 + }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + ret = AudioCreateRender(*audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter, + &audiopara.render); + ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrs(audiopara.attrs); + + for (int i = 0; i < COUNT; ++i) { + gettimeofday(&audiopara.start, NULL); + ret = audiopara.render->attr.GetSampleAttributes(audiopara.render, &audiopara.attrs); + gettimeofday(&audiopara.end, NULL); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) - + (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec); + audiopara.totalTime += audiopara.delayTime; + } + audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT; + EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime); + audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} +} diff --git a/audio/test/systemtest/hdi/hdireliability/BUILD.gn b/audio/test/systemtest/hdi/hdireliability/BUILD.gn index b6e134b925..12e022fd57 100755 --- a/audio/test/systemtest/hdi/hdireliability/BUILD.gn +++ b/audio/test/systemtest/hdi/hdireliability/BUILD.gn @@ -11,168 +11,393 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build/test.gni") -import("//drivers/adapter/uhdf2/uhdf.gni") +if (defined(ohos_lite)) { + import("//build/lite/config/test.gni") +} else { + import("//build/test.gni") + import("//drivers/adapter/uhdf2/uhdf.gni") + import("//drivers/peripheral/audio/audio.gni") +} -module_output_path = "hdf/audio/systemtest/hdi" -###########################systemtest############################## -###########################AudioHdiRenderReliabilityTest########################### -ohos_systemtest("AudioHdiRenderReliabilityTest") { - module_out_path = module_output_path - sources = [ - "src/audio_hdirender_reliability_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] +if (defined(ohos_lite)) { +###########################LITEOS########################################## + ###########################hdf_audio_hdi_render_reliability_test########################### + unittest("hdf_audio_hdi_render_reliability_test") { + sources = [ + "src/audio_hdirender_reliability_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] - include_dirs = [ - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/interfaces/include", - "//drivers/framework/include/core", - "//drivers/framework/include/utils", - "//drivers/framework/include/osal", - "//drivers/framework/include", - "//third_party/bounds_checking_function/include", - "//utils/native/base/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/framework/utils/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/adapter/uhdf2/osal/include", - "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", - "//third_party/googletest/googletest/include/gtest", - "//drivers/peripheral/audio/test/systemtest/hdi/hdireliability/include", - ] - deps = [ - "//utils/native/base:utils", - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - ] - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - ] -} -###########################end########################### -###########################AudioHdiCaptureReliabilityTest########################### -ohos_systemtest("AudioHdiCaptureReliabilityTest") { - module_out_path = module_output_path - sources = [ - "src/audio_hdicapture_reliability_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + include_dirs = [ + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/include", + "//drivers/framework/core/sec/include", + "//drivers/framework/core/shared/include", + "//drivers/framework/core/host/include", + "//drivers/framework/core/manager/include", + "//drivers/framework/core/common/include/host/", + "//third_party/bounds_checking_function/include", + "//drivers/adapter/khdf/liteos/osal/include", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/adapter/uhdf2/include/hdi/" , + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/hdireliability/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + "-std=c++11" + ] - include_dirs = [ - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/interfaces/include", - "//drivers/framework/include/core", - "//drivers/framework/include/utils", - "//drivers/framework/include/osal", - "//drivers/framework/include", - "//third_party/bounds_checking_function/include", - "//utils/native/base/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/framework/utils/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/adapter/uhdf2/osal/include", - "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", - "//third_party/googletest/googletest/include/gtest", - "//drivers/peripheral/audio/test/systemtest/hdi/hdireliability/include", - ] - deps = [ - "//utils/native/base:utils", - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - ] - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - ] -} -###########################end########################### -###########################AudioHdiCaptureControlReliabilityTest########################### -ohos_systemtest("AudioHdiCaptureControlReliabilityTest") { - module_out_path = module_output_path - sources = [ - "src/audio_hdicapture_control_reliability_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + deps = [ + "//third_party/bounds_checking_function:libsec_shared" + ] + } + ###########################end########################### + ###########################hdf_audio_hdi_capture_reliability_test########################### + unittest("hdf_audio_hdi_capture_reliability_test") { + sources = [ + "src/audio_hdicapture_reliability_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] - include_dirs = [ - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/interfaces/include", - "//drivers/framework/include/core", - "//drivers/framework/include/utils", - "//drivers/framework/include/osal", - "//drivers/framework/include", - "//third_party/bounds_checking_function/include", - "//utils/native/base/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/framework/utils/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/adapter/uhdf2/osal/include", - "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", - "//third_party/googletest/googletest/include/gtest", - "//drivers/peripheral/audio/test/systemtest/hdi/hdireliability/include", - ] - deps = [ - "//utils/native/base:utils", - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - ] - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - ] -} -###########################end########################### -###########################AudioHdiRenderControlReliabilityTest########################### -ohos_systemtest("AudioHdiRenderControlReliabilityTest") { - module_out_path = module_output_path - sources = [ - "src/audio_hdirender_control_reliability_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + include_dirs = [ + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/include", + "//drivers/framework/core/sec/include", + "//drivers/framework/core/shared/include", + "//drivers/framework/core/host/include", + "//drivers/framework/core/manager/include", + "//drivers/framework/core/common/include/host/", + "//third_party/bounds_checking_function/include", + "//drivers/adapter/khdf/liteos/osal/include", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/adapter/uhdf2/include/hdi/" , + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/hdireliability/include", + ] + + deps = [ + "//third_party/bounds_checking_function:libsec_shared" + ] + } + ###########################end########################### + ###########################hdf_audio_hdi_capture_control_reliability_test########################### + unittest("hdf_audio_hdi_capture_control_reliability_test") { + sources = [ + "src/audio_hdicapture_control_reliability_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] + + include_dirs = [ + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/include", + "//drivers/framework/core/sec/include", + "//drivers/framework/core/shared/include", + "//drivers/framework/core/host/include", + "//drivers/framework/core/manager/include", + "//drivers/framework/core/common/include/host/", + "//third_party/bounds_checking_function/include", + "//drivers/adapter/khdf/liteos/osal/include", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/adapter/uhdf2/include/hdi/" , + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/hdireliability/include", + ] + + deps = [ + "//third_party/bounds_checking_function:libsec_shared" + ] + } + ###########################end########################### + ###########################hdf_audio_hdi_render_control_reliability_test########################### + unittest("hdf_audio_hdi_render_control_reliability_test") { + sources = [ + "src/audio_hdirender_control_reliability_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] + + include_dirs = [ + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/include", + "//drivers/framework/core/sec/include", + "//drivers/framework/core/shared/include", + "//drivers/framework/core/host/include", + "//drivers/framework/core/manager/include", + "//drivers/framework/core/common/include/host/", + "//third_party/bounds_checking_function/include", + "//drivers/adapter/khdf/liteos/osal/include", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/adapter/uhdf2/include/hdi/" , + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/hdireliability/include", + ] + + deps = [ + "//third_party/bounds_checking_function:libsec_shared" + ] + } +} else { + ###########################systemtest############################## + module_output_path = "hdf/audio" + ###########################hdf_audio_hdi_render_reliability_test########################### + ohos_systemtest("hdf_audio_hdi_render_reliability_test") { + module_out_path = module_output_path + sources = [ + "src/audio_hdirender_reliability_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] + + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/include", + "//third_party/bounds_checking_function/include", + "//utils/native/base/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/adapter/uhdf2/osal/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/hdireliability/include", + ] + deps = [ + "//utils/native/base:utils", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + defines = [] + if (enable_audio_adm_so) { + defines += [ "AUDIO_ADM_SO" ] + } + if (enable_audio_mpi_so) { + defines += [ "AUDIO_MPI_SO" ] + } + if (enable_audio_adm_service) { + defines += [ "AUDIO_ADM_SERVICE" ] + } + if (enable_audio_mpi_service) { + defines += [ "AUDIO_MPI_SERVICE" ] + } + } + ###########################end########################### + ###########################hdf_audio_hdi_capture_reliability_test########################### + ohos_systemtest("hdf_audio_hdi_capture_reliability_test") { + module_out_path = module_output_path + sources = [ + "src/audio_hdicapture_reliability_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] + + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/include", + "//third_party/bounds_checking_function/include", + "//utils/native/base/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/adapter/uhdf2/osal/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/hdireliability/include", + ] + deps = [ + "//utils/native/base:utils", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + defines = [] + if (enable_audio_adm_so) { + defines += [ "AUDIO_ADM_SO" ] + } + if (enable_audio_mpi_so) { + defines += [ "AUDIO_MPI_SO" ] + } + if (enable_audio_adm_service) { + defines += [ "AUDIO_ADM_SERVICE" ] + } + if (enable_audio_mpi_service) { + defines += [ "AUDIO_MPI_SERVICE" ] + } + } + ###########################end########################### + ###########################hdf_audio_hdi_capture_control_reliability_test########################### + ohos_systemtest("hdf_audio_hdi_capture_control_reliability_test") { + module_out_path = module_output_path + sources = [ + "src/audio_hdicapture_control_reliability_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] + + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/include", + "//third_party/bounds_checking_function/include", + "//utils/native/base/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/adapter/uhdf2/osal/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/hdireliability/include", + ] + deps = [ + "//utils/native/base:utils", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + defines = [] + if (enable_audio_adm_so) { + defines += [ "AUDIO_ADM_SO" ] + } + if (enable_audio_mpi_so) { + defines += [ "AUDIO_MPI_SO" ] + } + if (enable_audio_adm_service) { + defines += [ "AUDIO_ADM_SERVICE" ] + } + if (enable_audio_mpi_service) { + defines += [ "AUDIO_MPI_SERVICE" ] + } + } + ###########################end########################### + ###########################hdf_audio_hdi_render_control_reliability_test########################### + ohos_systemtest("hdf_audio_hdi_render_control_reliability_test") { + module_out_path = module_output_path + sources = [ + "src/audio_hdirender_control_reliability_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] - include_dirs = [ - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/interfaces/include", - "//drivers/framework/include/core", - "//drivers/framework/include/utils", - "//drivers/framework/include/osal", - "//drivers/framework/include", - "//third_party/bounds_checking_function/include", - "//utils/native/base/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/framework/utils/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/adapter/uhdf2/osal/include", - "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", - "//third_party/googletest/googletest/include/gtest", - "//drivers/peripheral/audio/test/systemtest/hdi/hdireliability/include", - ] - deps = [ - "//utils/native/base:utils", - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - ] - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - ] + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/include", + "//third_party/bounds_checking_function/include", + "//utils/native/base/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/adapter/uhdf2/osal/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/hdireliability/include", + ] + deps = [ + "//utils/native/base:utils", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + defines = [] + if (enable_audio_adm_so) { + defines += [ "AUDIO_ADM_SO" ] + } + if (enable_audio_mpi_so) { + defines += [ "AUDIO_MPI_SO" ] + } + if (enable_audio_adm_service) { + defines += [ "AUDIO_ADM_SERVICE" ] + } + if (enable_audio_mpi_service) { + defines += [ "AUDIO_MPI_SERVICE" ] + } + } } ###########################end########################### \ No newline at end of file diff --git a/audio/test/systemtest/hdi/hdireliability/include/audio_hdicapture_control_reliability_test.h b/audio/test/systemtest/hdi/hdireliability/include/audio_hdicapture_control_reliability_test.h old mode 100644 new mode 100755 diff --git a/audio/test/systemtest/hdi/hdireliability/include/audio_hdirender_control_reliability_test.h b/audio/test/systemtest/hdi/hdireliability/include/audio_hdirender_control_reliability_test.h old mode 100644 new mode 100755 diff --git a/audio/test/systemtest/hdi/hdireliability/src/audio_hdicapture_control_reliability_test.cpp b/audio/test/systemtest/hdi/hdireliability/src/audio_hdicapture_control_reliability_test.cpp old mode 100644 new mode 100755 index 299cc1180d..e544e59111 --- a/audio/test/systemtest/hdi/hdireliability/src/audio_hdicapture_control_reliability_test.cpp +++ b/audio/test/systemtest/hdi/hdireliability/src/audio_hdicapture_control_reliability_test.cpp @@ -22,10 +22,9 @@ using namespace testing::ext; using namespace HMOS::Audio; namespace { -const string AUDIO_FILE = "//bin/audiocapturetest.wav"; -const string ADAPTER_NAME = "hdmi"; -const string ADAPTER_NAME2 = "usb"; -const string ADAPTER_NAME3 = "internal"; +const string ADAPTER_NAME_HDMI = "hdmi"; +const string ADAPTER_NAME_USB = "usb"; +const string ADAPTER_NAME_INTERNAL = "internal"; const int PTHREAD_SAMEADA_COUNT = 3; const int PTHREAD_DIFFADA_COUNT = 2; const int BUFFER_SIZE = 16384; @@ -36,78 +35,96 @@ public: static void TearDownTestCase(void); void SetUp(); void TearDown(); - struct AudioManager *(*GetAudioManager)() = nullptr; - void *handleSo = nullptr; - static int32_t RelAudioCreateCapture(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioCaptureStart(struct RelCaptureAdapterPara& ptr); - static int32_t RelGetAllAdapter(struct RelCaptureAdapterPara& ptr); - static int32_t RelLoadAdapter(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioCaptureStop(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioCaptureResume(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioCapturePause(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioCaptureProcedure(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioCaptureFrame(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioCaptureStartAndCaputreFrame(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioAdapterInitAllPorts(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioAdapterGetPortCapability(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioAdapterSetPassthroughMode(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioAdapterGetPassthroughMode(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioCaptureGetCapturePosition(struct RelCaptureAdapterPara& ptr); + static TestAudioManager *(*GetAudioManager)(); + static void *handleSo; +#ifdef AUDIO_MPI_SO + static int32_t (*SdkInit)(); + static void (*SdkExit)(); + static void *sdkSo; +#endif + static int32_t RelAudioCreateCapture(struct PrepareAudioPara& ptr); + static int32_t RelAudioCaptureStart(struct PrepareAudioPara& ptr); + static int32_t RelGetAllAdapter(struct PrepareAudioPara& ptr); + static int32_t RelLoadAdapter(struct PrepareAudioPara& ptr); + static int32_t RelAudioCaptureStop(struct PrepareAudioPara& ptr); + static int32_t RelAudioCaptureResume(struct PrepareAudioPara& ptr); + static int32_t RelAudioCapturePause(struct PrepareAudioPara& ptr); + static int32_t RelAudioCaptureProcedure(struct PrepareAudioPara& ptr); + static int32_t RelAudioCaptureFrame(struct PrepareAudioPara& ptr); + static int32_t RelAudioCaptureStartAndCaputreFrame(struct PrepareAudioPara& ptr); + static int32_t RelAudioAdapterInitAllPorts(struct PrepareAudioPara& ptr); + static int32_t RelAudioAdapterGetPortCapability(struct PrepareAudioPara& ptr); + static int32_t RelAudioAdapterSetPassthroughMode(struct PrepareAudioPara& ptr); + static int32_t RelAudioAdapterGetPassthroughMode(struct PrepareAudioPara& ptr); + static int32_t RelAudioCaptureGetCapturePosition(struct PrepareAudioPara& ptr); }; using THREAD_FUNC = void *(*)(void *); -void AudioHdiCaptureControlReliabilityTest::SetUpTestCase(void) {} +TestAudioManager *(*AudioHdiCaptureControlReliabilityTest::GetAudioManager)() = nullptr; +void *AudioHdiCaptureControlReliabilityTest::handleSo = nullptr; +#ifdef AUDIO_MPI_SO + int32_t (*AudioHdiCaptureControlReliabilityTest::SdkInit)() = nullptr; + void (*AudioHdiCaptureControlReliabilityTest::SdkExit)() = nullptr; + void *AudioHdiCaptureControlReliabilityTest::sdkSo = nullptr; +#endif -void AudioHdiCaptureControlReliabilityTest::TearDownTestCase(void) {} - -void AudioHdiCaptureControlReliabilityTest::SetUp(void) +void AudioHdiCaptureControlReliabilityTest::SetUpTestCase(void) { - char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; - handleSo = dlopen(resolvedPath, RTLD_LAZY); +#ifdef AUDIO_MPI_SO + char sdkResolvedPath[] = "//system/lib/libhdi_audio_interface_lib_render.z.so"; + sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY); + if (sdkSo == nullptr) { + return; + } + SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit")); + if (SdkInit == nullptr) { + return; + } + SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit")); + if (SdkExit == nullptr) { + return; + } + SdkInit(); +#endif + handleSo = dlopen(RESOLVED_PATH.c_str(), RTLD_LAZY); if (handleSo == nullptr) { return; } - GetAudioManager = (struct AudioManager* (*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); + GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str())); if (GetAudioManager == nullptr) { return; } } -void AudioHdiCaptureControlReliabilityTest::TearDown(void) +void AudioHdiCaptureControlReliabilityTest::TearDownTestCase(void) { +#ifdef AUDIO_MPI_SO + SdkExit(); + if (sdkSo != nullptr) { + dlclose(sdkSo); + sdkSo = nullptr; + } + if (SdkInit != nullptr) { + SdkInit = nullptr; + } + if (SdkExit != nullptr) { + SdkExit = nullptr; + } +#endif if (GetAudioManager != nullptr) { GetAudioManager = nullptr; } } -struct CaptureCharacteristic { - uint64_t getframes; -}; +void AudioHdiCaptureControlReliabilityTest::SetUp(void) {} -struct RelCaptureAdapterPara { - struct AudioManager *manager; - enum AudioPortDirection portType; - const char *adapterName; - struct AudioAdapter *adapter; - struct AudioPort capturePort; - void *param; - enum AudioPortPin pins; - const char *path; - struct AudioCapture *capture; - struct AudioHeadInfo headInfo; - struct AudioAdapterDescriptor *desc; - struct AudioAdapterDescriptor *descs; - struct CaptureCharacteristic character; - struct AudioPortCapability capability; - enum AudioPortPassthroughMode mode; - struct AudioTimeStamp time = {.tvNSec = 1}; -}; +void AudioHdiCaptureControlReliabilityTest::TearDown(void) {} -int32_t AudioHdiCaptureControlReliabilityTest::RelGetAllAdapter(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureControlReliabilityTest::RelGetAllAdapter(struct PrepareAudioPara& ptr) { int size = 0; - auto *inst = (AudioHdiCaptureControlReliabilityTest *)ptr.param; + auto *inst = (AudioHdiCaptureControlReliabilityTest *)ptr.self; if (inst != nullptr && inst->GetAudioManager != nullptr) { ptr.manager = inst->GetAudioManager(); } @@ -118,7 +135,7 @@ int32_t AudioHdiCaptureControlReliabilityTest::RelGetAllAdapter(struct RelCaptur if (ptr.descs == nullptr || size == 0) { return HDF_FAILURE; } else { - int index = SwitchAdapter(ptr.descs, ptr.adapterName, ptr.portType, ptr.capturePort, size); + int index = SwitchAdapter(ptr.descs, ptr.adapterName, ptr.portType, ptr.audioPort, size); if (index < 0) { return HDF_FAILURE; } else { @@ -128,7 +145,7 @@ int32_t AudioHdiCaptureControlReliabilityTest::RelGetAllAdapter(struct RelCaptur return HDF_SUCCESS; } -int32_t AudioHdiCaptureControlReliabilityTest::RelLoadAdapter(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureControlReliabilityTest::RelLoadAdapter(struct PrepareAudioPara& ptr) { if (ptr.desc == nullptr) { return HDF_FAILURE; @@ -141,7 +158,7 @@ int32_t AudioHdiCaptureControlReliabilityTest::RelLoadAdapter(struct RelCaptureA return HDF_SUCCESS; } -int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCreateCapture(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCreateCapture(struct PrepareAudioPara& ptr) { int32_t ret = -1; struct AudioSampleAttributes attrs = {}; @@ -150,7 +167,7 @@ int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCreateCapture(struct RelC return HDF_FAILURE; } InitAttrs(attrs); - InitDevDesc(devDesc, (&ptr.capturePort)->portId, ptr.pins); + InitDevDesc(devDesc, (&ptr.audioPort)->portId, ptr.pins); ret = ptr.adapter->CreateCapture(ptr.adapter, &devDesc, &attrs, &ptr.capture); if (ret < 0 || ptr.capture == nullptr) { ptr.manager->UnloadAdapter(ptr.manager, ptr.adapter); @@ -159,8 +176,11 @@ int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCreateCapture(struct RelC return HDF_SUCCESS; } -int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureStart(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureStart(struct PrepareAudioPara& ptr) { + if (ptr.capture == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.capture->control.Start((AudioHandle)(ptr.capture)); if (ret < 0) { @@ -169,7 +189,7 @@ int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureStart(struct RelCa return HDF_SUCCESS; } -int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureFrame(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureFrame(struct PrepareAudioPara& ptr) { int32_t ret = -1; uint64_t requestBytes = BUFFER_SIZE; @@ -191,7 +211,7 @@ int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureFrame(struct RelCa return HDF_SUCCESS; } -int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureStartAndCaputreFrame(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureStartAndCaputreFrame(struct PrepareAudioPara& ptr) { int32_t ret = -1; struct AudioSampleAttributes attrs = {}; @@ -214,8 +234,11 @@ int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureStartAndCaputreFra return HDF_SUCCESS; } -int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureStop(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureStop(struct PrepareAudioPara& ptr) { + if (ptr.capture == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.capture->control.Stop((AudioHandle)(ptr.capture)); if (ret < 0) { @@ -224,8 +247,11 @@ int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureStop(struct RelCap return HDF_SUCCESS; } -int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCapturePause(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCapturePause(struct PrepareAudioPara& ptr) { + if (ptr.capture == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.capture->control.Pause((AudioHandle)(ptr.capture)); if (ret < 0) { @@ -234,8 +260,11 @@ int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCapturePause(struct RelCa return HDF_SUCCESS; } -int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureResume(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureResume(struct PrepareAudioPara& ptr) { + if (ptr.capture == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.capture->control.Resume((AudioHandle)(ptr.capture)); if (ret < 0) { @@ -244,7 +273,7 @@ int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureResume(struct RelC return HDF_SUCCESS; } -int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureProcedure(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureProcedure(struct PrepareAudioPara& ptr) { int32_t ret = -1; ret = RelGetAllAdapter(ptr); @@ -264,12 +293,14 @@ int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureProcedure(struct R ret = RelAudioCaptureStartAndCaputreFrame(ptr); if (ret < 0) { + ptr.adapter->DestroyCapture(ptr.adapter, ptr.capture); + ptr.manager->UnloadAdapter(ptr.manager, ptr.adapter); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioHdiCaptureControlReliabilityTest::RelAudioAdapterInitAllPorts(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureControlReliabilityTest::RelAudioAdapterInitAllPorts(struct PrepareAudioPara& ptr) { int32_t ret = -1; if (ptr.adapter == nullptr) { @@ -282,47 +313,50 @@ int32_t AudioHdiCaptureControlReliabilityTest::RelAudioAdapterInitAllPorts(struc return HDF_SUCCESS; } -int32_t AudioHdiCaptureControlReliabilityTest::RelAudioAdapterGetPortCapability(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureControlReliabilityTest::RelAudioAdapterGetPortCapability(struct PrepareAudioPara& ptr) { int32_t ret = -1; if (ptr.adapter == nullptr) { return HDF_FAILURE; } - ret = ptr.adapter->GetPortCapability(ptr.adapter, &(ptr.capturePort), &(ptr.capability)); + ret = ptr.adapter->GetPortCapability(ptr.adapter, &(ptr.audioPort), &(ptr.capability)); if (ret < 0) { return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioHdiCaptureControlReliabilityTest::RelAudioAdapterSetPassthroughMode(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureControlReliabilityTest::RelAudioAdapterSetPassthroughMode(struct PrepareAudioPara& ptr) { int32_t ret = -1; if (ptr.adapter == nullptr) { return HDF_FAILURE; } - ret = ptr.adapter->SetPassthroughMode(ptr.adapter, &(ptr.capturePort), ptr.mode); + ret = ptr.adapter->SetPassthroughMode(ptr.adapter, &(ptr.audioPort), ptr.mode); if (ret < 0) { return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioHdiCaptureControlReliabilityTest::RelAudioAdapterGetPassthroughMode(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureControlReliabilityTest::RelAudioAdapterGetPassthroughMode(struct PrepareAudioPara& ptr) { int32_t ret = -1; if (ptr.adapter == nullptr) { return HDF_FAILURE; } - ret = ptr.adapter->GetPassthroughMode(ptr.adapter, &(ptr.capturePort), &(ptr.mode)); + ret = ptr.adapter->GetPassthroughMode(ptr.adapter, &(ptr.audioPort), &(ptr.mode)); if (ret < 0) { return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureGetCapturePosition(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureGetCapturePosition(struct PrepareAudioPara& ptr) { + if (ptr.capture == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.capture->GetCapturePosition(ptr.capture, &(ptr.character.getframes), &(ptr.time)); if (ret < 0) { @@ -340,11 +374,11 @@ int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureGetCapturePosition HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureFrame_Reliability_0001, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }; - struct RelCaptureAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; ret = RelGetAllAdapter(para); EXPECT_EQ(HDF_SUCCESS, ret); ret = RelLoadAdapter(para); @@ -355,7 +389,7 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureFrame_ EXPECT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelCaptureAdapterPara), ¶, sizeof(RelCaptureAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureFrame, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); @@ -367,57 +401,9 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureFrame_ ret = (intptr_t)result; EXPECT_EQ(HDF_SUCCESS, ret); } - ret = para.capture->control.Stop((AudioHandle)(para.capture)); + ret = StopAudio(para); EXPECT_EQ(HDF_SUCCESS, ret); - para.adapter->DestroyCapture(para.adapter, para.capture); - para.manager->UnloadAdapter(para.manager, para.adapter); } - -/** -* @tc.name RelAudioCaptureFrame API via The passed in adaptername is the different -* @tc.number SUB_Audio_HDI_RelAudioCaptureFrame_Reliability_0002 -* @tc.desc test AudioCaptureStop interface, Returns 0 if the input data is read successfully -* @tc.author: wangkang -*/ -HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureFrame_Reliability_0002, TestSize.Level1) -{ - int32_t ret = -1; - struct RelCaptureAdapterPara para[PTHREAD_DIFFADA_COUNT] = { - { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() - }, { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() - } - }; - - pthread_t tids[PTHREAD_DIFFADA_COUNT]; - for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - ret = RelGetAllAdapter(para[i]); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = RelLoadAdapter(para[i]); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = RelAudioCreateCapture(para[i]); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = RelAudioCaptureStart(para[i]); - EXPECT_EQ(HDF_SUCCESS, ret); - int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureFrame, ¶[i]); - EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); - } - for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - void *result = nullptr; - pthread_join(tids[i], &result); - ret = (intptr_t)result; - EXPECT_EQ(HDF_SUCCESS, ret); - ret = para[i].capture->control.Stop((AudioHandle)(para[i].capture)); - EXPECT_EQ(HDF_SUCCESS, ret); - para[i].adapter->DestroyCapture(para[i].adapter, para[i].capture); - para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); - } -} - /** * @tc.name test AudioCaptureStart API via Multithread call. * @tc.number SUB_Audio_HDI_AudioCaptureStart_Reliability_0001 @@ -429,11 +415,11 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureStart_ int32_t ret = -1; int32_t failcount = 0; int32_t succeedcount = 0; - struct RelCaptureAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }; - struct RelCaptureAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; ret = RelGetAllAdapter(para); EXPECT_EQ(HDF_SUCCESS, ret); ret = RelLoadAdapter(para); @@ -442,7 +428,7 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureStart_ EXPECT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelCaptureAdapterPara), ¶, sizeof(RelCaptureAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureStart, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); @@ -460,16 +446,14 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureStart_ failcount = failcount + 1; } } - ret = para.capture->control.Stop((AudioHandle)(para.capture)); + ret = StopAudio(para); EXPECT_EQ(HDF_SUCCESS, ret); - para.adapter->DestroyCapture(para.adapter, para.capture); - para.manager->UnloadAdapter(para.manager, para.adapter); EXPECT_EQ(failcount, PTHREAD_SAMEADA_COUNT - 1); EXPECT_EQ(succeedcount, 1); } /** -* @tc.name RelAudioCaptureStart API via The passed in adaptername is the differentt +* @tc.name RelAudioCaptureStart API via The passed in adaptername is the different * @tc.number SUB_Audio_HDI_RelAudioCaptureStart_Reliability_0002 * @tc.desc test AudioCaptureStart interface, return 0 if the the AudioCapture objects are Start successfully * @tc.author: wangkang @@ -477,13 +461,13 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureStart_ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureStart_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }, { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() } }; pthread_t tids[PTHREAD_DIFFADA_COUNT]; @@ -498,14 +482,9 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureStart_ EXPECT_EQ(HDF_SUCCESS, ret); } for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - void *result = nullptr; - pthread_join(tids[i], &result); - ret = (intptr_t)result; + para[i].tids = tids[i]; + ret = ThreadRelease(para[i]); EXPECT_EQ(HDF_SUCCESS, ret); - ret = para[i].capture->control.Stop((AudioHandle)(para[i].capture)); - EXPECT_EQ(HDF_SUCCESS, ret); - para[i].adapter->DestroyCapture(para[i].adapter, para[i].capture); - para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } } @@ -520,16 +499,16 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureStop_R int32_t ret = -1; int32_t failcount = 0; int32_t succeedcount = 0; - struct RelCaptureAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }; - struct RelCaptureAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; ret = RelAudioCaptureProcedure(para); ASSERT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelCaptureAdapterPara), ¶, sizeof(RelCaptureAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureStop, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); @@ -554,7 +533,7 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureStop_R } /** -* @tc.name RelAudioCaptureStop API via The passed in adaptername is the differentt +* @tc.name RelAudioCaptureStop API via The passed in adaptername is the different * @tc.number SUB_Audio_HDI_RelAudioCaptureStop_Reliability_0002 * @tc.desc test AudioCaptureStop interface, return 0 if the the AudioCapture objects are Stop successfully * @tc.author: wangkang @@ -562,13 +541,13 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureStop_R HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureStop_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }, { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() } }; @@ -578,6 +557,7 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureStop_R ASSERT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureStop, ¶[i]); EXPECT_EQ(HDF_SUCCESS, ret); + usleep(50000); } for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { void *result = nullptr; @@ -598,16 +578,16 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureStop_R HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCapturePause_Reliability_0001, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }; - struct RelCaptureAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; ret = RelAudioCaptureProcedure(para); ASSERT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelCaptureAdapterPara), ¶, sizeof(RelCaptureAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCapturePause, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); @@ -622,49 +602,9 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCapturePause_ ret = (intptr_t)result; EXPECT_EQ(HDF_SUCCESS, ret); } - ret = para.capture->control.Stop((AudioHandle)(para.capture)); + ret = StopAudio(para); EXPECT_EQ(HDF_SUCCESS, ret); - para.adapter->DestroyCapture(para.adapter, para.capture); - para.manager->UnloadAdapter(para.manager, para.adapter); -} - -/** -* @tc.name RelAudioCapturePause API via The passed in adaptername is the differentt -* @tc.number SUB_Audio_HDI_RelAudioCapturePause_Reliability_0002 -* @tc.desc test AudioCapturePause interface, return 0 if the the AudioCapture objects are Pause successfully -* @tc.author: wangkang -*/ -HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCapturePause_Reliability_0002, TestSize.Level1) -{ - int32_t ret = -1; - struct RelCaptureAdapterPara para[PTHREAD_DIFFADA_COUNT] = { - { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() - }, { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() - } - }; - - pthread_t tids[PTHREAD_DIFFADA_COUNT]; - for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - ret = RelAudioCaptureProcedure(para[i]); - ASSERT_EQ(HDF_SUCCESS, ret); - ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCapturePause, ¶[i]); - EXPECT_EQ(HDF_SUCCESS, ret); - } - for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - void *result = nullptr; - pthread_join(tids[i], &result); - ret = (intptr_t)result; - EXPECT_EQ(HDF_SUCCESS, ret); - para[i].capture->control.Stop((AudioHandle)(para[i].capture)); - para[i].adapter->DestroyCapture(para[i].adapter, para[i].capture); - para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); - } } - /** * @tc.name test RelAudioAdapterInitAllPorts API via Multi thread calling multi sound card * @tc.number SUB_Audio_HDI_AudioInitAllPorts_Reliability_0001 @@ -674,13 +614,13 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCapturePause_ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioInitAllPorts_Reliability_0001, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() } }; pthread_t tids[PTHREAD_DIFFADA_COUNT]; @@ -710,11 +650,11 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioInitAllPorts_ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioInitAllPorts_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, - .path = AUDIO_FILE.c_str() + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_CAPTURE_FILE.c_str() }; - struct RelCaptureAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { @@ -722,7 +662,7 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioInitAllPorts_ EXPECT_EQ(HDF_SUCCESS, ret); ret = RelLoadAdapter(para); EXPECT_EQ(HDF_SUCCESS, ret); - ret = memcpy_s(&arrpara[i], sizeof(RelCaptureAdapterPara), ¶, sizeof(RelCaptureAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioAdapterInitAllPorts, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); @@ -745,13 +685,13 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioInitAllPorts_ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioGetPortCapability_Reliability_0001, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() } }; pthread_t tids[PTHREAD_DIFFADA_COUNT]; @@ -783,12 +723,12 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioGetPortCapabi HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioGetPortCapability_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }; - struct RelCaptureAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { @@ -798,7 +738,7 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioGetPortCapabi EXPECT_EQ(HDF_SUCCESS, ret); ret = RelAudioAdapterInitAllPorts(para); EXPECT_EQ(HDF_SUCCESS, ret); - ret = memcpy_s(&arrpara[i], sizeof(RelCaptureAdapterPara), ¶, sizeof(RelCaptureAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioAdapterGetPortCapability, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); @@ -820,13 +760,13 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioGetPortCapabi HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioSetPassthroughMode_Reliability_0001, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str(), .mode = PORT_PASSTHROUGH_LPCM + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str(), .mode = PORT_PASSTHROUGH_LPCM }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str(), .mode = PORT_PASSTHROUGH_LPCM + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str(), .mode = PORT_PASSTHROUGH_LPCM } }; @@ -846,7 +786,7 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioSetPassthroug pthread_join(tids[i], &result); ret = (intptr_t)result; EXPECT_EQ(HDF_SUCCESS, ret); - ret = para[i].adapter->GetPassthroughMode(para[i].adapter, &(para[i].capturePort), &(para[i].mode)); + ret = para[i].adapter->GetPassthroughMode(para[i].adapter, &(para[i].audioPort), &(para[i].mode)); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(PORT_PASSTHROUGH_LPCM, para[i].mode); para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); @@ -862,12 +802,12 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioSetPassthroug HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioSetPassthroughMode_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, - .path = AUDIO_FILE.c_str(), .mode = PORT_PASSTHROUGH_LPCM + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_CAPTURE_FILE.c_str(), .mode = PORT_PASSTHROUGH_LPCM }; - struct RelCaptureAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { ret = RelGetAllAdapter(para); @@ -876,7 +816,7 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioSetPassthroug EXPECT_EQ(HDF_SUCCESS, ret); ret = RelAudioAdapterInitAllPorts(para); EXPECT_EQ(HDF_SUCCESS, ret); - ret = memcpy_s(&arrpara[i], sizeof(RelCaptureAdapterPara), ¶, sizeof(RelCaptureAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioAdapterSetPassthroughMode, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); @@ -886,7 +826,7 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioSetPassthroug pthread_join(tids[i], &result); ret = (intptr_t)result; EXPECT_EQ(HDF_SUCCESS, ret); - ret = arrpara[i].adapter->GetPassthroughMode(arrpara[i].adapter, &(arrpara[i].capturePort), &(arrpara[i].mode)); + ret = arrpara[i].adapter->GetPassthroughMode(arrpara[i].adapter, &(arrpara[i].audioPort), &(arrpara[i].mode)); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(PORT_PASSTHROUGH_LPCM, arrpara[i].mode); arrpara[i].manager->UnloadAdapter(arrpara[i].manager, arrpara[i].adapter); @@ -902,13 +842,13 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioSetPassthroug HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioGetPassthroughMode_Reliability_0001, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str(), .mode = PORT_PASSTHROUGH_LPCM + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str(), .mode = PORT_PASSTHROUGH_LPCM }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str(), .mode = PORT_PASSTHROUGH_LPCM + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str(), .mode = PORT_PASSTHROUGH_LPCM } }; pthread_t tids[PTHREAD_DIFFADA_COUNT]; @@ -943,12 +883,12 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioGetPassthroug HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioGetPassthroughMode_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, - .path = AUDIO_FILE.c_str(), .mode = PORT_PASSTHROUGH_LPCM + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_CAPTURE_FILE.c_str(), .mode = PORT_PASSTHROUGH_LPCM }; - struct RelCaptureAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { ret = RelGetAllAdapter(para); @@ -957,7 +897,7 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioGetPassthroug EXPECT_EQ(HDF_SUCCESS, ret); ret = RelAudioAdapterInitAllPorts(para); EXPECT_EQ(HDF_SUCCESS, ret); - ret = memcpy_s(&arrpara[i], sizeof(RelCaptureAdapterPara), ¶, sizeof(RelCaptureAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); ret = RelAudioAdapterSetPassthroughMode(arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); @@ -983,16 +923,16 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioGetPassthroug HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureResume_Reliability_0001, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }; - struct RelCaptureAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; ret = RelAudioCaptureProcedure(para); ASSERT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelCaptureAdapterPara), ¶, sizeof(RelCaptureAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); ret = RelAudioCapturePause(arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); @@ -1007,10 +947,8 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureResume ret = (intptr_t)result; EXPECT_EQ(HDF_SUCCESS, ret); } - ret = para.capture->control.Stop((AudioHandle)(para.capture)); + ret = StopAudio(para); EXPECT_EQ(HDF_SUCCESS, ret); - para.adapter->DestroyCapture(para.adapter, para.capture); - para.manager->UnloadAdapter(para.manager, para.adapter); } /** @@ -1022,13 +960,13 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureResume HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureResume_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }, { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() } }; pthread_t tids[PTHREAD_DIFFADA_COUNT]; @@ -1041,13 +979,9 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureResume EXPECT_EQ(HDF_SUCCESS, ret); } for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - void *result = nullptr; - pthread_join(tids[i], &result); - EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); - ret = para[i].capture->control.Stop((AudioHandle)(para[i].capture)); + para[i].tids = tids[i]; + ret = ThreadRelease(para[i]); EXPECT_EQ(HDF_SUCCESS, ret); - para[i].adapter->DestroyCapture(para[i].adapter, para[i].capture); - para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } } @@ -1061,18 +995,18 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioGetCapturePos { int32_t ret = -1; int64_t timeExp = 0; - struct RelCaptureAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }; - struct RelCaptureAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; ret = RelAudioCaptureProcedure(para); ASSERT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelCaptureAdapterPara), ¶, sizeof(RelCaptureAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetCapturePosition, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); @@ -1085,10 +1019,8 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioGetCapturePos EXPECT_LT(INITIAL_VALUE, arrpara[i].character.getframes); EXPECT_LT(timeExp, arrpara[i].time.tvNSec); } - ret = para.capture->control.Stop((AudioHandle)(para.capture)); + ret = StopAudio(para); EXPECT_EQ(HDF_SUCCESS, ret); - para.adapter->DestroyCapture(para.adapter, para.capture); - para.manager->UnloadAdapter(para.manager, para.adapter); } /** * @tc.name test AudioCaptureGetCapturePosition API via Multithread call. @@ -1101,13 +1033,13 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureGetCap { int32_t ret = -1; int64_t timeExp = 0; - struct RelCaptureAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }, { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() } }; @@ -1120,15 +1052,11 @@ HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureGetCap } for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - void *result = nullptr; - pthread_join(tids[i], &result); - EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); + para[i].tids = tids[i]; + ret = ThreadRelease(para[i]); + EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_LT(INITIAL_VALUE, para[i].character.getframes); EXPECT_LT(timeExp, para[i].time.tvNSec); - ret = para[i].capture->control.Stop((AudioHandle)(para[i].capture)); - EXPECT_EQ(HDF_SUCCESS, ret); - para[i].adapter->DestroyCapture(para[i].adapter, para[i].capture); - para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } } } \ No newline at end of file diff --git a/audio/test/systemtest/hdi/hdireliability/src/audio_hdicapture_reliability_test.cpp b/audio/test/systemtest/hdi/hdireliability/src/audio_hdicapture_reliability_test.cpp index 5ab0969008..504f3db075 100755 --- a/audio/test/systemtest/hdi/hdireliability/src/audio_hdicapture_reliability_test.cpp +++ b/audio/test/systemtest/hdi/hdireliability/src/audio_hdicapture_reliability_test.cpp @@ -22,10 +22,9 @@ using namespace testing::ext; using namespace HMOS::Audio; namespace { -const string AUDIO_FILE = "//bin/audiocapturetest.wav"; -const string ADAPTER_NAME = "hdmi"; -const string ADAPTER_NAME2 = "usb"; -const string ADAPTER_NAME3 = "internal"; +const string ADAPTER_NAME_HDMI = "hdmi"; +const string ADAPTER_NAME_USB = "usb"; +const string ADAPTER_NAME_INTERNAL = "internal"; const int PTHREAD_SAMEADA_COUNT = 3; const int PTHREAD_DIFFADA_COUNT = 2; const uint32_t SAMPLERATEVALUE = 48000; @@ -36,94 +35,101 @@ public: static void TearDownTestCase(void); void SetUp(); void TearDown(); - struct AudioManager *(*GetAudioManager)() = nullptr; - void *handleSo = nullptr; - static int32_t RelAudioCreateCapture(struct RelCaptureAdapterPara& ptr); - static int32_t RelGetAllAdapter(struct RelCaptureAdapterPara& ptr); - static int32_t RelLoadAdapter(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioDestroyCapture(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioCaptureSetMute(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioCaptureGetMute(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioCaptureSetVolume(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioCaptureGetVolume(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioCaptureProcedure(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioCaptureStartAndCaputreFrame(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioCaptureSetGain(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioCaptureGetGain(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioCaptureGetGainThreshold(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioCaptureGetFrameSize(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioCaptureGetFrameCount(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioCaptureGetCurrentChannelId(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioCaptureSetSampleAttributes(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioCaptureGetSampleAttributes(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioCaptureSelectScene(struct RelCaptureAdapterPara& ptr); - static int32_t RelAudioCaptureCheckSceneCapability(struct RelCaptureAdapterPara& ptr); + static TestAudioManager *(*GetAudioManager)(); + static void *handleSo; +#ifdef AUDIO_MPI_SO + static int32_t (*SdkInit)(); + static void (*SdkExit)(); + static void *sdkSo; +#endif + static int32_t RelAudioCreateCapture(struct PrepareAudioPara& ptr); + static int32_t RelGetAllAdapter(struct PrepareAudioPara& ptr); + static int32_t RelLoadAdapter(struct PrepareAudioPara& ptr); + static int32_t RelAudioDestroyCapture(struct PrepareAudioPara& ptr); + static int32_t RelAudioCaptureSetMute(struct PrepareAudioPara& ptr); + static int32_t RelAudioCaptureGetMute(struct PrepareAudioPara& ptr); + static int32_t RelAudioCaptureSetVolume(struct PrepareAudioPara& ptr); + static int32_t RelAudioCaptureGetVolume(struct PrepareAudioPara& ptr); + static int32_t RelAudioCaptureProcedure(struct PrepareAudioPara& ptr); + static int32_t RelAudioCaptureStartAndCaputreFrame(struct PrepareAudioPara& ptr); + static int32_t RelAudioCaptureSetGain(struct PrepareAudioPara& ptr); + static int32_t RelAudioCaptureGetGain(struct PrepareAudioPara& ptr); + static int32_t RelAudioCaptureGetGainThreshold(struct PrepareAudioPara& ptr); + static int32_t RelAudioCaptureGetFrameSize(struct PrepareAudioPara& ptr); + static int32_t RelAudioCaptureGetFrameCount(struct PrepareAudioPara& ptr); + static int32_t RelAudioCaptureGetCurrentChannelId(struct PrepareAudioPara& ptr); + static int32_t RelAudioCaptureSetSampleAttributes(struct PrepareAudioPara& ptr); + static int32_t RelAudioCaptureGetSampleAttributes(struct PrepareAudioPara& ptr); + static int32_t RelAudioCaptureSelectScene(struct PrepareAudioPara& ptr); + static int32_t RelAudioCaptureCheckSceneCapability(struct PrepareAudioPara& ptr); }; using THREAD_FUNC = void *(*)(void *); -void AudioHdiCaptureReliabilityTest::SetUpTestCase(void) {} +TestAudioManager *(*AudioHdiCaptureReliabilityTest::GetAudioManager)() = nullptr; +void *AudioHdiCaptureReliabilityTest::handleSo = nullptr; +#ifdef AUDIO_MPI_SO + int32_t (*AudioHdiCaptureReliabilityTest::SdkInit)() = nullptr; + void (*AudioHdiCaptureReliabilityTest::SdkExit)() = nullptr; + void *AudioHdiCaptureReliabilityTest::sdkSo = nullptr; +#endif -void AudioHdiCaptureReliabilityTest::TearDownTestCase(void) {} - -void AudioHdiCaptureReliabilityTest::SetUp(void) +void AudioHdiCaptureReliabilityTest::SetUpTestCase(void) { - char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; - handleSo = dlopen(resolvedPath, RTLD_LAZY); +#ifdef AUDIO_MPI_SO + char sdkResolvedPath[] = "//system/lib/libhdi_audio_interface_lib_render.z.so"; + sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY); + if (sdkSo == nullptr) { + return; + } + SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit")); + if (SdkInit == nullptr) { + return; + } + SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit")); + if (SdkExit == nullptr) { + return; + } + SdkInit(); +#endif + handleSo = dlopen(RESOLVED_PATH.c_str(), RTLD_LAZY); if (handleSo == nullptr) { return; } - GetAudioManager = (struct AudioManager* (*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); + GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str())); if (GetAudioManager == nullptr) { return; } } -void AudioHdiCaptureReliabilityTest::TearDown(void) +void AudioHdiCaptureReliabilityTest::TearDownTestCase(void) { +#ifdef AUDIO_MPI_SO + SdkExit(); + if (sdkSo != nullptr) { + dlclose(sdkSo); + sdkSo = nullptr; + } + if (SdkInit != nullptr) { + SdkInit = nullptr; + } + if (SdkExit != nullptr) { + SdkExit = nullptr; + } +#endif if (GetAudioManager != nullptr) { GetAudioManager = nullptr; } } -struct CaptureCharacteristic { - bool setmute; - bool getmute; - float setvolume; - float getvolume; - float setgain; - float getgain; - float gainthresholdmin; - float gainthresholdmax; - uint64_t getframesize; - uint64_t getframecount; - uint32_t getcurrentchannelId; - bool supported; -}; +void AudioHdiCaptureReliabilityTest::SetUp(void) {} -struct RelCaptureAdapterPara { - struct AudioManager *manager; - enum AudioPortDirection portType; - const char *adapterName; - struct AudioAdapter *adapter; - struct AudioPort capturePort; - void *param; - enum AudioPortPin pins; - const char *path; - struct AudioCapture *capture; - struct AudioHeadInfo headInfo; - struct AudioAdapterDescriptor *desc; - struct AudioAdapterDescriptor *descs; - struct CaptureCharacteristic character; - struct AudioSampleAttributes attrs; - struct AudioSampleAttributes attrsValue; - struct AudioSceneDescriptor scenes; -}; +void AudioHdiCaptureReliabilityTest::TearDown(void) {} -int32_t AudioHdiCaptureReliabilityTest::RelGetAllAdapter(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureReliabilityTest::RelGetAllAdapter(struct PrepareAudioPara& ptr) { int size = 0; - auto *inst = (AudioHdiCaptureReliabilityTest *)ptr.param; + auto *inst = (AudioHdiCaptureReliabilityTest *)ptr.self; if (inst != nullptr && inst->GetAudioManager != nullptr) { ptr.manager = inst->GetAudioManager(); } @@ -134,7 +140,7 @@ int32_t AudioHdiCaptureReliabilityTest::RelGetAllAdapter(struct RelCaptureAdapte if (ptr.descs == nullptr || size == 0) { return HDF_FAILURE; } else { - int index = SwitchAdapter(ptr.descs, ptr.adapterName, ptr.portType, ptr.capturePort, size); + int index = SwitchAdapter(ptr.descs, ptr.adapterName, ptr.portType, ptr.audioPort, size); if (index < 0) { return HDF_FAILURE; } else { @@ -144,7 +150,7 @@ int32_t AudioHdiCaptureReliabilityTest::RelGetAllAdapter(struct RelCaptureAdapte return HDF_SUCCESS; } -int32_t AudioHdiCaptureReliabilityTest::RelLoadAdapter(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureReliabilityTest::RelLoadAdapter(struct PrepareAudioPara& ptr) { if (ptr.desc == nullptr) { return HDF_FAILURE; @@ -157,7 +163,7 @@ int32_t AudioHdiCaptureReliabilityTest::RelLoadAdapter(struct RelCaptureAdapterP return HDF_SUCCESS; } -int32_t AudioHdiCaptureReliabilityTest::RelAudioCreateCapture(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureReliabilityTest::RelAudioCreateCapture(struct PrepareAudioPara& ptr) { int32_t ret = -1; struct AudioSampleAttributes attrs = {}; @@ -166,7 +172,7 @@ int32_t AudioHdiCaptureReliabilityTest::RelAudioCreateCapture(struct RelCaptureA return HDF_FAILURE; } InitAttrs(attrs); - InitDevDesc(devDesc, (&ptr.capturePort)->portId, ptr.pins); + InitDevDesc(devDesc, (&ptr.audioPort)->portId, ptr.pins); ret = ptr.adapter->CreateCapture(ptr.adapter, &devDesc, &attrs, &ptr.capture); if (ret < 0 || ptr.capture == nullptr) { ptr.manager->UnloadAdapter(ptr.manager, ptr.adapter); @@ -175,7 +181,7 @@ int32_t AudioHdiCaptureReliabilityTest::RelAudioCreateCapture(struct RelCaptureA return HDF_SUCCESS; } -int32_t AudioHdiCaptureReliabilityTest::RelAudioDestroyCapture(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureReliabilityTest::RelAudioDestroyCapture(struct PrepareAudioPara& ptr) { int32_t ret = -1; if (ptr.adapter == nullptr || ptr.manager == nullptr) { @@ -188,7 +194,7 @@ int32_t AudioHdiCaptureReliabilityTest::RelAudioDestroyCapture(struct RelCapture return HDF_SUCCESS; } -int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureStartAndCaputreFrame(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureStartAndCaputreFrame(struct PrepareAudioPara& ptr) { int32_t ret = -1; struct AudioSampleAttributes attrs = {}; @@ -196,11 +202,7 @@ int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureStartAndCaputreFrame(stru if (file == nullptr) { return HDF_FAILURE; } - ret = InitAttrs(attrs); - if (ret < 0) { - fclose(file); - return HDF_FAILURE; - } + InitAttrs(attrs); ret = FrameStartCapture(ptr.capture, file, attrs); if (ret < 0) { @@ -211,8 +213,11 @@ int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureStartAndCaputreFrame(stru return HDF_SUCCESS; } -int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSetMute(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSetMute(struct PrepareAudioPara& ptr) { + if (ptr.capture == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.capture->volume.SetMute(ptr.capture, ptr.character.setmute); if (ret < 0) { @@ -221,8 +226,11 @@ int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSetMute(struct RelCapture return HDF_SUCCESS; } -int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetMute(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetMute(struct PrepareAudioPara& ptr) { + if (ptr.capture == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.capture->volume.GetMute(ptr.capture, &(ptr.character.getmute)); if (ret < 0) { @@ -231,8 +239,11 @@ int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetMute(struct RelCapture return HDF_SUCCESS; } -int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSetVolume(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSetVolume(struct PrepareAudioPara& ptr) { + if (ptr.capture == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.capture->volume.SetVolume(ptr.capture, ptr.character.setvolume); if (ret < 0) { @@ -241,8 +252,11 @@ int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSetVolume(struct RelCaptu return HDF_SUCCESS; } -int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetVolume(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetVolume(struct PrepareAudioPara& ptr) { + if (ptr.capture == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.capture->volume.GetVolume(ptr.capture, &(ptr.character.getvolume)); if (ret < 0) { @@ -251,7 +265,7 @@ int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetVolume(struct RelCaptu return HDF_SUCCESS; } -int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureProcedure(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureProcedure(struct PrepareAudioPara& ptr) { int32_t ret = -1; ret = RelGetAllAdapter(ptr); @@ -271,13 +285,18 @@ int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureProcedure(struct RelCaptu ret = RelAudioCaptureStartAndCaputreFrame(ptr); if (ret < 0) { + ptr.adapter->DestroyCapture(ptr.adapter, ptr.capture); + ptr.manager->UnloadAdapter(ptr.manager, ptr.adapter); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetGainThreshold(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetGainThreshold(struct PrepareAudioPara& ptr) { + if (ptr.capture == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.capture->volume.GetGainThreshold(ptr.capture, &(ptr.character.gainthresholdmin), &(ptr.character.gainthresholdmax)); @@ -287,8 +306,11 @@ int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetGainThreshold(struct R return HDF_SUCCESS; } -int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSetGain(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSetGain(struct PrepareAudioPara& ptr) { + if (ptr.capture == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.capture->volume.SetGain(ptr.capture, ptr.character.setgain); if (ret < 0) { @@ -297,8 +319,11 @@ int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSetGain(struct RelCapture return HDF_SUCCESS; } -int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetGain(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetGain(struct PrepareAudioPara& ptr) { + if (ptr.capture == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.capture->volume.GetGain(ptr.capture, &(ptr.character.getgain)); if (ret < 0) { @@ -307,8 +332,11 @@ int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetGain(struct RelCapture return HDF_SUCCESS; } -int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetFrameSize(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetFrameSize(struct PrepareAudioPara& ptr) { + if (ptr.capture == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.capture->attr.GetFrameSize(ptr.capture, &(ptr.character.getframesize)); if (ret < 0) { @@ -317,8 +345,11 @@ int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetFrameSize(struct RelCa return HDF_SUCCESS; } -int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetFrameCount(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetFrameCount(struct PrepareAudioPara& ptr) { + if (ptr.capture == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.capture->attr.GetFrameCount(ptr.capture, &(ptr.character.getframecount)); if (ret < 0) { @@ -327,8 +358,11 @@ int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetFrameCount(struct RelC return HDF_SUCCESS; } -int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetCurrentChannelId(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetCurrentChannelId(struct PrepareAudioPara& ptr) { + if (ptr.capture == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.capture->attr.GetCurrentChannelId(ptr.capture, &(ptr.character.getcurrentchannelId)); if (ret < 0) { @@ -337,8 +371,11 @@ int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetCurrentChannelId(struc return HDF_SUCCESS; } -int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSetSampleAttributes(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSetSampleAttributes(struct PrepareAudioPara& ptr) { + if (ptr.capture == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.capture->attr.SetSampleAttributes(ptr.capture, &(ptr.attrs)); if (ret < 0) { @@ -347,8 +384,11 @@ int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSetSampleAttributes(struc return HDF_SUCCESS; } -int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetSampleAttributes(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetSampleAttributes(struct PrepareAudioPara& ptr) { + if (ptr.capture == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.capture->attr.GetSampleAttributes(ptr.capture, &(ptr.attrsValue)); if (ret < 0) { @@ -357,8 +397,11 @@ int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetSampleAttributes(struc return HDF_SUCCESS; } -int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSelectScene(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSelectScene(struct PrepareAudioPara& ptr) { + if (ptr.capture == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.capture->scene.SelectScene(ptr.capture, &(ptr.scenes)); if (ret < 0) { @@ -367,8 +410,11 @@ int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSelectScene(struct RelCap return HDF_SUCCESS; } -int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureCheckSceneCapability(struct RelCaptureAdapterPara& ptr) +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureCheckSceneCapability(struct PrepareAudioPara& ptr) { + if (ptr.capture == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.capture->scene.CheckSceneCapability(ptr.capture, &ptr.scenes, &(ptr.character.supported)); if (ret < 0) { @@ -378,7 +424,7 @@ int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureCheckSceneCapability(stru } /** -* @tc.name RelAudioCreateCapture API via The passed in adaptername is the differentt +* @tc.name RelAudioCreateCapture API via The passed in adaptername is the different * @tc.number SUB_Audio_HDI_AudioCreateCapture_Reliability_0002 * @tc.desc test AudioCreateCapture interface, return 0 if the the capture objects are created successfully * @tc.author: wangkang @@ -386,13 +432,13 @@ int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureCheckSceneCapability(stru HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCreateCapture_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }, { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() } }; pthread_t tids[PTHREAD_DIFFADA_COUNT]; @@ -403,7 +449,7 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCreateCapture_Reliab EXPECT_EQ(HDF_SUCCESS, ret); int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCreateCapture, ¶[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); } for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { void *result = nullptr; @@ -424,13 +470,13 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCreateCapture_Reliab HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioDestroyCapture_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }, { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() } }; pthread_t tids[PTHREAD_DIFFADA_COUNT]; @@ -461,23 +507,23 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioDestroyCapture_Relia HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSetGain_Reliability_0001, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }; - struct RelCaptureAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; ret = RelAudioCaptureProcedure(para); ASSERT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelCaptureAdapterPara), ¶, sizeof(RelCaptureAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); arrpara[i].character.setgain = 2; ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureSetGain, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); } for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { @@ -488,10 +534,8 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSetGain_Relia EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(arrpara[i].character.setgain, arrpara[i].character.getgain); } - ret = para.capture->control.Stop((AudioHandle)(para.capture)); + ret = StopAudio(para); EXPECT_EQ(HDF_SUCCESS, ret); - para.adapter->DestroyCapture(para.adapter, para.capture); - para.manager->UnloadAdapter(para.manager, para.adapter); } /** * @tc.name test AudioCaptureSetVolume API via Multithread call. @@ -502,13 +546,13 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSetGain_Relia HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSetGain_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }, { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() } }; pthread_t tids[PTHREAD_DIFFADA_COUNT]; @@ -518,21 +562,15 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSetGain_Relia para[i].character.setgain = 15; int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureSetGain, ¶[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); } for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - void *result = nullptr; - pthread_join(tids[i], &result); - ret = (intptr_t)result; - EXPECT_EQ(HDF_SUCCESS, ret); + para[i].tids = tids[i]; ret = para[i].capture->volume.GetGain(para[i].capture, &(para[i].character.getgain)); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_LT(INITIAL_VALUE, para[i].character.getgain); - - ret = para[i].capture->control.Stop((AudioHandle)(para[i].capture)); + ret = ThreadRelease(para[i]); EXPECT_EQ(HDF_SUCCESS, ret); - para[i].adapter->DestroyCapture(para[i].adapter, para[i].capture); - para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } } /** @@ -544,25 +582,28 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSetGain_Relia HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetGain_Reliability_0001, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }; - struct RelCaptureAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; - ret = RelAudioCaptureProcedure(para); + ASSERT_NE(nullptr, GetAudioManager); + para.manager = GetAudioManager(); + ASSERT_NE(nullptr, para.manager); + ret = AudioCreateCapture(*para.manager, para.pins, para.adapterName, ¶.adapter, + ¶.capture); ASSERT_EQ(HDF_SUCCESS, ret); - pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelCaptureAdapterPara), ¶, sizeof(RelCaptureAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); arrpara[i].character.setgain = 8; ret = arrpara[i].capture->volume.SetGain(arrpara[i].capture, arrpara[i].character.setgain); EXPECT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetGain, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); } for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { @@ -571,8 +612,6 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetGain_Relia EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); EXPECT_EQ(8, arrpara[i].character.getgain); } - ret = para.capture->control.Stop((AudioHandle)(para.capture)); - EXPECT_EQ(HDF_SUCCESS, ret); para.adapter->DestroyCapture(para.adapter, para.capture); para.manager->UnloadAdapter(para.manager, para.adapter); } @@ -585,34 +624,37 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetGain_Relia HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetGain_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }, { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() } }; pthread_t tids[PTHREAD_DIFFADA_COUNT]; for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - ret = RelAudioCaptureProcedure(para[i]); + ASSERT_NE(nullptr, GetAudioManager); + para[i].manager = GetAudioManager(); + ASSERT_NE(nullptr, para[i].manager); + ret = AudioCreateCapture(*para[i].manager, para[i].pins, para[i].adapterName, ¶[i].adapter, + ¶[i].capture); ASSERT_EQ(HDF_SUCCESS, ret); para[i].character.setgain = 15; ret = para[i].capture->volume.SetGain(para[i].capture, para[i].character.setgain); EXPECT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetGain, ¶[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); } for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - void *result = nullptr; - pthread_join(tids[i], &result); - EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); - EXPECT_LT(INITIAL_VALUE, para[i].character.getgain); - ret = para[i].capture->control.Stop((AudioHandle)(para[i].capture)); + para[i].tids = tids[i]; + pthread_join(para[i].tids, ¶[i].result); + ret = (intptr_t)para[i].result; EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_LT(INITIAL_VALUE, para[i].character.getgain); para[i].adapter->DestroyCapture(para[i].adapter, para[i].capture); para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } @@ -626,22 +668,26 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetGain_Relia HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetGainThreshold_Reliability_0001, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }; - struct RelCaptureAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; - ret = RelAudioCaptureProcedure(para); + ASSERT_NE(nullptr, GetAudioManager); + para.manager = GetAudioManager(); + ASSERT_NE(nullptr, para.manager); + ret = AudioCreateCapture(*para.manager, para.pins, para.adapterName, ¶.adapter, + ¶.capture); ASSERT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelCaptureAdapterPara), ¶, sizeof(RelCaptureAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetGainThreshold, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); } for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { @@ -651,8 +697,6 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetGainThresh EXPECT_EQ(0, arrpara[i].character.gainthresholdmin); EXPECT_EQ(15, arrpara[i].character.gainthresholdmax); } - ret = para.capture->control.Stop((AudioHandle)(para.capture)); - EXPECT_EQ(HDF_SUCCESS, ret); para.adapter->DestroyCapture(para.adapter, para.capture); para.manager->UnloadAdapter(para.manager, para.adapter); } @@ -665,19 +709,23 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetGainThresh HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetGainThreshold_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }, { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() } }; pthread_t tids[PTHREAD_DIFFADA_COUNT]; for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - ret = RelAudioCaptureProcedure(para[i]); + ASSERT_NE(nullptr, GetAudioManager); + para[i].manager = GetAudioManager(); + ASSERT_NE(nullptr, para[i].manager); + ret = AudioCreateCapture(*para[i].manager, para[i].pins, para[i].adapterName, ¶[i].adapter, + ¶[i].capture); ASSERT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetGainThreshold, ¶[i]); EXPECT_EQ(HDF_SUCCESS, ret); @@ -689,8 +737,6 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetGainThresh EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); EXPECT_EQ(0, para[i].character.gainthresholdmin); EXPECT_EQ(15, para[i].character.gainthresholdmax); - ret = para[i].capture->control.Stop((AudioHandle)(para[i].capture)); - EXPECT_EQ(HDF_SUCCESS, ret); para[i].adapter->DestroyCapture(para[i].adapter, para[i].capture); para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } @@ -705,18 +751,22 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetFrameSize_ { int32_t ret = -1; uint64_t sizeValue = 4096; - struct RelCaptureAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }; - struct RelCaptureAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; - ret = RelAudioCaptureProcedure(para); + ASSERT_NE(nullptr, GetAudioManager); + para.manager = GetAudioManager(); + ASSERT_NE(nullptr, para.manager); + ret = AudioCreateCapture(*para.manager, para.pins, para.adapterName, ¶.adapter, + ¶.capture); ASSERT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelCaptureAdapterPara), ¶, sizeof(RelCaptureAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetFrameSize, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); @@ -728,8 +778,6 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetFrameSize_ EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); EXPECT_EQ(sizeValue, arrpara[i].character.getframesize); } - ret = para.capture->control.Stop((AudioHandle)(para.capture)); - EXPECT_EQ(HDF_SUCCESS, ret); para.adapter->DestroyCapture(para.adapter, para.capture); para.manager->UnloadAdapter(para.manager, para.adapter); } @@ -742,19 +790,23 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetFrameSize_ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetFrameSize_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }, { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() } }; pthread_t tids[PTHREAD_DIFFADA_COUNT]; for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - ret = RelAudioCaptureProcedure(para[i]); + ASSERT_NE(nullptr, GetAudioManager); + para[i].manager = GetAudioManager(); + ASSERT_NE(nullptr, para[i].manager); + ret = AudioCreateCapture(*para[i].manager, para[i].pins, para[i].adapterName, ¶[i].adapter, + ¶[i].capture); ASSERT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetFrameSize, ¶[i]); EXPECT_EQ(HDF_SUCCESS, ret); @@ -765,8 +817,6 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetFrameSize_ pthread_join(tids[i], &result); EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); EXPECT_LT(INITIAL_VALUE, para[i].character.getframesize); - ret = para[i].capture->control.Stop((AudioHandle)(para[i].capture)); - EXPECT_EQ(HDF_SUCCESS, ret); para[i].adapter->DestroyCapture(para[i].adapter, para[i].capture); para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } @@ -780,18 +830,18 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetFrameSize_ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetFrameCount_Reliability_0001, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }; - struct RelCaptureAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; ret = RelAudioCaptureProcedure(para); ASSERT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelCaptureAdapterPara), ¶, sizeof(RelCaptureAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetFrameCount, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); @@ -803,10 +853,8 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetFrameCount EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); EXPECT_LT(INITIAL_VALUE, arrpara[i].character.getframecount); } - ret = para.capture->control.Stop((AudioHandle)(para.capture)); + ret = StopAudio(para); EXPECT_EQ(HDF_SUCCESS, ret); - para.adapter->DestroyCapture(para.adapter, para.capture); - para.manager->UnloadAdapter(para.manager, para.adapter); } /** * @tc.name test AudioCaptureGetFrameCount API via Multithread call. @@ -817,13 +865,13 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetFrameCount HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetFrameCount_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }, { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() } }; @@ -836,14 +884,10 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetFrameCount } for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - void *result = nullptr; - pthread_join(tids[i], &result); - EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); - EXPECT_LT(INITIAL_VALUE, para[i].character.getframecount); - ret = para[i].capture->control.Stop((AudioHandle)(para[i].capture)); + para[i].tids = tids[i]; + ret = ThreadRelease(para[i]); EXPECT_EQ(HDF_SUCCESS, ret); - para[i].adapter->DestroyCapture(para[i].adapter, para[i].capture); - para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); + EXPECT_LT(INITIAL_VALUE, para[i].character.getframecount); } } @@ -857,18 +901,22 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioGetCurrentChannelId_ { int32_t ret = -1; uint32_t channelIdValue = 2; - struct RelCaptureAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }; - struct RelCaptureAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; - ret = RelAudioCaptureProcedure(para); + ASSERT_NE(nullptr, GetAudioManager); + para.manager = GetAudioManager(); + ASSERT_NE(nullptr, para.manager); + ret = AudioCreateCapture(*para.manager, para.pins, para.adapterName, ¶.adapter, + ¶.capture); ASSERT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelCaptureAdapterPara), ¶, sizeof(RelCaptureAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); arrpara[i].character.getcurrentchannelId = 0; ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetCurrentChannelId, &arrpara[i]); @@ -881,8 +929,6 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioGetCurrentChannelId_ EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); EXPECT_EQ(channelIdValue, arrpara[i].character.getcurrentchannelId); } - ret = para.capture->control.Stop((AudioHandle)(para.capture)); - EXPECT_EQ(HDF_SUCCESS, ret); para.adapter->DestroyCapture(para.adapter, para.capture); para.manager->UnloadAdapter(para.manager, para.adapter); } @@ -896,19 +942,23 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_CaptureGetCurrentChannelI { int32_t ret = -1; uint32_t channelIdValue = 2; - struct RelCaptureAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }, { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() } }; pthread_t tids[PTHREAD_DIFFADA_COUNT]; for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - ret = RelAudioCaptureProcedure(para[i]); + ASSERT_NE(nullptr, GetAudioManager); + para[i].manager = GetAudioManager(); + ASSERT_NE(nullptr, para[i].manager); + ret = AudioCreateCapture(*para[i].manager, para[i].pins, para[i].adapterName, ¶[i].adapter, + ¶[i].capture); ASSERT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetCurrentChannelId, ¶[i]); EXPECT_EQ(HDF_SUCCESS, ret); @@ -919,8 +969,6 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_CaptureGetCurrentChannelI pthread_join(tids[i], &result); EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); EXPECT_EQ(channelIdValue, para[i].character.getcurrentchannelId); - ret = para[i].capture->control.Stop((AudioHandle)(para[i].capture)); - EXPECT_EQ(HDF_SUCCESS, ret); para[i].adapter->DestroyCapture(para[i].adapter, para[i].capture); para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } @@ -935,18 +983,18 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_CaptureGetCurrentChannelI HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSetMute_0001, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para = { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + struct PrepareAudioPara para = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }; - struct RelCaptureAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; ret = RelAudioCaptureProcedure(para); ASSERT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelCaptureAdapterPara), ¶, sizeof(RelCaptureAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); ret = arrpara[i].capture->volume.GetMute(arrpara[i].capture, &(arrpara[i].character.getmute)); EXPECT_EQ(HDF_SUCCESS, ret); @@ -957,7 +1005,7 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSetMute_0001, } ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureSetMute, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); ret = arrpara[i].capture->volume.GetMute(arrpara[i].capture, &(arrpara[i].character.getmute)); EXPECT_EQ(HDF_SUCCESS, ret); if (arrpara[i].character.setmute == true) { @@ -972,10 +1020,8 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSetMute_0001, pthread_join(tids[i], &result); EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); } - ret = para.capture->control.Stop((AudioHandle)(para.capture)); + ret = StopAudio(para); EXPECT_EQ(HDF_SUCCESS, ret); - para.adapter->DestroyCapture(para.adapter, para.capture); - para.manager->UnloadAdapter(para.manager, para.adapter); } /** * @tc.name RelAudioCaptureSetMute @@ -986,13 +1032,13 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSetMute_0001, HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSetMute_0002, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }, { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() } }; @@ -1009,7 +1055,7 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSetMute_0002, } ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureSetMute, ¶[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); ret = para[i].capture->volume.GetMute(para[i].capture, &(para[i].character.getmute)); EXPECT_EQ(HDF_SUCCESS, ret); if (para[i].character.setmute == true) { @@ -1020,13 +1066,9 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSetMute_0002, } for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - void *result = nullptr; - pthread_join(tids[i], &result); - EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); - ret = para[i].capture->control.Stop((AudioHandle)(para[i].capture)); + para[i].tids = tids[i]; + ret = ThreadRelease(para[i]); EXPECT_EQ(HDF_SUCCESS, ret); - para[i].adapter->DestroyCapture(para[i].adapter, para[i].capture); - para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } } /** @@ -1038,25 +1080,29 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSetMute_0002, HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetMute_0001, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para = { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + struct PrepareAudioPara para = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }; - struct RelCaptureAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; - ret = RelAudioCaptureProcedure(para); + ASSERT_NE(nullptr, GetAudioManager); + para.manager = GetAudioManager(); + ASSERT_NE(nullptr, para.manager); + ret = AudioCreateCapture(*para.manager, para.pins, para.adapterName, ¶.adapter, + ¶.capture); ASSERT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelCaptureAdapterPara), ¶, sizeof(RelCaptureAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); arrpara[i].character.setmute = true; ret = arrpara[i].capture->volume.SetMute(arrpara[i].capture, false); EXPECT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetMute, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); } for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { @@ -1065,8 +1111,6 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetMute_0001, EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); EXPECT_FALSE(arrpara[i].character.getmute); } - ret = para.capture->control.Stop((AudioHandle)(para.capture)); - EXPECT_EQ(HDF_SUCCESS, ret); para.adapter->DestroyCapture(para.adapter, para.capture); para.manager->UnloadAdapter(para.manager, para.adapter); } @@ -1079,27 +1123,31 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetMute_0001, HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetMute_0002, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }, { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() } }; pthread_t tids[PTHREAD_DIFFADA_COUNT]; for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - ret = RelAudioCaptureProcedure(para[i]); + ASSERT_NE(nullptr, GetAudioManager); + para[i].manager = GetAudioManager(); + ASSERT_NE(nullptr, para[i].manager); + ret = AudioCreateCapture(*para[i].manager, para[i].pins, para[i].adapterName, ¶[i].adapter, + ¶[i].capture); ASSERT_EQ(HDF_SUCCESS, ret); para[i].character.setmute = true; ret = para[i].capture->volume.SetMute(para[i].capture, false); EXPECT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetMute, ¶[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); } for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { @@ -1107,8 +1155,175 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetMute_0002, pthread_join(tids[i], &result); EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); EXPECT_FALSE(para[i].character.getmute); - ret = para[i].capture->control.Stop((AudioHandle)(para[i].capture)); + para[i].adapter->DestroyCapture(para[i].adapter, para[i].capture); + para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); + } +} +/** +* @tc.name test AudioCaptureSetVolume API via Multithread call. +* @tc.number SUB_Audio_HDI_AudiocaptureSetVolume_Reliability_0001 +* @tc.desc test SetVolume interface Reliability pass through pthread_create fun and adapterName is same. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSetVolume_Reliability_0001, TestSize.Level1) +{ + int32_t ret = -1; + float volumeHighExpc = 0.70; + struct PrepareAudioPara para = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() + }; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; + + ret = RelAudioCaptureProcedure(para); + ASSERT_EQ(HDF_SUCCESS, ret); + + pthread_t tids[PTHREAD_SAMEADA_COUNT]; + for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); + ret = arrpara[i].capture->volume.GetVolume(arrpara[i].capture, &(arrpara[i].character.getvolume)); + EXPECT_EQ(HDF_SUCCESS, ret); + arrpara[i].character.setvolume = 0.7; + ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureSetVolume, &arrpara[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + usleep(10000); + } + + for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { + void *result = nullptr; + pthread_join(tids[i], &result); + EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); + ret = arrpara[i].capture->volume.GetVolume(arrpara[i].capture, &(arrpara[i].character.getvolume)); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(volumeHighExpc, arrpara[i].character.getvolume); + } + ret = StopAudio(para); + EXPECT_EQ(HDF_SUCCESS, ret); +} +/** +* @tc.name test AudioCaptureSetVolume API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioCaptureSetVolume_Reliability_0002 +* @tc.desc test SetVolume interface Reliability pass through pthread_create fun and adapterName is different +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSetVolume_Reliability_0002, TestSize.Level1) +{ + int32_t ret = -1; + float volumeHighExpc = 0.6; + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { + { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() + }, { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() + } + }; + pthread_t tids[PTHREAD_DIFFADA_COUNT]; + for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { + ret = RelAudioCaptureProcedure(para[i]); + ASSERT_EQ(HDF_SUCCESS, ret); + para[i].character.setvolume = 0.6; + ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureSetVolume, ¶[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + usleep(10000); + } + for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { + void *result = nullptr; + pthread_join(tids[i], &result); + EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); + ret = para[i].capture->volume.GetVolume(para[i].capture, &(para[i].character.getvolume)); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(volumeHighExpc, para[i].character.getvolume); + ret = StopAudio(para[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + } +} +/** +* @tc.name test AudioCaptureGetVolume API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioCaptureGetVolume_Reliability_0001 +* @tc.desc test GetVolume interface Reliability pass through pthread_create fun and adapterName is same. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetVolume_Reliability_0001, TestSize.Level1) +{ + int32_t ret = -1; + float volumeHighExpc = 0.7; + struct PrepareAudioPara para = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() + }; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; + + ASSERT_NE(nullptr, GetAudioManager); + para.manager = GetAudioManager(); + ASSERT_NE(nullptr, para.manager); + ret = AudioCreateCapture(*para.manager, para.pins, para.adapterName, ¶.adapter, + ¶.capture); + ASSERT_EQ(HDF_SUCCESS, ret); + + pthread_t tids[PTHREAD_SAMEADA_COUNT]; + for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); + EXPECT_EQ(HDF_SUCCESS, ret); + arrpara[i].character.setvolume = 0.7; + ret = arrpara[i].capture->volume.SetVolume(arrpara[i].capture, arrpara[i].character.setvolume); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetVolume, &arrpara[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + usleep(10000); + } + + for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { + void *result = nullptr; + pthread_join(tids[i], &result); + EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); + EXPECT_EQ(volumeHighExpc, arrpara[i].character.getvolume); + } + para.adapter->DestroyCapture(para.adapter, para.capture); + para.manager->UnloadAdapter(para.manager, para.adapter); +} +/** +* @tc.name test AudioCaptureGetVolume API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioCaptureGetVolume_Reliability_0002 +* @tc.desc test GetVolume interface Reliability pass through pthread_create fun and adapterName is different. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetVolume_Reliability_0002, TestSize.Level1) +{ + int32_t ret = -1; + float volumeHighExpc = 0.6; + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { + { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() + }, { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() + } + }; + + pthread_t tids[PTHREAD_DIFFADA_COUNT]; + for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { + ASSERT_NE(nullptr, GetAudioManager); + para[i].manager = GetAudioManager(); + ASSERT_NE(nullptr, para[i].manager); + ret = AudioCreateCapture(*para[i].manager, para[i].pins, para[i].adapterName, ¶[i].adapter, + ¶[i].capture); + ASSERT_EQ(HDF_SUCCESS, ret); + para[i].character.setvolume = 0.6; + ret = para[i].capture->volume.SetVolume(para[i].capture, para[i].character.setvolume); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetVolume, ¶[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + usleep(10000); + } + for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { + void *result = nullptr; + pthread_join(tids[i], &result); + EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); + EXPECT_EQ(volumeHighExpc, para[i].character.getvolume); para[i].adapter->DestroyCapture(para[i].adapter, para[i].capture); para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } @@ -1116,7 +1331,7 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetMute_0002, /** * @tc.name test AudioCaptureSetSampleAttributes API via Multithread call. * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_Reliability_0001 -* @tc.desc test AudioCaptureSetSampleAttributes interface Reliability pass through pthread_create fun and adapterName +* @tc.desc test SetSampleAttributes interface Reliability pass through pthread_create fun and adapterName is same. * @tc.author: ZHANGHAILIN */ @@ -1125,22 +1340,26 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSetSampleAttr { int32_t ret = -1; uint32_t count = 2; - struct RelCaptureAdapterPara para = { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + struct PrepareAudioPara para = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }; - struct RelCaptureAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; - ret = RelAudioCaptureProcedure(para); + ASSERT_NE(nullptr, GetAudioManager); + para.manager = GetAudioManager(); + ASSERT_NE(nullptr, para.manager); + ret = AudioCreateCapture(*para.manager, para.pins, para.adapterName, ¶.adapter, + ¶.capture); ASSERT_EQ(HDF_SUCCESS, ret); InitAttrs(para.attrs); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelCaptureAdapterPara), ¶, sizeof(RelCaptureAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureSetSampleAttributes, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); ret = arrpara[i].capture->attr.GetSampleAttributes(arrpara[i].capture, &(arrpara[i].attrsValue)); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(AUDIO_IN_MEDIA, arrpara[i].attrsValue.type); @@ -1155,8 +1374,6 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSetSampleAttr pthread_join(tids[i], &result); EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); } - ret = para.capture->control.Stop((AudioHandle)(para.capture)); - EXPECT_EQ(HDF_SUCCESS, ret); para.adapter->DestroyCapture(para.adapter, para.capture); para.manager->UnloadAdapter(para.manager, para.adapter); } @@ -1172,28 +1389,29 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSetSampleAttr { int32_t ret = -1; uint32_t count = 2; - struct RelCaptureAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }, { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() } }; pthread_t tids[PTHREAD_DIFFADA_COUNT]; for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { ret = RelAudioCaptureProcedure(para[i]); - if (ret < 0) { - para[i].adapter->DestroyCapture(para[i].adapter, para[i].capture); - para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + ASSERT_NE(nullptr, GetAudioManager); + para[i].manager = GetAudioManager(); + ASSERT_NE(nullptr, para[i].manager); + ret = AudioCreateCapture(*para[i].manager, para[i].pins, para[i].adapterName, ¶[i].adapter, + ¶[i].capture); + ASSERT_EQ(HDF_SUCCESS, ret); InitAttrs(para[i].attrs); int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureSetSampleAttributes, ¶[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); ret = para[i].capture->attr.GetSampleAttributes(para[i].capture, &(para[i].attrsValue)); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(AUDIO_IN_MEDIA, para[i].attrsValue.type); @@ -1207,8 +1425,6 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSetSampleAttr void *result = nullptr; pthread_join(tids[i], &result); EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); - ret = para[i].capture->control.Stop((AudioHandle)(para[i].capture)); - EXPECT_EQ(HDF_SUCCESS, ret); para[i].adapter->DestroyCapture(para[i].adapter, para[i].capture); para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } @@ -1225,25 +1441,29 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetSampleAttr { int32_t ret = -1; uint32_t count = 2; - struct RelCaptureAdapterPara para = { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + struct PrepareAudioPara para = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }; - struct RelCaptureAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; - ret = RelAudioCaptureProcedure(para); + ASSERT_NE(nullptr, GetAudioManager); + para.manager = GetAudioManager(); + ASSERT_NE(nullptr, para.manager); + ret = AudioCreateCapture(*para.manager, para.pins, para.adapterName, ¶.adapter, + ¶.capture); ASSERT_EQ(HDF_SUCCESS, ret); InitAttrs(para.attrs); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelCaptureAdapterPara), ¶, sizeof(RelCaptureAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); ret = arrpara[i].capture->attr.SetSampleAttributes(arrpara[i].capture, &(arrpara[i].attrs)); EXPECT_EQ(HDF_SUCCESS, ret); int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetSampleAttributes, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); EXPECT_EQ(AUDIO_IN_MEDIA, arrpara[i].attrsValue.type); EXPECT_FALSE(arrpara[i].attrsValue.interleaved); EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, arrpara[i].attrsValue.format); @@ -1256,8 +1476,6 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetSampleAttr pthread_join(tids[i], &result); EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); } - ret = para.capture->control.Stop((AudioHandle)(para.capture)); - EXPECT_EQ(HDF_SUCCESS, ret); para.adapter->DestroyCapture(para.adapter, para.capture); para.manager->UnloadAdapter(para.manager, para.adapter); } @@ -1273,19 +1491,23 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetSampleAttr { int32_t ret = -1; uint32_t count = 2; - struct RelCaptureAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }, { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() } }; pthread_t tids[PTHREAD_DIFFADA_COUNT]; for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - ret = RelAudioCaptureProcedure(para[i]); + ASSERT_NE(nullptr, GetAudioManager); + para[i].manager = GetAudioManager(); + ASSERT_NE(nullptr, para[i].manager); + ret = AudioCreateCapture(*para[i].manager, para[i].pins, para[i].adapterName, ¶[i].adapter, + ¶[i].capture); ASSERT_EQ(HDF_SUCCESS, ret); InitAttrs(para[i].attrs); ret = para[i].capture->attr.SetSampleAttributes(para[i].capture, &(para[i].attrs)); @@ -1293,7 +1515,7 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetSampleAttr ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetSampleAttributes, ¶[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); EXPECT_EQ(AUDIO_IN_MEDIA, para[i].attrsValue.type); EXPECT_FALSE(para[i].attrsValue.interleaved); EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, para[i].attrsValue.format); @@ -1305,8 +1527,6 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetSampleAttr void *result = nullptr; pthread_join(tids[i], &result); EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); - ret = para[i].capture->control.Stop((AudioHandle)(para[i].capture)); - EXPECT_EQ(HDF_SUCCESS, ret); para[i].adapter->DestroyCapture(para[i].adapter, para[i].capture); para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } @@ -1321,18 +1541,22 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetSampleAttr HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSelectScene_Reliability_0001, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para = { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + struct PrepareAudioPara para = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }; - struct RelCaptureAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; - ret = RelAudioCaptureProcedure(para); + ASSERT_NE(nullptr, GetAudioManager); + para.manager = GetAudioManager(); + ASSERT_NE(nullptr, para.manager); + ret = AudioCreateCapture(*para.manager, para.pins, para.adapterName, ¶.adapter, + ¶.capture); ASSERT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelCaptureAdapterPara), ¶, sizeof(RelCaptureAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); arrpara[i].scenes.scene.id = 0; arrpara[i].scenes.desc.pins = PIN_IN_MIC; @@ -1345,8 +1569,6 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSelectScene_R pthread_join(tids[i], &result); EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); } - ret = para.capture->control.Stop((AudioHandle)(para.capture)); - EXPECT_EQ(HDF_SUCCESS, ret); para.adapter->DestroyCapture(para.adapter, para.capture); para.manager->UnloadAdapter(para.manager, para.adapter); } @@ -1361,19 +1583,23 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSelectScene_R HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSelectScene_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }, { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() } }; pthread_t tids[PTHREAD_DIFFADA_COUNT]; for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - ret = RelAudioCaptureProcedure(para[i]); + ASSERT_NE(nullptr, GetAudioManager); + para[i].manager = GetAudioManager(); + ASSERT_NE(nullptr, para[i].manager); + ret = AudioCreateCapture(*para[i].manager, para[i].pins, para[i].adapterName, ¶[i].adapter, + ¶[i].capture); ASSERT_EQ(HDF_SUCCESS, ret); para[i].scenes.scene.id = 0; para[i].scenes.desc.pins = PIN_IN_MIC; @@ -1385,8 +1611,6 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSelectScene_R void *result = nullptr; pthread_join(tids[i], &result); EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); - ret = para[i].capture->control.Stop((AudioHandle)(para[i].capture)); - EXPECT_EQ(HDF_SUCCESS, ret); para[i].adapter->DestroyCapture(para[i].adapter, para[i].capture); para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } @@ -1402,18 +1626,22 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureCheckSceneCap TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para = { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + struct PrepareAudioPara para = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }; - struct RelCaptureAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; - ret = RelAudioCaptureProcedure(para); + ASSERT_NE(nullptr, GetAudioManager); + para.manager = GetAudioManager(); + ASSERT_NE(nullptr, para.manager); + ret = AudioCreateCapture(*para.manager, para.pins, para.adapterName, ¶.adapter, + ¶.capture); ASSERT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelCaptureAdapterPara), ¶, sizeof(RelCaptureAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); arrpara[i].scenes.scene.id = 0; arrpara[i].scenes.desc.pins = PIN_IN_MIC; @@ -1426,8 +1654,6 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureCheckSceneCap pthread_join(tids[i], &result); EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); } - ret = para.capture->control.Stop((AudioHandle)(para.capture)); - EXPECT_EQ(HDF_SUCCESS, ret); para.adapter->DestroyCapture(para.adapter, para.capture); para.manager->UnloadAdapter(para.manager, para.adapter); } @@ -1443,19 +1669,23 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureCheckSceneCap TestSize.Level1) { int32_t ret = -1; - struct RelCaptureAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() }, { - .portType = PORT_IN, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, - .path = AUDIO_FILE.c_str() + .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str() } }; pthread_t tids[PTHREAD_DIFFADA_COUNT]; for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - ret = RelAudioCaptureProcedure(para[i]); + ASSERT_NE(nullptr, GetAudioManager); + para[i].manager = GetAudioManager(); + ASSERT_NE(nullptr, para[i].manager); + ret = AudioCreateCapture(*para[i].manager, para[i].pins, para[i].adapterName, ¶[i].adapter, + ¶[i].capture); ASSERT_EQ(HDF_SUCCESS, ret); para[i].scenes.scene.id = 0; para[i].scenes.desc.pins = PIN_IN_MIC; @@ -1467,8 +1697,6 @@ HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureCheckSceneCap void *result = nullptr; pthread_join(tids[i], &result); EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); - ret = para[i].capture->control.Stop((AudioHandle)(para[i].capture)); - EXPECT_EQ(HDF_SUCCESS, ret); para[i].adapter->DestroyCapture(para[i].adapter, para[i].capture); para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } diff --git a/audio/test/systemtest/hdi/hdireliability/src/audio_hdirender_control_reliability_test.cpp b/audio/test/systemtest/hdi/hdireliability/src/audio_hdirender_control_reliability_test.cpp old mode 100644 new mode 100755 index cc1b472abd..b530271654 --- a/audio/test/systemtest/hdi/hdireliability/src/audio_hdirender_control_reliability_test.cpp +++ b/audio/test/systemtest/hdi/hdireliability/src/audio_hdirender_control_reliability_test.cpp @@ -22,10 +22,9 @@ using namespace testing::ext; using namespace HMOS::Audio; namespace { -const string AUDIO_FILE = "//bin/audiorendertest.wav"; -const string ADAPTER_NAME = "hdmi"; -const string ADAPTER_NAME2 = "usb"; -const string ADAPTER_NAME3 = "internal"; +const string ADAPTER_NAME_HDMI = "hdmi"; +const string ADAPTER_NAME_USB = "usb"; +const string ADAPTER_NAME_INTERNAL = "internal"; const int PTHREAD_SAMEADA_COUNT = 10; const int PTHREAD_DIFFADA_COUNT = 3; @@ -35,73 +34,93 @@ public: static void TearDownTestCase(void); void SetUp(); void TearDown(); - struct AudioManager *(*GetAudioManager)() = nullptr; - void *handleSo = nullptr; - static int32_t RelGetAllAdapter(struct RelRenderAdapterPara& ptr); - static int32_t RelLoadAdapter(struct RelRenderAdapterPara& ptr); - static int32_t RelUnloadAdapter(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioCreateRender(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioRenderStart(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioRenderFrame(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioRenderStop(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioRenderStartAndFrame(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioRenderProcedure(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioRenderPause(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioRenderResume(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioRenderGetRenderPosition(struct RelRenderAdapterPara& ptr); + static TestAudioManager *(*GetAudioManager)(); + static void *handleSo; +#ifdef AUDIO_MPI_SO + static int32_t (*SdkInit)(); + static void (*SdkExit)(); + static void *sdkSo; +#endif + static int32_t RelGetAllAdapter(struct PrepareAudioPara& ptr); + static int32_t RelLoadAdapter(struct PrepareAudioPara& ptr); + static int32_t RelUnloadAdapter(struct PrepareAudioPara& ptr); + static int32_t RelAudioCreateRender(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderStart(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderFrame(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderStop(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderStartAndFrame(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderProcedure(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderPause(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderResume(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderGetRenderPosition(struct PrepareAudioPara& ptr); }; using THREAD_FUNC = void *(*)(void *); -void AudioHdiRenderControlReliabilityTest::SetUpTestCase(void) {} +TestAudioManager *(*AudioHdiRenderControlReliabilityTest::GetAudioManager)() = nullptr; +void *AudioHdiRenderControlReliabilityTest::handleSo = nullptr; +#ifdef AUDIO_MPI_SO + int32_t (*AudioHdiRenderControlReliabilityTest::SdkInit)() = nullptr; + void (*AudioHdiRenderControlReliabilityTest::SdkExit)() = nullptr; + void *AudioHdiRenderControlReliabilityTest::sdkSo = nullptr; +#endif -void AudioHdiRenderControlReliabilityTest::TearDownTestCase(void) {} - -void AudioHdiRenderControlReliabilityTest::SetUp(void) +void AudioHdiRenderControlReliabilityTest::SetUpTestCase(void) { - char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; - handleSo = dlopen(resolvedPath, RTLD_LAZY); +#ifdef AUDIO_MPI_SO + char sdkResolvedPath[] = "//system/lib/libhdi_audio_interface_lib_render.z.so"; + sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY); + if (sdkSo == nullptr) { + return; + } + SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit")); + if (SdkInit == nullptr) { + return; + } + SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit")); + if (SdkExit == nullptr) { + return; + } + SdkInit(); +#endif + handleSo = dlopen(RESOLVED_PATH.c_str(), RTLD_LAZY); if (handleSo == nullptr) { return; } - GetAudioManager = (struct AudioManager* (*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); + GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str())); if (GetAudioManager == nullptr) { return; } } -void AudioHdiRenderControlReliabilityTest::TearDown(void) +void AudioHdiRenderControlReliabilityTest::TearDownTestCase(void) { +#ifdef AUDIO_MPI_SO + SdkExit(); + if (sdkSo != nullptr) { + dlclose(sdkSo); + sdkSo = nullptr; + } + if (SdkInit != nullptr) { + SdkInit = nullptr; + } + if (SdkExit != nullptr) { + SdkExit = nullptr; + } +#endif if (GetAudioManager != nullptr) { GetAudioManager = nullptr; } } -struct RenderCharacteristic { - uint64_t getframes; -}; +void AudioHdiRenderControlReliabilityTest::SetUp(void) {} -struct RelRenderAdapterPara { - struct AudioManager *manager; - enum AudioPortDirection portType; - const char *adapterName; - struct AudioAdapter *adapter; - struct AudioPort renderPort; - void *param; - enum AudioPortPin pins; - const char *path; - struct AudioRender *render; - struct AudioHeadInfo headInfo; - struct AudioAdapterDescriptor *desc; - struct AudioAdapterDescriptor *descs; - struct RenderCharacteristic character; - struct AudioTimeStamp time = {.tvNSec = 1}; -}; +void AudioHdiRenderControlReliabilityTest::TearDown(void) {} -int32_t AudioHdiRenderControlReliabilityTest::RelGetAllAdapter(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderControlReliabilityTest::RelGetAllAdapter(struct PrepareAudioPara& ptr) { int size = 0; - auto *inst = (AudioHdiRenderControlReliabilityTest *)ptr.param; + auto *inst = (AudioHdiRenderControlReliabilityTest *)ptr.self; if (inst != nullptr && inst->GetAudioManager != nullptr) { ptr.manager = inst->GetAudioManager(); } @@ -112,7 +131,7 @@ int32_t AudioHdiRenderControlReliabilityTest::RelGetAllAdapter(struct RelRenderA if (ptr.descs == nullptr || size == 0) { return HDF_FAILURE; } else { - int index = SwitchAdapter(ptr.descs, ptr.adapterName, ptr.portType, ptr.renderPort, size); + int index = SwitchAdapter(ptr.descs, ptr.adapterName, ptr.portType, ptr.audioPort, size); if (index < 0) { return HDF_FAILURE; } else { @@ -125,7 +144,7 @@ int32_t AudioHdiRenderControlReliabilityTest::RelGetAllAdapter(struct RelRenderA return HDF_SUCCESS; } -int32_t AudioHdiRenderControlReliabilityTest::RelLoadAdapter(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderControlReliabilityTest::RelLoadAdapter(struct PrepareAudioPara& ptr) { ptr.manager->LoadAdapter(ptr.manager, ptr.desc, &ptr.adapter); @@ -135,7 +154,7 @@ int32_t AudioHdiRenderControlReliabilityTest::RelLoadAdapter(struct RelRenderAda return HDF_SUCCESS; } -int32_t AudioHdiRenderControlReliabilityTest::RelAudioCreateRender(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderControlReliabilityTest::RelAudioCreateRender(struct PrepareAudioPara& ptr) { int32_t ret = -1; struct AudioSampleAttributes attrs = {}; @@ -144,7 +163,7 @@ int32_t AudioHdiRenderControlReliabilityTest::RelAudioCreateRender(struct RelRen return HDF_FAILURE; } InitAttrs(attrs); - InitDevDesc(devDesc, (&ptr.renderPort)->portId, ptr.pins); + InitDevDesc(devDesc, (&ptr.audioPort)->portId, ptr.pins); ret = ptr.adapter->CreateRender(ptr.adapter, &devDesc, &attrs, &ptr.render); if (ret < 0 || ptr.render == nullptr) { ptr.manager->UnloadAdapter(ptr.manager, ptr.adapter); @@ -153,7 +172,7 @@ int32_t AudioHdiRenderControlReliabilityTest::RelAudioCreateRender(struct RelRen return HDF_SUCCESS; } -int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderStartAndFrame(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderStartAndFrame(struct PrepareAudioPara& ptr) { int32_t ret = -1; struct AudioSampleAttributes attrs = {}; @@ -165,11 +184,10 @@ int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderStartAndFrame(struct if (file == nullptr) { return HDF_FAILURE; } - ret = InitAttrs(attrs); - if (ret < 0) { - return HDF_FAILURE; - } + InitAttrs(attrs); + if (HMOS::Audio::WavHeadAnalysis(ptr.headInfo, file, attrs) < 0) { + fclose(file); return HDF_FAILURE; } else { ret = HMOS::Audio::FrameStart(ptr.headInfo, ptr.render, file, attrs); @@ -184,8 +202,11 @@ int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderStartAndFrame(struct return HDF_SUCCESS; } -int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderStart(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderStart(struct PrepareAudioPara& ptr) { + if (ptr.render == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.render->control.Start((AudioHandle)(ptr.render)); if (ret < 0) { @@ -194,7 +215,7 @@ int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderStart(struct RelRend return HDF_SUCCESS; } -int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderFrame(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderFrame(struct PrepareAudioPara& ptr) { int32_t ret = -1; uint64_t requestBytes = 0; @@ -220,8 +241,11 @@ int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderFrame(struct RelRend return HDF_SUCCESS; } -int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderStop(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderStop(struct PrepareAudioPara& ptr) { + if (ptr.render == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.render->control.Stop((AudioHandle)(ptr.render)); if (ret < 0) { @@ -230,8 +254,11 @@ int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderStop(struct RelRende return HDF_SUCCESS; } -int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderPause(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderPause(struct PrepareAudioPara& ptr) { + if (ptr.render == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.render->control.Pause((AudioHandle)(ptr.render)); if (ret < 0) { @@ -240,8 +267,11 @@ int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderPause(struct RelRend return HDF_SUCCESS; } -int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderResume(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderResume(struct PrepareAudioPara& ptr) { + if (ptr.render == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.render->control.Resume((AudioHandle)(ptr.render)); if (ret < 0) { @@ -250,7 +280,7 @@ int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderResume(struct RelRen return HDF_SUCCESS; } -int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderProcedure(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderProcedure(struct PrepareAudioPara& ptr) { int32_t ret = -1; ret = RelGetAllAdapter(ptr); @@ -270,13 +300,18 @@ int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderProcedure(struct Rel ret = RelAudioRenderStartAndFrame(ptr); if (ret < 0) { + ptr.adapter->DestroyRender(ptr.adapter, ptr.render); + ptr.manager->UnloadAdapter(ptr.manager, ptr.adapter); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderGetRenderPosition(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderGetRenderPosition(struct PrepareAudioPara& ptr) { + if (ptr.render == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.render->GetRenderPosition(ptr.render, &(ptr.character.getframes), &(ptr.time)); if (ret < 0) { @@ -294,15 +329,15 @@ int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderGetRenderPosition(st HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioGetAllAdapter_Reliability_0001, TestSize.Level1) { int32_t ret = -1; - struct RelRenderAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; - struct RelRenderAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelRenderAdapterPara), ¶, sizeof(RelRenderAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelGetAllAdapter, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); @@ -323,15 +358,15 @@ HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioGetAllAdapter_ HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioLoadlAdapter_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() } }; @@ -363,15 +398,15 @@ HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioLoadlAdapter_R int32_t ret = -1; int32_t failcount = 0; int32_t succeedcount = 0; - struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() } }; @@ -411,11 +446,11 @@ HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderStart_Re int32_t ret = -1; int32_t failcount = 0; int32_t succeedcount = 0; - struct RelRenderAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; - struct RelRenderAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; ret = RelGetAllAdapter(para); EXPECT_EQ(HDF_SUCCESS, ret); @@ -426,7 +461,7 @@ HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderStart_Re pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelRenderAdapterPara), ¶, sizeof(RelRenderAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderStart, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); @@ -444,10 +479,8 @@ HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderStart_Re failcount = failcount + 1; } } - ret = para.render->control.Stop((AudioHandle)(para.render)); + ret = StopAudio(para); EXPECT_EQ(HDF_SUCCESS, ret); - para.adapter->DestroyRender(para.adapter, para.render); - para.manager->UnloadAdapter(para.manager, para.adapter); EXPECT_EQ(failcount, PTHREAD_SAMEADA_COUNT - 1); EXPECT_EQ(succeedcount, 1); } @@ -461,15 +494,15 @@ HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderStart_Re HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderStart_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() } }; @@ -485,14 +518,9 @@ HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderStart_Re EXPECT_EQ(HDF_SUCCESS, ret); } for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - void *result = nullptr; - pthread_join(tids[i], &result); - ret = (intptr_t)result; + para[i].tids = tids[i]; + ret = ThreadRelease(para[i]); EXPECT_EQ(HDF_SUCCESS, ret); - ret = para[i].render->control.Stop((AudioHandle)(para[i].render)); - EXPECT_EQ(HDF_SUCCESS, ret); - para[i].adapter->DestroyRender(para[i].adapter, para[i].render); - para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } } @@ -505,15 +533,15 @@ HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderStart_Re HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderFrame_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() } }; @@ -532,14 +560,9 @@ HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderFrame_Re usleep(50000); } for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - void *result = nullptr; - pthread_join(tids[i], &result); - ret = (intptr_t)result; - EXPECT_EQ(HDF_SUCCESS, ret); - ret = para[i].render->control.Stop((AudioHandle)(para[i].render)); + para[i].tids = tids[i]; + ret = ThreadRelease(para[i]); EXPECT_EQ(HDF_SUCCESS, ret); - para[i].adapter->DestroyRender(para[i].adapter, para[i].render); - para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } } @@ -554,17 +577,17 @@ HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderStop_Rel int32_t ret = -1; int32_t failcount = 0; int32_t succeedcount = 0; - struct RelRenderAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; - struct RelRenderAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; ret = RelAudioRenderProcedure(para); ASSERT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelRenderAdapterPara), ¶, sizeof(RelRenderAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderStop, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); @@ -598,15 +621,15 @@ HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderStop_Rel HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderStop_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() } }; @@ -638,18 +661,18 @@ HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderPause_Re int32_t ret = -1; int32_t failcount = 0; int32_t succeedcount = 0; - struct RelRenderAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; - struct RelRenderAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; ret = RelAudioRenderProcedure(para); ASSERT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelRenderAdapterPara), ¶, sizeof(RelRenderAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderPause, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); @@ -668,9 +691,8 @@ HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderPause_Re failcount = failcount + 1; } } - para.render->control.Stop((AudioHandle)(para.render)); - para.adapter->DestroyRender(para.adapter, para.render); - para.manager->UnloadAdapter(para.manager, para.adapter); + ret = StopAudio(para); + EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(failcount, PTHREAD_SAMEADA_COUNT - 1); EXPECT_EQ(succeedcount, 1); } @@ -684,15 +706,15 @@ HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderPause_Re HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderPause_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() } }; @@ -704,14 +726,9 @@ HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderPause_Re EXPECT_EQ(HDF_SUCCESS, ret); } for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - void *result = nullptr; - pthread_join(tids[i], &result); - EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); - - ret = para[i].render->control.Stop((AudioHandle)(para[i].render)); + para[i].tids = tids[i]; + ret = ThreadRelease(para[i]); EXPECT_EQ(HDF_SUCCESS, ret); - para[i].adapter->DestroyRender(para[i].adapter, para[i].render); - para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } } @@ -726,11 +743,11 @@ HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderResume_R int32_t ret = -1; int32_t failcount = 0; int32_t succeedcount = 0; - struct RelRenderAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; - struct RelRenderAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; ret = RelAudioRenderProcedure(para); ASSERT_EQ(HDF_SUCCESS, ret); @@ -739,7 +756,7 @@ HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderResume_R pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelRenderAdapterPara), ¶, sizeof(RelRenderAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderResume, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); @@ -758,9 +775,8 @@ HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderResume_R failcount = failcount + 1; } } - para.render->control.Stop((AudioHandle)(para.render)); - para.adapter->DestroyRender(para.adapter, para.render); - para.manager->UnloadAdapter(para.manager, para.adapter); + ret = StopAudio(para); + EXPECT_EQ(HDF_SUCCESS, ret); } /** * @tc.name test AudioRenderResume API via Multithread call. @@ -771,15 +787,15 @@ HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderResume_R HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderResume_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() } }; @@ -793,14 +809,9 @@ HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderResume_R EXPECT_EQ(HDF_SUCCESS, ret); } for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - void *result = nullptr; - pthread_join(tids[i], &result); - EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); - - ret = para[i].render->control.Stop((AudioHandle)(para[i].render)); + para[i].tids = tids[i]; + ret = ThreadRelease(para[i]); EXPECT_EQ(HDF_SUCCESS, ret); - para[i].adapter->DestroyRender(para[i].adapter, para[i].render); - para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } } @@ -815,18 +826,18 @@ HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderGetRende { int32_t ret = -1; int64_t timeExp = 0; - struct RelRenderAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; - struct RelRenderAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; ret = RelAudioRenderProcedure(para); ASSERT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelRenderAdapterPara), ¶, sizeof(RelRenderAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetRenderPosition, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); @@ -839,10 +850,8 @@ HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderGetRende EXPECT_LT(INITIAL_VALUE, arrpara[i].character.getframes); EXPECT_LT(timeExp, arrpara[i].time.tvNSec); } - ret = para.render->control.Stop((AudioHandle)(para.render)); + ret = StopAudio(para); EXPECT_EQ(HDF_SUCCESS, ret); - para.adapter->DestroyRender(para.adapter, para.render); - para.manager->UnloadAdapter(para.manager, para.adapter); } /** @@ -856,15 +865,15 @@ HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderGetRende { int32_t ret = -1; int64_t timeExp = 0; - struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() } }; @@ -877,16 +886,11 @@ HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderGetRende } for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - void *result = nullptr; - pthread_join(tids[i], &result); - EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); + para[i].tids = tids[i]; + ret = ThreadRelease(para[i]); + EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_LT(INITIAL_VALUE, para[i].character.getframes); EXPECT_LT(timeExp, para[i].time.tvNSec); - - ret = para[i].render->control.Stop((AudioHandle)(para[i].render)); - EXPECT_EQ(HDF_SUCCESS, ret); - para[i].adapter->DestroyRender(para[i].adapter, para[i].render); - para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } } } \ No newline at end of file diff --git a/audio/test/systemtest/hdi/hdireliability/src/audio_hdirender_reliability_test.cpp b/audio/test/systemtest/hdi/hdireliability/src/audio_hdirender_reliability_test.cpp index 8528444270..370b7afad5 100755 --- a/audio/test/systemtest/hdi/hdireliability/src/audio_hdirender_reliability_test.cpp +++ b/audio/test/systemtest/hdi/hdireliability/src/audio_hdirender_reliability_test.cpp @@ -22,12 +22,12 @@ using namespace testing::ext; using namespace HMOS::Audio; namespace { -const string AUDIO_FILE = "//bin/audiorendertest.wav"; -const string ADAPTER_NAME = "hdmi"; -const string ADAPTER_NAME2 = "usb"; -const string ADAPTER_NAME3 = "internal"; +const string ADAPTER_NAME_HDMI = "hdmi"; +const string ADAPTER_NAME_USB = "usb"; +const string ADAPTER_NAME_INTERNAL = "internal"; const int PTHREAD_SAMEADA_COUNT = 10; const int PTHREAD_DIFFADA_COUNT = 3; +const int PTHREAD_DIFFADA_SIZE = 2; class AudioHdiRenderReliabilityTest : public testing::Test { public: @@ -35,99 +35,105 @@ public: static void TearDownTestCase(void); void SetUp(); void TearDown(); - struct AudioManager *(*GetAudioManager)() = nullptr; - void *handleSo = nullptr; - static int32_t RelGetAllAdapter(struct RelRenderAdapterPara& ptr); - static int32_t RelLoadAdapter(struct RelRenderAdapterPara& ptr); - static int32_t RelUnloadAdapter(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioCreateRender(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioDestroyRender(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioRenderStartAndFrame(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioRenderProcedure(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioRenderSetGain(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioRenderGetGain(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioRenderGetGainThreshold(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioRenderSetMute(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioRenderGetMute(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioRenderSetVolume(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioRenderGetVolume(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioRenderGetFrameSize(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioRenderGetFrameCount(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioRenderGetCurrentChannelId(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioRenderSetChannelMode(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioRenderGetChannelMode(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioRenderSetSampleAttributes(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioRenderGetSampleAttributes(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioRenderSelectScene(struct RelRenderAdapterPara& ptr); - static int32_t RelAudioRenderCheckSceneCapability(struct RelRenderAdapterPara& ptr); + static TestAudioManager *(*GetAudioManager)(); + static void *handleSo; +#ifdef AUDIO_MPI_SO + static int32_t (*SdkInit)(); + static void (*SdkExit)(); + static void *sdkSo; +#endif + static int32_t RelGetAllAdapter(struct PrepareAudioPara& ptr); + static int32_t RelLoadAdapter(struct PrepareAudioPara& ptr); + static int32_t RelUnloadAdapter(struct PrepareAudioPara& ptr); + static int32_t RelAudioCreateRender(struct PrepareAudioPara& ptr); + static int32_t RelAudioDestroyRender(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderStartAndFrame(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderProcedure(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderSetGain(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderGetGain(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderGetGainThreshold(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderSetMute(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderGetMute(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderSetVolume(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderGetVolume(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderGetFrameSize(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderGetFrameCount(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderGetCurrentChannelId(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderSetChannelMode(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderGetChannelMode(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderSetSampleAttributes(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderGetSampleAttributes(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderSelectScene(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderCheckSceneCapability(struct PrepareAudioPara& ptr); + static int32_t RelAudioRenderGetLatency(struct PrepareAudioPara& ptr); }; using THREAD_FUNC = void *(*)(void *); -void AudioHdiRenderReliabilityTest::SetUpTestCase(void) {} +TestAudioManager *(*AudioHdiRenderReliabilityTest::GetAudioManager)() = nullptr; +void *AudioHdiRenderReliabilityTest::handleSo = nullptr; +#ifdef AUDIO_MPI_SO + int32_t (*AudioHdiRenderReliabilityTest::SdkInit)() = nullptr; + void (*AudioHdiRenderReliabilityTest::SdkExit)() = nullptr; + void *AudioHdiRenderReliabilityTest::sdkSo = nullptr; +#endif -void AudioHdiRenderReliabilityTest::TearDownTestCase(void) {} - -void AudioHdiRenderReliabilityTest::SetUp(void) +void AudioHdiRenderReliabilityTest::SetUpTestCase(void) { - char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; - handleSo = dlopen(resolvedPath, RTLD_LAZY); +#ifdef AUDIO_MPI_SO + char sdkResolvedPath[] = "//system/lib/libhdi_audio_interface_lib_render.z.so"; + sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY); + if (sdkSo == nullptr) { + return; + } + SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit")); + if (SdkInit == nullptr) { + return; + } + SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit")); + if (SdkExit == nullptr) { + return; + } + SdkInit(); +#endif + handleSo = dlopen(RESOLVED_PATH.c_str(), RTLD_LAZY); if (handleSo == nullptr) { return; } - GetAudioManager = (struct AudioManager* (*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); + GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str())); if (GetAudioManager == nullptr) { return; } } -void AudioHdiRenderReliabilityTest::TearDown(void) +void AudioHdiRenderReliabilityTest::TearDownTestCase(void) { +#ifdef AUDIO_MPI_SO + SdkExit(); + if (sdkSo != nullptr) { + dlclose(sdkSo); + sdkSo = nullptr; + } + if (SdkInit != nullptr) { + SdkInit = nullptr; + } + if (SdkExit != nullptr) { + SdkExit = nullptr; + } +#endif if (GetAudioManager != nullptr) { GetAudioManager = nullptr; } } -struct RenderCharacteristic { - bool setmute; - bool getmute; - float setvolume; - float getvolume; - float setgain; - float getgain; - float gainthresholdmin; - float gainthresholdmax; - uint64_t getframesize; - uint64_t getframecount; - uint32_t getcurrentchannelId; - enum AudioChannelMode setmode; - enum AudioChannelMode getmode; - bool supported; -}; +void AudioHdiRenderReliabilityTest::SetUp(void) {} -struct RelRenderAdapterPara { - struct AudioManager *manager; - enum AudioPortDirection portType; - const char *adapterName; - struct AudioAdapter *adapter; - struct AudioPort renderPort; - void *param; - enum AudioPortPin pins; - const char *path; - struct AudioRender *render; - struct AudioHeadInfo headInfo; - struct AudioAdapterDescriptor *desc; - struct AudioAdapterDescriptor *descs; - struct RenderCharacteristic character; - struct AudioSampleAttributes attrs; - struct AudioSampleAttributes attrsValue; - struct AudioSceneDescriptor scenes; -}; +void AudioHdiRenderReliabilityTest::TearDown(void) {} -int32_t AudioHdiRenderReliabilityTest::RelGetAllAdapter(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderReliabilityTest::RelGetAllAdapter(struct PrepareAudioPara& ptr) { int size = 0; - auto *inst = (AudioHdiRenderReliabilityTest *)ptr.param; + auto *inst = (AudioHdiRenderReliabilityTest *)ptr.self; if (inst != nullptr && inst->GetAudioManager != nullptr) { ptr.manager = inst->GetAudioManager(); } @@ -138,7 +144,7 @@ int32_t AudioHdiRenderReliabilityTest::RelGetAllAdapter(struct RelRenderAdapterP if (ptr.descs == nullptr || size == 0) { return HDF_FAILURE; } else { - int index = SwitchAdapter(ptr.descs, ptr.adapterName, ptr.portType, ptr.renderPort, size); + int index = SwitchAdapter(ptr.descs, ptr.adapterName, ptr.portType, ptr.audioPort, size); if (index < 0) { return HDF_FAILURE; } else { @@ -151,7 +157,7 @@ int32_t AudioHdiRenderReliabilityTest::RelGetAllAdapter(struct RelRenderAdapterP return HDF_SUCCESS; } -int32_t AudioHdiRenderReliabilityTest::RelLoadAdapter(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderReliabilityTest::RelLoadAdapter(struct PrepareAudioPara& ptr) { ptr.manager->LoadAdapter(ptr.manager, ptr.desc, &ptr.adapter); @@ -161,7 +167,7 @@ int32_t AudioHdiRenderReliabilityTest::RelLoadAdapter(struct RelRenderAdapterPar return HDF_SUCCESS; } -int32_t AudioHdiRenderReliabilityTest::RelAudioCreateRender(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderReliabilityTest::RelAudioCreateRender(struct PrepareAudioPara& ptr) { int32_t ret = -1; struct AudioSampleAttributes attrs = {}; @@ -170,7 +176,7 @@ int32_t AudioHdiRenderReliabilityTest::RelAudioCreateRender(struct RelRenderAdap return HDF_FAILURE; } InitAttrs(attrs); - InitDevDesc(devDesc, (&ptr.renderPort)->portId, ptr.pins); + InitDevDesc(devDesc, (&ptr.audioPort)->portId, ptr.pins); ret = ptr.adapter->CreateRender(ptr.adapter, &devDesc, &attrs, &ptr.render); if (ret < 0 || ptr.render == nullptr) { ptr.manager->UnloadAdapter(ptr.manager, ptr.adapter); @@ -179,7 +185,7 @@ int32_t AudioHdiRenderReliabilityTest::RelAudioCreateRender(struct RelRenderAdap return HDF_SUCCESS; } -int32_t AudioHdiRenderReliabilityTest::RelAudioDestroyRender(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderReliabilityTest::RelAudioDestroyRender(struct PrepareAudioPara& ptr) { int32_t ret = -1; if (ptr.adapter == nullptr || ptr.render == nullptr) { @@ -192,7 +198,7 @@ int32_t AudioHdiRenderReliabilityTest::RelAudioDestroyRender(struct RelRenderAda return HDF_SUCCESS; } -int32_t AudioHdiRenderReliabilityTest::RelAudioRenderStartAndFrame(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderStartAndFrame(struct PrepareAudioPara& ptr) { int32_t ret = -1; struct AudioSampleAttributes attrs = {}; @@ -204,11 +210,10 @@ int32_t AudioHdiRenderReliabilityTest::RelAudioRenderStartAndFrame(struct RelRen if (file == nullptr) { return HDF_FAILURE; } - ret = InitAttrs(attrs); - if (ret < 0) { - return HDF_FAILURE; - } + InitAttrs(attrs); + if (HMOS::Audio::WavHeadAnalysis(ptr.headInfo, file, attrs) < 0) { + fclose(file); return HDF_FAILURE; } else { ret = HMOS::Audio::FrameStart(ptr.headInfo, ptr.render, file, attrs); @@ -223,10 +228,12 @@ int32_t AudioHdiRenderReliabilityTest::RelAudioRenderStartAndFrame(struct RelRen return HDF_SUCCESS; } -int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetGainThreshold(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetGainThreshold(struct PrepareAudioPara& ptr) { + if (ptr.render == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; - ret = ptr.render->volume.GetGainThreshold(ptr.render, &(ptr.character.gainthresholdmin), &(ptr.character.gainthresholdmax)); if (ret < 0) { @@ -235,8 +242,11 @@ int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetGainThreshold(struct Rel return HDF_SUCCESS; } -int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSetGain(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSetGain(struct PrepareAudioPara& ptr) { + if (ptr.render == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.render->volume.SetGain(ptr.render, ptr.character.setgain); if (ret < 0) { @@ -245,8 +255,11 @@ int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSetGain(struct RelRenderAda return HDF_SUCCESS; } -int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetGain(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetGain(struct PrepareAudioPara& ptr) { + if (ptr.render == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.render->volume.GetGain(ptr.render, &(ptr.character.getgain)); if (ret < 0) { @@ -255,7 +268,7 @@ int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetGain(struct RelRenderAda return HDF_SUCCESS; } -int32_t AudioHdiRenderReliabilityTest::RelAudioRenderProcedure(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderProcedure(struct PrepareAudioPara& ptr) { int32_t ret = -1; ret = RelGetAllAdapter(ptr); @@ -275,13 +288,18 @@ int32_t AudioHdiRenderReliabilityTest::RelAudioRenderProcedure(struct RelRenderA ret = RelAudioRenderStartAndFrame(ptr); if (ret < 0) { + ptr.adapter->DestroyRender(ptr.adapter, ptr.render); + ptr.manager->UnloadAdapter(ptr.manager, ptr.adapter); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSetMute(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSetMute(struct PrepareAudioPara& ptr) { + if (ptr.render == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.render->volume.SetMute(ptr.render, ptr.character.setmute); if (ret < 0) { @@ -290,8 +308,11 @@ int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSetMute(struct RelRenderAda return HDF_SUCCESS; } -int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetMute(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetMute(struct PrepareAudioPara& ptr) { + if (ptr.render == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.render->volume.GetMute(ptr.render, &(ptr.character.getmute)); if (ret < 0) { @@ -300,8 +321,11 @@ int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetMute(struct RelRenderAda return HDF_SUCCESS; } -int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSetVolume(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSetVolume(struct PrepareAudioPara& ptr) { + if (ptr.render == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.render->volume.SetVolume(ptr.render, ptr.character.setvolume); if (ret < 0) { @@ -310,8 +334,11 @@ int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSetVolume(struct RelRenderA return HDF_SUCCESS; } -int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetVolume(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetVolume(struct PrepareAudioPara& ptr) { + if (ptr.render == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.render->volume.GetVolume(ptr.render, &(ptr.character.getvolume)); if (ret < 0) { @@ -320,8 +347,11 @@ int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetVolume(struct RelRenderA return HDF_SUCCESS; } -int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetFrameSize(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetFrameSize(struct PrepareAudioPara& ptr) { + if (ptr.render == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.render->attr.GetFrameSize(ptr.render, &(ptr.character.getframesize)); if (ret < 0) { @@ -330,8 +360,11 @@ int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetFrameSize(struct RelRend return HDF_SUCCESS; } -int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetFrameCount(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetFrameCount(struct PrepareAudioPara& ptr) { + if (ptr.render == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.render->attr.GetFrameCount(ptr.render, &(ptr.character.getframecount)); if (ret < 0) { @@ -340,8 +373,11 @@ int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetFrameCount(struct RelRen return HDF_SUCCESS; } -int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetCurrentChannelId(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetCurrentChannelId(struct PrepareAudioPara& ptr) { + if (ptr.render == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.render->attr.GetCurrentChannelId(ptr.render, &(ptr.character.getcurrentchannelId)); if (ret < 0) { @@ -350,8 +386,11 @@ int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetCurrentChannelId(struct return HDF_SUCCESS; } -int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSetSampleAttributes(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSetSampleAttributes(struct PrepareAudioPara& ptr) { + if (ptr.render == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.render->attr.SetSampleAttributes(ptr.render, &(ptr.attrs)); if (ret < 0) { @@ -360,8 +399,11 @@ int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSetSampleAttributes(struct return HDF_SUCCESS; } -int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetSampleAttributes(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetSampleAttributes(struct PrepareAudioPara& ptr) { + if (ptr.render == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.render->attr.GetSampleAttributes(ptr.render, &(ptr.attrsValue)); if (ret < 0) { @@ -370,8 +412,11 @@ int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetSampleAttributes(struct return HDF_SUCCESS; } -int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSelectScene(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSelectScene(struct PrepareAudioPara& ptr) { + if (ptr.render == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.render->scene.SelectScene(ptr.render, &(ptr.scenes)); if (ret < 0) { @@ -380,8 +425,11 @@ int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSelectScene(struct RelRende return HDF_SUCCESS; } -int32_t AudioHdiRenderReliabilityTest::RelAudioRenderCheckSceneCapability(struct RelRenderAdapterPara& ptr) +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderCheckSceneCapability(struct PrepareAudioPara& ptr) { + if (ptr.render == nullptr) { + return HDF_FAILURE; + } int32_t ret = -1; ret = ptr.render->scene.CheckSceneCapability(ptr.render, &ptr.scenes, &(ptr.character.supported)); if (ret < 0) { @@ -390,6 +438,45 @@ int32_t AudioHdiRenderReliabilityTest::RelAudioRenderCheckSceneCapability(struct return HDF_SUCCESS; } +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSetChannelMode(struct PrepareAudioPara &ptr) +{ + if (ptr.render == nullptr) { + return HDF_FAILURE; + } + int32_t ret = -1; + ret = ptr.render->SetChannelMode(ptr.render, ptr.character.setmode); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetChannelMode(struct PrepareAudioPara &ptr) +{ + if (ptr.render == nullptr) { + return HDF_FAILURE; + } + int32_t ret = -1; + ret = ptr.render->GetChannelMode(ptr.render, &(ptr.character.getmode)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetLatency(struct PrepareAudioPara& ptr) +{ + if (ptr.render == nullptr) { + return HDF_FAILURE; + } + int32_t ret = -1; + ret = ptr.render->GetLatency(ptr.render, &(ptr.character.latencyTime)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + /** * @tc.name test AudioCreateRender API via Multithread call. * @tc.number SUB_Audio_HDI_AudioCreateRender_Reliability_0001 @@ -399,15 +486,15 @@ int32_t AudioHdiRenderReliabilityTest::RelAudioRenderCheckSceneCapability(struct HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioCreateRender_Reliability_0001, TestSize.Level1) { int32_t ret = -1; - struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() } }; @@ -439,15 +526,15 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioCreateRender_Reliabil HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioDestroyRender_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() } }; @@ -479,18 +566,22 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioDestroyRender_Reliabi HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetFrameSize_Reliability_0001, TestSize.Level1) { int32_t ret = -1; - struct RelRenderAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; - struct RelRenderAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; - ret = RelAudioRenderProcedure(para); + ASSERT_NE(nullptr, GetAudioManager); + para.manager = GetAudioManager(); + ASSERT_NE(nullptr, para.manager); + ret = AudioCreateRender(*para.manager, para.pins, para.adapterName, ¶.adapter, + ¶.render); ASSERT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelRenderAdapterPara), ¶, sizeof(RelRenderAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetFrameSize, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); @@ -502,8 +593,6 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetFrameSize_Re EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); EXPECT_LT(INITIAL_VALUE, arrpara[i].character.getframesize); } - ret = para.render->control.Stop((AudioHandle)(para.render)); - EXPECT_EQ(HDF_SUCCESS, ret); para.adapter->DestroyRender(para.adapter, para.render); para.manager->UnloadAdapter(para.manager, para.adapter); } @@ -517,34 +606,36 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetFrameSize_Re HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetFrameSize_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() } }; pthread_t tids[PTHREAD_DIFFADA_COUNT]; for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - ret = RelAudioRenderProcedure(para[i]); + ASSERT_NE(nullptr, GetAudioManager); + para[i].manager = GetAudioManager(); + ASSERT_NE(nullptr, para[i].manager); + ret = AudioCreateRender(*para[i].manager, para[i].pins, para[i].adapterName, ¶[i].adapter, + ¶[i].render); ASSERT_EQ(HDF_SUCCESS, ret); int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetFrameSize, ¶[i]); EXPECT_EQ(HDF_SUCCESS, ret); } for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - void *result = nullptr; - pthread_join(tids[i], &result); - EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); - EXPECT_LT(INITIAL_VALUE, para[i].character.getframesize); - - ret = para[i].render->control.Stop((AudioHandle)(para[i].render)); + para[i].tids = tids[i]; + pthread_join(para[i].tids, ¶[i].result); + ret = (intptr_t)para[i].result; EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_LT(INITIAL_VALUE, para[i].character.getframesize); para[i].adapter->DestroyRender(para[i].adapter, para[i].render); para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } @@ -559,18 +650,18 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetFrameSize_Re HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetFrameCount_Reliability_0001, TestSize.Level1) { int32_t ret = -1; - struct RelRenderAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; - struct RelRenderAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; ret = RelAudioRenderProcedure(para); ASSERT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelRenderAdapterPara), ¶, sizeof(RelRenderAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetFrameCount, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); @@ -582,10 +673,8 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetFrameCount_R EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); EXPECT_LT(INITIAL_VALUE, arrpara[i].character.getframecount); } - ret = para.render->control.Stop((AudioHandle)(para.render)); + ret = StopAudio(para); EXPECT_EQ(HDF_SUCCESS, ret); - para.adapter->DestroyRender(para.adapter, para.render); - para.manager->UnloadAdapter(para.manager, para.adapter); } /** @@ -597,15 +686,15 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetFrameCount_R HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetFrameCount_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() } }; @@ -618,15 +707,10 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetFrameCount_R } for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - void *result = nullptr; - pthread_join(tids[i], &result); - EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); - EXPECT_LT(INITIAL_VALUE, para[i].character.getframecount); - - ret = para[i].render->control.Stop((AudioHandle)(para[i].render)); + para[i].tids = tids[i]; + ret = ThreadRelease(para[i]); EXPECT_EQ(HDF_SUCCESS, ret); - para[i].adapter->DestroyRender(para[i].adapter, para[i].render); - para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); + EXPECT_LT(INITIAL_VALUE, para[i].character.getframecount); } } @@ -640,18 +724,21 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetCurrentChann { int32_t ret = -1; uint32_t channelIdValue = 2; - struct RelRenderAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; - struct RelRenderAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; - ret = RelAudioRenderProcedure(para); + ASSERT_NE(nullptr, GetAudioManager); + para.manager = GetAudioManager(); + ASSERT_NE(nullptr, para.manager); + ret = AudioCreateRender(*para.manager, para.pins, para.adapterName, ¶.adapter, ¶.render); ASSERT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelRenderAdapterPara), ¶, sizeof(RelRenderAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); arrpara[i].character.getcurrentchannelId = 0; int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetCurrentChannelId, &arrpara[i]); @@ -664,8 +751,6 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetCurrentChann EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); EXPECT_EQ(channelIdValue, arrpara[i].character.getcurrentchannelId); } - ret = para.render->control.Stop((AudioHandle)(para.render)); - EXPECT_EQ(HDF_SUCCESS, ret); para.adapter->DestroyRender(para.adapter, para.render); para.manager->UnloadAdapter(para.manager, para.adapter); } @@ -680,34 +765,36 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetCurrentChann { int32_t ret = -1; uint32_t channelIdValue = 2; - struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() } }; pthread_t tids[PTHREAD_DIFFADA_COUNT]; for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - ret = RelAudioRenderProcedure(para[i]); + ASSERT_NE(nullptr, GetAudioManager); + para[i].manager = GetAudioManager(); + ASSERT_NE(nullptr, para[i].manager); + ret = AudioCreateRender(*para[i].manager, para[i].pins, para[i].adapterName, ¶[i].adapter, + ¶[i].render); ASSERT_EQ(HDF_SUCCESS, ret); int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetCurrentChannelId, ¶[i]); EXPECT_EQ(HDF_SUCCESS, ret); } for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - void *result = nullptr; - pthread_join(tids[i], &result); - EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); - EXPECT_EQ(channelIdValue, para[i].character.getcurrentchannelId); - - ret = para[i].render->control.Stop((AudioHandle)(para[i].render)); + para[i].tids = tids[i]; + pthread_join(para[i].tids, ¶[i].result); + ret = (intptr_t)para[i].result; EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(channelIdValue, para[i].character.getcurrentchannelId); para[i].adapter->DestroyRender(para[i].adapter, para[i].render); para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } @@ -722,18 +809,18 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetCurrentChann HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudiorenderSetMute_Reliability_0001, TestSize.Level1) { int32_t ret = -1; - struct RelRenderAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; - struct RelRenderAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; ret = RelAudioRenderProcedure(para); ASSERT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelRenderAdapterPara), ¶, sizeof(RelRenderAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); ret = arrpara[i].render->volume.GetMute(arrpara[i].render, &(arrpara[i].character.getmute)); EXPECT_EQ(HDF_SUCCESS, ret); @@ -744,7 +831,7 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudiorenderSetMute_Reliabi } ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSetMute, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); ret = arrpara[i].render->volume.GetMute(arrpara[i].render, &(arrpara[i].character.getmute)); EXPECT_EQ(HDF_SUCCESS, ret); if (arrpara[i].character.setmute == true) { @@ -759,10 +846,8 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudiorenderSetMute_Reliabi pthread_join(tids[i], &result); EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); } - ret = para.render->control.Stop((AudioHandle)(para.render)); + ret = StopAudio(para); EXPECT_EQ(HDF_SUCCESS, ret); - para.adapter->DestroyRender(para.adapter, para.render); - para.manager->UnloadAdapter(para.manager, para.adapter); } /** @@ -774,15 +859,15 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudiorenderSetMute_Reliabi HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudiorenderSetMute_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() } }; @@ -799,7 +884,7 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudiorenderSetMute_Reliabi } ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSetMute, ¶[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); ret = para[i].render->volume.GetMute(para[i].render, &(para[i].character.getmute)); EXPECT_EQ(HDF_SUCCESS, ret); if (para[i].character.setmute == true) { @@ -809,13 +894,9 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudiorenderSetMute_Reliabi } } for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - void *result = nullptr; - pthread_join(tids[i], &result); - EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); - ret = para[i].render->control.Stop((AudioHandle)(para[i].render)); + para[i].tids = tids[i]; + ret = ThreadRelease(para[i]); EXPECT_EQ(HDF_SUCCESS, ret); - para[i].adapter->DestroyRender(para[i].adapter, para[i].render); - para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } } @@ -828,25 +909,29 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudiorenderSetMute_Reliabi HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudiorenderGetMute_Reliability_0001, TestSize.Level1) { int32_t ret = -1; - struct RelRenderAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; - struct RelRenderAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; - ret = RelAudioRenderProcedure(para); + ASSERT_NE(nullptr, GetAudioManager); + para.manager = GetAudioManager(); + ASSERT_NE(nullptr, para.manager); + ret = AudioCreateRender(*para.manager, para.pins, para.adapterName, ¶.adapter, + ¶.render); ASSERT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelRenderAdapterPara), ¶, sizeof(RelRenderAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); arrpara[i].character.setmute = true; ret = arrpara[i].render->volume.SetMute(arrpara[i].render, false); EXPECT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetMute, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); } for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { @@ -855,8 +940,6 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudiorenderGetMute_Reliabi EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); EXPECT_FALSE(arrpara[i].character.getmute); } - ret = para.render->control.Stop((AudioHandle)(para.render)); - EXPECT_EQ(HDF_SUCCESS, ret); para.adapter->DestroyRender(para.adapter, para.render); para.manager->UnloadAdapter(para.manager, para.adapter); } @@ -870,38 +953,41 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudiorenderGetMute_Reliabi HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudiorenderGetMute_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() } }; pthread_t tids[PTHREAD_DIFFADA_COUNT]; for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - ret = RelAudioRenderProcedure(para[i]); + ASSERT_NE(nullptr, GetAudioManager); + para[i].manager = GetAudioManager(); + ASSERT_NE(nullptr, para[i].manager); + ret = AudioCreateRender(*para[i].manager, para[i].pins, para[i].adapterName, ¶[i].adapter, + ¶[i].render); ASSERT_EQ(HDF_SUCCESS, ret); para[i].character.setmute = true; ret = para[i].render->volume.SetMute(para[i].render, false); EXPECT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetMute, ¶[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); } for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - void *result = nullptr; - pthread_join(tids[i], &result); - EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); - EXPECT_FALSE(para[i].character.getmute); - ret = para[i].render->control.Stop((AudioHandle)(para[i].render)); + para[i].tids = tids[i]; + pthread_join(para[i].tids, ¶[i].result); + ret = (intptr_t)para[i].result; EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_FALSE(para[i].character.getmute); para[i].adapter->DestroyRender(para[i].adapter, para[i].render); para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } @@ -909,31 +995,31 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudiorenderGetMute_Reliabi /** * @tc.name test AudioRenderSetVolume API via Multithread call. * @tc.number SUB_Audio_HDI_AudiorenderSetVolume_Reliability_0001 -* @tc.desc test AudioRenderSetVolume interface Reliability pass through pthread_create fun and adapterName is same. +* @tc.desc test SetVolume interface Reliability pass through pthread_create fun and adapterName is same. * @tc.author: zhouyongxiao */ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudiorenderSetVolume_Reliability_0001, TestSize.Level1) { int32_t ret = -1; float volumeHighExpc = 0.70; - struct RelRenderAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; - struct RelRenderAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; ret = RelAudioRenderProcedure(para); ASSERT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelRenderAdapterPara), ¶, sizeof(RelRenderAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); ret = arrpara[i].render->volume.GetVolume(arrpara[i].render, &(arrpara[i].character.getvolume)); EXPECT_EQ(HDF_SUCCESS, ret); arrpara[i].character.setvolume = 0.70; ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSetVolume, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); } for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { @@ -944,31 +1030,29 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudiorenderSetVolume_Relia EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(volumeHighExpc, arrpara[i].character.getvolume); } - ret = para.render->control.Stop((AudioHandle)(para.render)); + ret = StopAudio(para); EXPECT_EQ(HDF_SUCCESS, ret); - para.adapter->DestroyRender(para.adapter, para.render); - para.manager->UnloadAdapter(para.manager, para.adapter); } /** * @tc.name test AudioRenderSetVolume API via Multithread call. * @tc.number SUB_Audio_HDI_AudiorenderSetVolume_Reliability_0002 -* @tc.desc test RenderSetVolume interface Reliability pass through pthread_create fun and adapterName is different +* @tc.desc test SetVolume interface Reliability pass through pthread_create fun and adapterName is different * @tc.author: zhouyongxiao */ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudiorenderSetVolume_Reliability_0002, TestSize.Level1) { int32_t ret = -1; float volumeHighExpc = 0.6; - struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() } }; @@ -979,7 +1063,7 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudiorenderSetVolume_Relia para[i].character.setvolume = 0.6; ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSetVolume, ¶[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); } for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { void *result = nullptr; @@ -988,42 +1072,44 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudiorenderSetVolume_Relia ret = para[i].render->volume.GetVolume(para[i].render, &(para[i].character.getvolume)); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(volumeHighExpc, para[i].character.getvolume); - ret = para[i].render->control.Stop((AudioHandle)(para[i].render)); + ret = StopAudio(para[i]); EXPECT_EQ(HDF_SUCCESS, ret); - para[i].adapter->DestroyRender(para[i].adapter, para[i].render); - para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } } /** * @tc.name test AudioRenderGetVolume API via Multithread call. * @tc.number SUB_Audio_HDI_AudiorenderGetVolume_Reliability_0001 -* @tc.desc test AudioRenderGetMute interface Reliability pass through pthread_create fun and adapterName is same. +* @tc.desc test GetVolume interface Reliability pass through pthread_create fun and adapterName is same. * @tc.author: zhouyongxiao */ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudiorenderGetVolume_Reliability_0001, TestSize.Level1) { int32_t ret = -1; float volumeHighExpc = 0.7; - struct RelRenderAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; - struct RelRenderAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; - ret = RelAudioRenderProcedure(para); + ASSERT_NE(nullptr, GetAudioManager); + para.manager = GetAudioManager(); + ASSERT_NE(nullptr, para.manager); + ret = AudioCreateRender(*para.manager, para.pins, para.adapterName, ¶.adapter, + ¶.render); ASSERT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelRenderAdapterPara), ¶, sizeof(RelRenderAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); arrpara[i].character.setvolume = 0.7; ret = arrpara[i].render->volume.SetVolume(arrpara[i].render, arrpara[i].character.setvolume); EXPECT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetVolume, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); } for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { @@ -1032,8 +1118,6 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudiorenderGetVolume_Relia EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); EXPECT_EQ(volumeHighExpc, arrpara[i].character.getvolume); } - ret = para.render->control.Stop((AudioHandle)(para.render)); - EXPECT_EQ(HDF_SUCCESS, ret); para.adapter->DestroyRender(para.adapter, para.render); para.manager->UnloadAdapter(para.manager, para.adapter); } @@ -1041,44 +1125,47 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudiorenderGetVolume_Relia /** * @tc.name test AudioRenderGetVolume API via Multithread call. * @tc.number SUB_Audio_HDI_AudiorenderGetVolume_Reliability_0002 -* @tc.desc test AudioRenderGetMute interface Reliability pass through pthread_create fun and adapterName is different. +* @tc.desc test GetVolume interface Reliability pass through pthread_create fun and adapterName is different. * @tc.author: zhouyongxiao */ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudiorenderGetVolume_Reliability_0002, TestSize.Level1) { int32_t ret = -1; float volumeHighExpc = 0.6; - struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() } }; pthread_t tids[PTHREAD_DIFFADA_COUNT]; for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - ret = RelAudioRenderProcedure(para[i]); + ASSERT_NE(nullptr, GetAudioManager); + para[i].manager = GetAudioManager(); + ASSERT_NE(nullptr, para[i].manager); + ret = AudioCreateRender(*para[i].manager, para[i].pins, para[i].adapterName, ¶[i].adapter, + ¶[i].render); ASSERT_EQ(HDF_SUCCESS, ret); para[i].character.setvolume = 0.6; ret = para[i].render->volume.SetVolume(para[i].render, para[i].character.setvolume); EXPECT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetVolume, ¶[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); } for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - void *result = nullptr; - pthread_join(tids[i], &result); - EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); - EXPECT_EQ(volumeHighExpc, para[i].character.getvolume); - ret = para[i].render->control.Stop((AudioHandle)(para[i].render)); + para[i].tids = tids[i]; + pthread_join(para[i].tids, ¶[i].result); + ret = (intptr_t)para[i].result; EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(volumeHighExpc, para[i].character.getvolume); para[i].adapter->DestroyRender(para[i].adapter, para[i].render); para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } @@ -1096,22 +1183,26 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderSetSampleAttrib int32_t ret = -1; uint32_t count = 2; uint32_t rateExpc = 48000; - struct RelRenderAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; - struct RelRenderAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; - ret = RelAudioRenderProcedure(para); + ASSERT_NE(nullptr, GetAudioManager); + para.manager = GetAudioManager(); + ASSERT_NE(nullptr, para.manager); + ret = AudioCreateRender(*para.manager, para.pins, para.adapterName, ¶.adapter, + ¶.render); ASSERT_EQ(HDF_SUCCESS, ret); InitAttrs(para.attrs); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelRenderAdapterPara), ¶, sizeof(RelRenderAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSetSampleAttributes, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); ret = arrpara[i].render->attr.GetSampleAttributes(arrpara[i].render, &(arrpara[i].attrsValue)); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(AUDIO_IN_MEDIA, arrpara[i].attrsValue.type); @@ -1125,8 +1216,6 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderSetSampleAttrib pthread_join(tids[i], &result); EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); } - ret = para.render->control.Stop((AudioHandle)(para.render)); - EXPECT_EQ(HDF_SUCCESS, ret); para.adapter->DestroyRender(para.adapter, para.render); para.manager->UnloadAdapter(para.manager, para.adapter); } @@ -1143,27 +1232,31 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderSetSampleAttrib int32_t ret = -1; uint32_t count = 2; uint32_t rateExpc = 48000; - struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() } }; pthread_t tids[PTHREAD_DIFFADA_COUNT]; for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - ret = RelAudioRenderProcedure(para[i]); + ASSERT_NE(nullptr, GetAudioManager); + para[i].manager = GetAudioManager(); + ASSERT_NE(nullptr, para[i].manager); + ret = AudioCreateRender(*para[i].manager, para[i].pins, para[i].adapterName, ¶[i].adapter, + ¶[i].render); ASSERT_EQ(HDF_SUCCESS, ret); InitAttrs(para[i].attrs); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSetSampleAttributes, ¶[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); ret = para[i].render->attr.GetSampleAttributes(para[i].render, &(para[i].attrsValue)); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(AUDIO_IN_MEDIA, para[i].attrsValue.type); @@ -1173,10 +1266,9 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderSetSampleAttrib } for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - void *result = nullptr; - pthread_join(tids[i], &result); - EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); - ret = para[i].render->control.Stop((AudioHandle)(para[i].render)); + para[i].tids = tids[i]; + pthread_join(para[i].tids, ¶[i].result); + ret = (intptr_t)para[i].result; EXPECT_EQ(HDF_SUCCESS, ret); para[i].adapter->DestroyRender(para[i].adapter, para[i].render); para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); @@ -1195,24 +1287,28 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetSampleAttrib int32_t ret = -1; uint32_t count = 2; uint32_t rateExpc = 48000; - struct RelRenderAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; - struct RelRenderAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; - ret = RelAudioRenderProcedure(para); + ASSERT_NE(nullptr, GetAudioManager); + para.manager = GetAudioManager(); + ASSERT_NE(nullptr, para.manager); + ret = AudioCreateRender(*para.manager, para.pins, para.adapterName, ¶.adapter, + ¶.render); ASSERT_EQ(HDF_SUCCESS, ret); InitAttrs(para.attrs); ret = para.render->attr.SetSampleAttributes(para.render, &(para.attrs)); EXPECT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelRenderAdapterPara), ¶, sizeof(RelRenderAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetSampleAttributes, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); } for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { @@ -1224,8 +1320,6 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetSampleAttrib EXPECT_EQ(rateExpc, arrpara[i].attrsValue.sampleRate); EXPECT_EQ(count, arrpara[i].attrsValue.channelCount); } - ret = para.render->control.Stop((AudioHandle)(para.render)); - EXPECT_EQ(HDF_SUCCESS, ret); para.adapter->DestroyRender(para.adapter, para.render); para.manager->UnloadAdapter(para.manager, para.adapter); } @@ -1242,41 +1336,44 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetSampleAttrib int32_t ret = -1; uint32_t count = 2; uint32_t rateExpc = 48000; - struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() } }; pthread_t tids[PTHREAD_DIFFADA_COUNT]; for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - ret = RelAudioRenderProcedure(para[i]); + ASSERT_NE(nullptr, GetAudioManager); + para[i].manager = GetAudioManager(); + ASSERT_NE(nullptr, para[i].manager); + ret = AudioCreateRender(*para[i].manager, para[i].pins, para[i].adapterName, ¶[i].adapter, + ¶[i].render); ASSERT_EQ(HDF_SUCCESS, ret); InitAttrs(para[i].attrs); ret = para[i].render->attr.SetSampleAttributes(para[i].render, &(para[i].attrs)); EXPECT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetSampleAttributes, ¶[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); } for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - void *result = nullptr; - pthread_join(tids[i], &result); - EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); + para[i].tids = tids[i]; + pthread_join(para[i].tids, ¶[i].result); + ret = (intptr_t)para[i].result; + EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(AUDIO_IN_MEDIA, para[i].attrsValue.type); EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, para[i].attrsValue.format); EXPECT_EQ(rateExpc, para[i].attrsValue.sampleRate); EXPECT_EQ(count, para[i].attrsValue.channelCount); - ret = para[i].render->control.Stop((AudioHandle)(para[i].render)); - EXPECT_EQ(HDF_SUCCESS, ret); para[i].adapter->DestroyRender(para[i].adapter, para[i].render); para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } @@ -1291,24 +1388,28 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetSampleAttrib HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderSelectScene_Reliability_0001, TestSize.Level1) { int32_t ret = -1; - struct RelRenderAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; - struct RelRenderAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; - ret = RelAudioRenderProcedure(para); + ASSERT_NE(nullptr, GetAudioManager); + para.manager = GetAudioManager(); + ASSERT_NE(nullptr, para.manager); + ret = AudioCreateRender(*para.manager, para.pins, para.adapterName, ¶.adapter, + ¶.render); ASSERT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelRenderAdapterPara), ¶, sizeof(RelRenderAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); arrpara[i].scenes.scene.id = 0; arrpara[i].scenes.desc.pins = PIN_OUT_SPEAKER; ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSelectScene, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); } for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { @@ -1316,8 +1417,6 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderSelectScene_Rel pthread_join(tids[i], &result); EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); } - ret = para.render->control.Stop((AudioHandle)(para.render)); - EXPECT_EQ(HDF_SUCCESS, ret); para.adapter->DestroyRender(para.adapter, para.render); para.manager->UnloadAdapter(para.manager, para.adapter); } @@ -1332,32 +1431,35 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderSelectScene_Rel HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderSelectScene_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() } }; pthread_t tids[PTHREAD_DIFFADA_COUNT]; for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT - 1; ++i) { - ret = RelAudioRenderProcedure(para[i]); + ASSERT_NE(nullptr, GetAudioManager); + para[i].manager = GetAudioManager(); + ASSERT_NE(nullptr, para[i].manager); + ret = AudioCreateRender(*para[i].manager, para[i].pins, para[i].adapterName, ¶[i].adapter, + ¶[i].render); ASSERT_EQ(HDF_SUCCESS, ret); para[i].scenes.scene.id = 0; para[i].scenes.desc.pins = PIN_OUT_SPEAKER; ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSelectScene, ¶[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); } for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT - 1; ++i) { - void *result = nullptr; - pthread_join(tids[i], &result); - EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); - ret = para[i].render->control.Stop((AudioHandle)(para[i].render)); + para[i].tids = tids[i]; + pthread_join(para[i].tids, ¶[i].result); + ret = (intptr_t)para[i].result; EXPECT_EQ(HDF_SUCCESS, ret); para[i].adapter->DestroyRender(para[i].adapter, para[i].render); para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); @@ -1374,24 +1476,28 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderSelectScene_Rel HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderCheckSceneCapability_Reliability_0001, TestSize.Level1) { int32_t ret = -1; - struct RelRenderAdapterPara para = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; - struct RelRenderAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; - ret = RelAudioRenderProcedure(para); + ASSERT_NE(nullptr, GetAudioManager); + para.manager = GetAudioManager(); + ASSERT_NE(nullptr, para.manager); + ret = AudioCreateRender(*para.manager, para.pins, para.adapterName, ¶.adapter, + ¶.render); ASSERT_EQ(HDF_SUCCESS, ret); pthread_t tids[PTHREAD_SAMEADA_COUNT]; for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { - ret = memcpy_s(&arrpara[i], sizeof(RelRenderAdapterPara), ¶, sizeof(RelRenderAdapterPara)); + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); EXPECT_EQ(HDF_SUCCESS, ret); arrpara[i].scenes.scene.id = 0; arrpara[i].scenes.desc.pins = PIN_OUT_SPEAKER; ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderCheckSceneCapability, &arrpara[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); } for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { @@ -1399,8 +1505,6 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderCheckSceneCapab pthread_join(tids[i], &result); EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); } - ret = para.render->control.Stop((AudioHandle)(para.render)); - EXPECT_EQ(HDF_SUCCESS, ret); para.adapter->DestroyRender(para.adapter, para.render); para.manager->UnloadAdapter(para.manager, para.adapter); } @@ -1415,36 +1519,535 @@ HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderCheckSceneCapab HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderCheckSceneCapability_Reliability_0002, TestSize.Level1) { int32_t ret = -1; - struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }, { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() } }; pthread_t tids[PTHREAD_DIFFADA_COUNT]; for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { - ret = RelAudioRenderProcedure(para[i]); + ASSERT_NE(nullptr, GetAudioManager); + para[i].manager = GetAudioManager(); + ASSERT_NE(nullptr, para[i].manager); + ret = AudioCreateRender(*para[i].manager, para[i].pins, para[i].adapterName, ¶[i].adapter, + ¶[i].render); ASSERT_EQ(HDF_SUCCESS, ret); para[i].scenes.scene.id = 0; para[i].scenes.desc.pins = PIN_OUT_SPEAKER; ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderCheckSceneCapability, ¶[i]); EXPECT_EQ(HDF_SUCCESS, ret); - usleep(50000); + usleep(10000); } for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { + para[i].tids = tids[i]; + pthread_join(para[i].tids, ¶[i].result); + ret = (intptr_t)para[i].result; + EXPECT_EQ(HDF_SUCCESS, ret); + para[i].adapter->DestroyRender(para[i].adapter, para[i].render); + para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); + } +} +/** +* @tc.name test AudioRenderSetGain API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioRenderSetGain_Reliability_0001 +* @tc.desc test AudioRenderSetGain interface Reliability pass through pthread_create fun and adapterName is same. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderSetGain_Reliability_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; + + ASSERT_NE(nullptr, GetAudioManager); + para.manager = GetAudioManager(); + ASSERT_NE(nullptr, para.manager); + ret = AudioCreateRender(*para.manager, para.pins, para.adapterName, ¶.adapter, + ¶.render); + ASSERT_EQ(HDF_SUCCESS, ret); + + pthread_t tids[PTHREAD_SAMEADA_COUNT]; + for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); + EXPECT_EQ(HDF_SUCCESS, ret); + arrpara[i].character.setgain = 15; + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSetGain, &arrpara[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + } + for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { void *result = nullptr; pthread_join(tids[i], &result); EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); - ret = para[i].render->control.Stop((AudioHandle)(para[i].render)); + EXPECT_LT(GAIN_MIN, arrpara[i].character.setgain); + } + para.adapter->DestroyRender(para.adapter, para.render); + para.manager->UnloadAdapter(para.manager, para.adapter); +} +/** +* @tc.name test AudioRenderSetGain API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioRenderSetGain_Reliability_0002 +* @tc.desc test SetGain interface Reliability pass through pthread_create fun and adapterName is different. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderSetGain_Reliability_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara para[PTHREAD_DIFFADA_SIZE] = { + { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + } + }; + pthread_t tids[PTHREAD_DIFFADA_SIZE]; + for (int32_t i = 0; i < PTHREAD_DIFFADA_SIZE; ++i) { + ASSERT_NE(nullptr, GetAudioManager); + para[i].manager = GetAudioManager(); + ASSERT_NE(nullptr, para[i].manager); + ret = AudioCreateRender(*para[i].manager, para[i].pins, para[i].adapterName, ¶[i].adapter, + ¶[i].render); + ASSERT_EQ(HDF_SUCCESS, ret); + para[i].character.setgain = 15; + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSetGain, ¶[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + } + for (int32_t i = 0; i < PTHREAD_DIFFADA_SIZE; ++i) { + void *result = nullptr; + int32_t ret = -1; + pthread_join(tids[i], &result); + ret = (intptr_t)result; + EXPECT_EQ(HDF_SUCCESS, ret); + ret = para[i].render->volume.GetGain(para[i].render, &(para[i].character.getgain)); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_LT(GAIN_MIN, para[i].character.getgain); + para[i].adapter->DestroyRender(para[i].adapter, para[i].render); + para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); + } +} +/** +* @tc.name test AudioRenderGetGain API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioRenderGetGain_Reliability_0001 +* @tc.desc test GetGain interface Reliability pass through pthread_create fun and adapterName is same. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetGain_Reliability_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; + + ASSERT_NE(nullptr, GetAudioManager); + para.manager = GetAudioManager(); + ASSERT_NE(nullptr, para.manager); + ret = AudioCreateRender(*para.manager, para.pins, para.adapterName, ¶.adapter, + ¶.render); + ASSERT_EQ(HDF_SUCCESS, ret); + + pthread_t tids[PTHREAD_SAMEADA_COUNT]; + for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); + EXPECT_EQ(HDF_SUCCESS, ret); + arrpara[i].character.setgain = 15; + ret = arrpara[i].render->volume.SetGain(arrpara[i].render, arrpara[i].character.setgain); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetGain, &arrpara[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + } + for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { + void *result = nullptr; + pthread_join(tids[i], &result); + EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); + EXPECT_LT(GAIN_MIN, arrpara[i].character.setgain); + } + para.adapter->DestroyRender(para.adapter, para.render); + para.manager->UnloadAdapter(para.manager, para.adapter); +} +/** +* @tc.name test AudioRenderGetGain API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioRenderGetGain_Reliability_0002 +* @tc.desc test GetGain interface Reliability pass through pthread_create fun and adapterName is different. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetGain_Reliability_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara para[PTHREAD_DIFFADA_SIZE] = { + { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + } + }; + pthread_t tids[PTHREAD_DIFFADA_SIZE]; + for (int32_t i = 0; i < PTHREAD_DIFFADA_SIZE; ++i) { + ASSERT_NE(nullptr, GetAudioManager); + para[i].manager = GetAudioManager(); + ASSERT_NE(nullptr, para[i].manager); + ret = AudioCreateRender(*para[i].manager, para[i].pins, para[i].adapterName, ¶[i].adapter, + ¶[i].render); + ASSERT_EQ(HDF_SUCCESS, ret); + para[i].character.setgain = 15; + ret = para[i].render->volume.SetGain(para[i].render, para[i].character.setgain); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetGain, ¶[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + } + for (int32_t i = 0; i < PTHREAD_DIFFADA_SIZE; ++i) { + para[i].tids = tids[i]; + pthread_join(para[i].tids, ¶[i].result); + ret = (intptr_t)para[i].result; + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_LT(GAIN_MIN, para[i].character.getgain); + para[i].adapter->DestroyRender(para[i].adapter, para[i].render); + para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); + } +} +/** +* @tc.name test AudioRenderGetGainThreshold API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioRenderGetGainThreshold_Reliability_0001 +* @tc.desc test GetGainThreshold interface Reliability pass through pthread_create fun and adapterName is same. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetGainThreshold_Reliability_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; + + ASSERT_NE(nullptr, GetAudioManager); + para.manager = GetAudioManager(); + ASSERT_NE(nullptr, para.manager); + ret = AudioCreateRender(*para.manager, para.pins, para.adapterName, ¶.adapter, + ¶.render); + ASSERT_EQ(HDF_SUCCESS, ret); + + pthread_t tids[PTHREAD_SAMEADA_COUNT]; + for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetGainThreshold, &arrpara[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + } + for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { + void *result = nullptr; + pthread_join(tids[i], &result); + EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); + EXPECT_EQ(0, arrpara[i].character.gainthresholdmin); + EXPECT_EQ(15, arrpara[i].character.gainthresholdmax); + } + para.adapter->DestroyRender(para.adapter, para.render); + para.manager->UnloadAdapter(para.manager, para.adapter); +} +/** +* @tc.name test AudioRenderGetGainThreshold API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioRenderGetGainThreshold_Reliability_0002 +* @tc.desc test GetGainThreshold interface Reliability pass through pthread_create fun and adapterName is different. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetGainThreshold_Reliability_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara para[PTHREAD_DIFFADA_SIZE] = { + { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + } + }; + + pthread_t tids[PTHREAD_DIFFADA_SIZE]; + for (int32_t i = 0; i < PTHREAD_DIFFADA_SIZE; ++i) { + ASSERT_NE(nullptr, GetAudioManager); + para[i].manager = GetAudioManager(); + ASSERT_NE(nullptr, para[i].manager); + ret = AudioCreateRender(*para[i].manager, para[i].pins, para[i].adapterName, ¶[i].adapter, + ¶[i].render); + ASSERT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetGainThreshold, ¶[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + } + for (int32_t i = 0; i < PTHREAD_DIFFADA_SIZE; ++i) { + para[i].tids = tids[i]; + pthread_join(para[i].tids, ¶[i].result); + ret = (intptr_t)para[i].result; + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(0, para[i].character.gainthresholdmin); + EXPECT_EQ(15, para[i].character.gainthresholdmax); + para[i].adapter->DestroyRender(para[i].adapter, para[i].render); + para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); + } +} +/** +* @tc.name test AudioRenderSetChannelMode API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioRenderSetChannelMode_Reliability_0001 +* @tc.desc test SetChannelMode interface Reliability pass through pthread_create fun and adapterName is same. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderSetChannelMode_Reliability_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; + ASSERT_NE(nullptr, GetAudioManager); + para.manager = GetAudioManager(); + ASSERT_NE(nullptr, para.manager); + ret = AudioCreateRender(*para.manager, para.pins, para.adapterName, ¶.adapter, + ¶.render); + ASSERT_EQ(HDF_SUCCESS, ret); + + pthread_t tids[PTHREAD_SAMEADA_COUNT]; + for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); + EXPECT_EQ(HDF_SUCCESS, ret); + arrpara[i].character.setmode = AUDIO_CHANNEL_NORMAL; + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSetChannelMode, &arrpara[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + } + for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { + void *result = nullptr; + pthread_join(tids[i], &result); + EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); + EXPECT_EQ(AUDIO_CHANNEL_NORMAL, arrpara[i].character.getmode); + } + para.adapter->DestroyRender(para.adapter, para.render); + para.manager->UnloadAdapter(para.manager, para.adapter); +} +/** +* @tc.name test AudioRenderSetChannelMode API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioRenderSetChannelMode_Reliability_0002 +* @tc.desc test SetChannelMode interface Reliability pass through pthread_create fun and adapterName is different. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderSetChannelMode_Reliability_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { + { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + } + }; + pthread_t tids[PTHREAD_DIFFADA_COUNT]; + for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { + ASSERT_NE(nullptr, GetAudioManager); + para[i].manager = GetAudioManager(); + ASSERT_NE(nullptr, para[i].manager); + ret = AudioCreateRender(*para[i].manager, para[i].pins, para[i].adapterName, ¶[i].adapter, + ¶[i].render); + ASSERT_EQ(HDF_SUCCESS, ret); + para[i].character.setmode = AUDIO_CHANNEL_NORMAL; + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSetChannelMode, ¶[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + } + for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { + void *result = nullptr; + int32_t ret = -1; + pthread_join(tids[i], &result); + EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); + ret = para[i].render->GetChannelMode(para[i].render, &(para[i].character.getmode)); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_CHANNEL_NORMAL, para[i].character.getmode); + para[i].adapter->DestroyRender(para[i].adapter, para[i].render); + para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); + } +} +/** +* @tc.name test AudioRenderGetChannelMode API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioRenderGetChannelMode_Reliability_0001 +* @tc.desc test GetChannelMode interface Reliability pass through pthread_create fun and adapterName is same. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetChannelMode_Reliability_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; + + ASSERT_NE(nullptr, GetAudioManager); + para.manager = GetAudioManager(); + ASSERT_NE(nullptr, para.manager); + ret = AudioCreateRender(*para.manager, para.pins, para.adapterName, ¶.adapter, + ¶.render); + ASSERT_EQ(HDF_SUCCESS, ret); + + pthread_t tids[PTHREAD_SAMEADA_COUNT]; + for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); + EXPECT_EQ(HDF_SUCCESS, ret); + arrpara[i].character.setmode = AUDIO_CHANNEL_NORMAL; + ret = arrpara[i].render->SetChannelMode(arrpara[i].render, arrpara[i].character.setmode); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSetChannelMode, &arrpara[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + } + for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { + void *result = nullptr; + pthread_join(tids[i], &result); + EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); + EXPECT_EQ(AUDIO_CHANNEL_NORMAL, arrpara[i].character.getmode); + } + para.adapter->DestroyRender(para.adapter, para.render); + para.manager->UnloadAdapter(para.manager, para.adapter); +} +/** +* @tc.name test AudioRenderGetChannelMode API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioRenderGetChannelMode_Reliability_0002 +* @tc.desc test GetChannelMode interface Reliability pass through pthread_create fun and adapterName is different. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetChannelMode_Reliability_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { + { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + } + }; + pthread_t tids[PTHREAD_DIFFADA_COUNT]; + for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { + ASSERT_NE(nullptr, GetAudioManager); + para[i].manager = GetAudioManager(); + ASSERT_NE(nullptr, para[i].manager); + ret = AudioCreateRender(*para[i].manager, para[i].pins, para[i].adapterName, ¶[i].adapter, + ¶[i].render); + ASSERT_EQ(HDF_SUCCESS, ret); + para[i].character.setmode = AUDIO_CHANNEL_NORMAL; + ret = para[i].render->SetChannelMode(para[i].render, para[i].character.setmode); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetChannelMode, ¶[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + } + for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { + para[i].tids = tids[i]; + pthread_join(para[i].tids, ¶[i].result); + ret = (intptr_t)para[i].result; + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_CHANNEL_NORMAL, para[i].character.getmode); + para[i].adapter->DestroyRender(para[i].adapter, para[i].render); + para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); + } +} +/** +* @tc.name test AudioRenderRenderGetLatency API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioRenderRenderGetLatency_Reliability_0001 +* @tc.desc test GetLatency interface Reliability pass through pthread_create fun and adapterName is same. +* @tc.author: wangkang +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderRenderGetLatency_Reliability_0001, TestSize.Level1) +{ + int32_t ret = -1; + uint32_t expectLatency = 0; + struct PrepareAudioPara para = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }; + struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT]; + + ASSERT_NE(nullptr, GetAudioManager); + para.manager = GetAudioManager(); + ASSERT_NE(nullptr, para.manager); + ret = AudioCreateRender(*para.manager, para.pins, para.adapterName, ¶.adapter, + ¶.render); + ASSERT_EQ(HDF_SUCCESS, ret); + + pthread_t tids[PTHREAD_SAMEADA_COUNT]; + for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { + ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), ¶, sizeof(PrepareAudioPara)); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetLatency, &arrpara[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + } + for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { + void *result = nullptr; + pthread_join(tids[i], &result); + EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); + EXPECT_LT(expectLatency, arrpara[i].character.latencyTime); + } + para.adapter->DestroyRender(para.adapter, para.render); + para.manager->UnloadAdapter(para.manager, para.adapter); +} +/** +* @tc.name test AudioRenderRenderGetLatency API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioRenderRenderGetLatency_Reliability_0002 +* @tc.desc test GetLatency interface Reliability pass through pthread_create fun and adapterName is different. +* @tc.author: wangkang +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderRenderGetLatency_Reliability_0002, TestSize.Level1) +{ + int32_t ret = -1; + uint32_t expectLatency = 0; + struct PrepareAudioPara para[PTHREAD_DIFFADA_COUNT] = { + { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_INTERNAL.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + } + }; + pthread_t tids[PTHREAD_DIFFADA_COUNT]; + for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { + ASSERT_NE(nullptr, GetAudioManager); + para[i].manager = GetAudioManager(); + ASSERT_NE(nullptr, para[i].manager); + ret = AudioCreateRender(*para[i].manager, para[i].pins, para[i].adapterName, ¶[i].adapter, + ¶[i].render); + ASSERT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetLatency, ¶[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + } + for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++i) { + para[i].tids = tids[i]; + pthread_join(para[i].tids, ¶[i].result); + ret = (intptr_t)para[i].result; EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_LT(expectLatency, para[i].character.latencyTime); para[i].adapter->DestroyRender(para[i].adapter, para[i].render); para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); } diff --git a/audio/test/systemtest/hdi/render/BUILD.gn b/audio/test/systemtest/hdi/render/BUILD.gn index 043fd1697e..dd68c82db9 100755 --- a/audio/test/systemtest/hdi/render/BUILD.gn +++ b/audio/test/systemtest/hdi/render/BUILD.gn @@ -11,198 +11,487 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build/test.gni") -import("//drivers/adapter/uhdf2/uhdf.gni") +if (defined(ohos_lite)) { + import("//build/lite/config/test.gni") +} else { + import("//build/test.gni") + import("//drivers/adapter/uhdf2/uhdf.gni") + import("//drivers/peripheral/audio/audio.gni") +} -module_output_path = "hdf/audio/systemtest/hdi" -###########################systemtest############################## -###########################AudioHdiRenderAttrTest###################### -ohos_systemtest("AudioHdiRenderAttrTest") { - module_out_path = module_output_path - sources = [ - "src/audio_hdirender_attr_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] +if (defined(ohos_lite)) { +###########################LITEOS########################################## + ###########################hdf_audio_hdi_render_attr_test###################### + unittest("hdf_audio_hdi_render_attr_test") { + sources = [ + "src/audio_hdirender_attr_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] - include_dirs = [ - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/interfaces/include", - "//drivers/framework/include/core", - "//drivers/framework/include/utils", - "//drivers/framework/include/osal", - "//drivers/framework/include", - "//third_party/bounds_checking_function/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/framework/utils/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/adapter/uhdf2/osal/include", - "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", - "//third_party/googletest/googletest/include/gtest", - "//drivers/peripheral/audio/test/systemtest/hdi/render/include", - ] - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - ] - deps = [ - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - ] -} -###########################end########################### -###########################AudioHdiRenderControlTest###################### -ohos_systemtest("AudioHdiRenderControlTest") { - module_out_path = module_output_path - sources = [ - "src/audio_hdirender_control_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + include_dirs = [ + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/include", + "//drivers/framework/core/sec/include", + "//drivers/framework/core/shared/include", + "//drivers/framework/core/host/include", + "//drivers/framework/core/manager/include", + "//drivers/framework/core/common/include/host/", + "//third_party/bounds_checking_function/include", + "//drivers/adapter/khdf/liteos/osal/include", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/adapter/uhdf2/include/hdi/", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/render/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + } + ###########################end########################### + ###########################hdf_audio_hdi_render_control_test###################### + unittest("hdf_audio_hdi_render_control_test") { + sources = [ + "src/audio_hdirender_control_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] - include_dirs = [ - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/interfaces/include", - "//drivers/framework/include/core", - "//drivers/framework/include/utils", - "//drivers/framework/include/osal", - "//drivers/framework/include", - "//third_party/bounds_checking_function/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/framework/utils/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/adapter/uhdf2/osal/include", - "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", - "//third_party/googletest/googletest/include/gtest", - "//drivers/peripheral/audio/test/systemtest/hdi/render/include", - ] - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - ] - deps = [ - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - ] -} -###########################end########################### -###########################AudioHdiRenderVolumeTest###################### -ohos_systemtest("AudioHdiRenderVolumeTest") { - module_out_path = module_output_path - sources = [ - "src/audio_hdirender_volume_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + include_dirs = [ + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/include", + "//drivers/framework/core/sec/include", + "//drivers/framework/core/shared/include", + "//drivers/framework/core/host/include", + "//drivers/framework/core/manager/include", + "//drivers/framework/core/common/include/host/", + "//third_party/bounds_checking_function/include", + "//drivers/adapter/khdf/liteos/osal/include", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/adapter/uhdf2/include/hdi/", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/render/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + } + ###########################end########################### + ###########################hdf_audio_hdi_render_volume_test###################### + unittest("hdf_audio_hdi_render_volume_test") { + sources = [ + "src/audio_hdirender_volume_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] - include_dirs = [ - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/interfaces/include", - "//drivers/framework/include/core", - "//drivers/framework/include/utils", - "//drivers/framework/include/osal", - "//drivers/framework/include", - "//third_party/bounds_checking_function/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/framework/utils/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/adapter/uhdf2/osal/include", - "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", - "//third_party/googletest/googletest/include/gtest", - "//drivers/peripheral/audio/test/systemtest/hdi/render/include", - ] - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - ] - deps = [ - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - ] -} -###########################end########################### -###########################AudioHdiRenderSceneTest###################### -ohos_systemtest("AudioHdiRenderSceneTest") { - module_out_path = module_output_path - sources = [ - "src/audio_hdirender_scene_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + include_dirs = [ + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/include", + "//drivers/framework/core/sec/include", + "//drivers/framework/core/shared/include", + "//drivers/framework/core/host/include", + "//drivers/framework/core/manager/include", + "//drivers/framework/core/common/include/host/", + "//third_party/bounds_checking_function/include", + "//drivers/adapter/khdf/liteos/osal/include", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/adapter/uhdf2/include/hdi/" , + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/render/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + } + ###########################end########################### + ###########################hdf_audio_hdi_render_scene_test###################### + unittest("hdf_audio_hdi_render_scene_test") { - include_dirs = [ - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/interfaces/include", - "//drivers/framework/include/core", - "//drivers/framework/include/utils", - "//drivers/framework/include/osal", - "//drivers/framework/include", - "//third_party/bounds_checking_function/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/framework/utils/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/adapter/uhdf2/osal/include", - "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", - "//third_party/googletest/googletest/include/gtest", - "//drivers/peripheral/audio/test/systemtest/hdi/render/include", - ] - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - ] - deps = [ - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - ] -} -###########################end########################### -###########################AudioHdiRenderTest###################### -ohos_systemtest("AudioHdiRenderTest") { - module_out_path = module_output_path - sources = [ - "src/audio_hdirender_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + sources = [ + "src/audio_hdirender_scene_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] + + include_dirs = [ + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/include", + "//drivers/framework/core/sec/include", + "//drivers/framework/core/shared/include", + "//drivers/framework/core/host/include", + "//drivers/framework/core/manager/include", + "//drivers/framework/core/common/include/host/", + "//third_party/bounds_checking_function/include", + "//drivers/adapter/khdf/liteos/osal/include", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/adapter/uhdf2/include/hdi/", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/render/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + } + ###########################end########################### + ###########################hdf_audio_hdi_render_test###################### + unittest("hdf_audio_hdi_render_test") { + sources = [ + "src/audio_hdirender_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] + + include_dirs = [ + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/include", + "//drivers/framework/core/sec/include", + "//drivers/framework/core/shared/include", + "//drivers/framework/core/host/include", + "//drivers/framework/core/manager/include", + "//drivers/framework/core/common/include/host/", + "//third_party/bounds_checking_function/include", + "//drivers/adapter/khdf/liteos/osal/include", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/adapter/uhdf2/include/hdi/", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/render/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + } +} else { + ###########################systemtest############################## + module_output_path = "hdf/audio" + ###########################hdf_audio_hdi_render_attr_test###################### + ohos_systemtest("hdf_audio_hdi_render_attr_test") { + module_out_path = module_output_path + sources = [ + "src/audio_hdirender_attr_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] + + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/include", + "//third_party/bounds_checking_function/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/adapter/uhdf2/osal/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/render/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + deps = [ + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + defines = [] + if (enable_audio_adm_so) { + defines += [ "AUDIO_ADM_SO" ] + } + if (enable_audio_mpi_so) { + defines += [ "AUDIO_MPI_SO" ] + } + if (enable_audio_adm_service) { + defines += [ "AUDIO_ADM_SERVICE" ] + } + if (enable_audio_mpi_service) { + defines += [ "AUDIO_MPI_SERVICE" ] + } + } + ###########################end########################### + ###########################hdf_audio_hdi_render_control_test###################### + ohos_systemtest("hdf_audio_hdi_render_control_test") { + module_out_path = module_output_path + sources = [ + "src/audio_hdirender_control_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] + + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/include", + "//third_party/bounds_checking_function/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/adapter/uhdf2/osal/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/render/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + deps = [ + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + defines = [] + if (enable_audio_adm_so) { + defines += [ "AUDIO_ADM_SO" ] + } + if (enable_audio_mpi_so) { + defines += [ "AUDIO_MPI_SO" ] + } + if (enable_audio_adm_service) { + defines += [ "AUDIO_ADM_SERVICE" ] + } + if (enable_audio_mpi_service) { + defines += [ "AUDIO_MPI_SERVICE" ] + } + } + ###########################end########################### + ###########################hdf_audio_hdi_render_volume_test###################### + ohos_systemtest("hdf_audio_hdi_render_volume_test") { + module_out_path = module_output_path + sources = [ + "src/audio_hdirender_volume_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] + + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/include", + "//third_party/bounds_checking_function/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/adapter/uhdf2/osal/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/render/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + deps = [ + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + defines = [] + if (enable_audio_adm_so) { + defines += [ "AUDIO_ADM_SO" ] + } + if (enable_audio_mpi_so) { + defines += [ "AUDIO_MPI_SO" ] + } + if (enable_audio_adm_service) { + defines += [ "AUDIO_ADM_SERVICE" ] + } + if (enable_audio_mpi_service) { + defines += [ "AUDIO_MPI_SERVICE" ] + } + } + ###########################end########################### + ###########################hdf_audio_hdi_render_scene_test###################### + ohos_systemtest("hdf_audio_hdi_render_scene_test") { + module_out_path = module_output_path + sources = [ + "src/audio_hdirender_scene_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] + + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/include", + "//third_party/bounds_checking_function/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/adapter/uhdf2/osal/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/render/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + deps = [ + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + defines = [] + if (enable_audio_adm_so) { + defines += [ "AUDIO_ADM_SO" ] + } + if (enable_audio_mpi_so) { + defines += [ "AUDIO_MPI_SO" ] + } + if (enable_audio_adm_service) { + defines += [ "AUDIO_ADM_SERVICE" ] + } + if (enable_audio_mpi_service) { + defines += [ "AUDIO_MPI_SERVICE" ] + } + } + ###########################end########################### + ###########################hdf_audio_hdi_render_test###################### + ohos_systemtest("hdf_audio_hdi_render_test") { + module_out_path = module_output_path + sources = [ + "src/audio_hdirender_test.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp" + ] - include_dirs = [ - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/interfaces/include", - "//drivers/framework/include/core", - "//drivers/framework/include/utils", - "//drivers/framework/include/osal", - "//drivers/framework/include", - "//third_party/bounds_checking_function/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/framework/utils/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/adapter/uhdf2/osal/include", - "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", - "//third_party/googletest/googletest/include/gtest", - "//drivers/peripheral/audio/test/systemtest/hdi/render/include", - ] - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - ] - deps = [ - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - ] + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/include", + "//third_party/bounds_checking_function/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/adapter/uhdf2/osal/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//third_party/googletest/googletest/include/gtest", + "//drivers/peripheral/audio/test/systemtest/hdi/render/include", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + deps = [ + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + defines = [] + if (enable_audio_adm_so) { + defines += [ "AUDIO_ADM_SO" ] + } + if (enable_audio_mpi_so) { + defines += [ "AUDIO_MPI_SO" ] + } + if (enable_audio_adm_service) { + defines += [ "AUDIO_ADM_SERVICE" ] + } + if (enable_audio_mpi_service) { + defines += [ "AUDIO_MPI_SERVICE" ] + } + } } ###########################end########################### \ No newline at end of file diff --git a/audio/test/systemtest/hdi/render/src/audio_hdirender_attr_test.cpp b/audio/test/systemtest/hdi/render/src/audio_hdirender_attr_test.cpp index 8adec45112..4705455014 100755 --- a/audio/test/systemtest/hdi/render/src/audio_hdirender_attr_test.cpp +++ b/audio/test/systemtest/hdi/render/src/audio_hdirender_attr_test.cpp @@ -41,10 +41,8 @@ using namespace testing::ext; using namespace HMOS::Audio; namespace { -const string AUDIO_FILE = "//bin/audiorendertest.wav"; -const string ADAPTER_NAME = "hdmi"; -const string ADAPTER_NAME2 = "usb"; -const string ADAPTER_NAME3 = "internal"; +const string ADAPTER_NAME_USB = "usb"; +const string ADAPTER_NAME_INTERNAL = "internal"; class AudioHdiRenderAttrTest : public testing::Test { public: @@ -52,130 +50,74 @@ public: static void TearDownTestCase(void); void SetUp(); void TearDown(); - struct AudioManager *(*GetAudioManager)() = nullptr; - void *handleSo = nullptr; - int32_t GetLoadAdapter(struct AudioManager manager, enum AudioPortDirection portType, - const string adapterName, struct AudioAdapter **adapter, struct AudioPort& audioPort) const; - int32_t AudioCreateRender(enum AudioPortPin pins, struct AudioManager manager, struct AudioAdapter *adapter, - const struct AudioPort renderPort, struct AudioRender **render) const; - int32_t AudioRenderStart(const string path, struct AudioRender *render) const; + static TestAudioManager *(*GetAudioManager)(); + static void *handleSo; +#ifdef AUDIO_MPI_SO + static int32_t (*SdkInit)(); + static void (*SdkExit)(); + static void *sdkSo; +#endif }; -void AudioHdiRenderAttrTest::SetUpTestCase(void) {} +using THREAD_FUNC = void *(*)(void *); -void AudioHdiRenderAttrTest::TearDownTestCase(void) {} +TestAudioManager *(*AudioHdiRenderAttrTest::GetAudioManager)() = nullptr; +void *AudioHdiRenderAttrTest::handleSo = nullptr; +#ifdef AUDIO_MPI_SO + int32_t (*AudioHdiRenderAttrTest::SdkInit)() = nullptr; + void (*AudioHdiRenderAttrTest::SdkExit)() = nullptr; + void *AudioHdiRenderAttrTest::sdkSo = nullptr; +#endif -void AudioHdiRenderAttrTest::SetUp(void) +void AudioHdiRenderAttrTest::SetUpTestCase(void) { - char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; - handleSo = dlopen(resolvedPath, RTLD_LAZY); - if (handleSo == nullptr) { +#ifdef AUDIO_MPI_SO + char sdkResolvedPath[] = "//system/lib/libhdi_audio_interface_lib_render.z.so"; + sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY); + if (sdkSo == nullptr) { return; } - GetAudioManager = (struct AudioManager* (*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); - if (GetAudioManager == nullptr) { + SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit")); + if (SdkInit == nullptr) { return; } -} - -void AudioHdiRenderAttrTest::TearDown(void) -{ - if (GetAudioManager != nullptr) { - GetAudioManager = nullptr; - } -} - -int32_t AudioHdiRenderAttrTest::GetLoadAdapter(struct AudioManager manager, enum AudioPortDirection portType, - const string adapterName, struct AudioAdapter **adapter, struct AudioPort& audioPort) const -{ - int32_t ret = -1; - int size = 0; - struct AudioAdapterDescriptor *desc = nullptr; - struct AudioAdapterDescriptor *descs = nullptr; - if (adapter == nullptr) { - return HDF_FAILURE; - } - ret = manager.GetAllAdapters(&manager, &descs, &size); - if (ret < 0 || descs == nullptr || size == 0) { - return HDF_FAILURE; - } else { - int index = SwitchAdapter(descs, adapterName, portType, audioPort, size); - if (index < 0) { - return HDF_FAILURE; - } else { - desc = &descs[index]; - } - } - if (desc == nullptr) { - return HDF_FAILURE; - } else { - ret = manager.LoadAdapter(&manager, desc, adapter); - } - if (ret < 0 || adapter == nullptr) { - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t AudioHdiRenderAttrTest::AudioCreateRender(enum AudioPortPin pins, struct AudioManager manager, - struct AudioAdapter *adapter, const struct AudioPort renderPort, struct AudioRender **render) const -{ - int32_t ret = -1; - struct AudioSampleAttributes attrs = {}; - struct AudioDeviceDescriptor devDesc = {}; - if (adapter == nullptr || adapter->CreateRender == nullptr || render == nullptr) { - return HDF_FAILURE; - } - ret = InitAttrs(attrs); - if (ret < 0) { - return HDF_FAILURE; + SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit")); + if (SdkExit == nullptr) { + return; } - ret = InitDevDesc(devDesc, renderPort.portId, pins); - if (ret < 0) { - return HDF_FAILURE; + SdkInit(); +#endif + handleSo = dlopen(RESOLVED_PATH.c_str(), RTLD_LAZY); + if (handleSo == nullptr) { + return; } - ret = adapter->CreateRender(adapter, &devDesc, &attrs, render); - if (ret < 0 || *render == nullptr) { - manager.UnloadAdapter(&manager, adapter); - return HDF_FAILURE; + GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str())); + if (GetAudioManager == nullptr) { + return; } - return HDF_SUCCESS; } -int32_t AudioHdiRenderAttrTest::AudioRenderStart(const string path, struct AudioRender *render) const +void AudioHdiRenderAttrTest::TearDownTestCase(void) { - int32_t ret = -1; - struct AudioSampleAttributes attrs = {}; - struct AudioHeadInfo headInfo = {}; - if (render == nullptr) { - return HDF_FAILURE; - } - ret = InitAttrs(attrs); - if (ret < 0) { - return HDF_FAILURE; +#ifdef AUDIO_MPI_SO + SdkExit(); + if (sdkSo != nullptr) { + dlclose(sdkSo); + sdkSo = nullptr; } - char absPath[PATH_MAX] = {0}; - if (realpath(path.c_str(), absPath) == nullptr) { - printf("path is not exist"); - return HDF_FAILURE; + if (SdkInit != nullptr) { + SdkInit = nullptr; } - FILE *file = fopen(absPath, "rb"); - if (file == nullptr) { - return HDF_FAILURE; + if (SdkExit != nullptr) { + SdkExit = nullptr; } - ret = WavHeadAnalysis(headInfo, file, attrs); - if (ret < 0) { - fclose(file); - return HDF_FAILURE; - } - ret = FrameStart(headInfo, render, file, attrs); - if (ret < 0) { - fclose(file); - return HDF_FAILURE; +#endif + if (GetAudioManager != nullptr) { + GetAudioManager = nullptr; } - fclose(file); - return HDF_SUCCESS; } +void AudioHdiRenderAttrTest::SetUp(void) {} +void AudioHdiRenderAttrTest::TearDown(void) {} /** * @tc.name Test AudioRenderSetSampleAttributes API via legal input. @@ -193,26 +135,14 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_00 uint32_t ret1 = 1; uint32_t ret2 = 8000; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioSampleAttributes attrs = {}; struct AudioSampleAttributes attrsValue = {}; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - attrs.type = AUDIO_IN_MEDIA; - attrs.format = AUDIO_FORMAT_PCM_16_BIT; - attrs.sampleRate = 8000; - attrs.channelCount = 1; + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 8000); ret = render->attr.SetSampleAttributes(render, &attrs); EXPECT_EQ(HDF_SUCCESS, ret); @@ -243,30 +173,16 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_00 uint32_t ret1 = 11025; uint32_t ret2 = 2; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioSampleAttributes attrs = {}; struct AudioSampleAttributes attrsValue = {}; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 11025); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - attrs.type = AUDIO_IN_MEDIA; - attrs.format = AUDIO_FORMAT_PCM_24_BIT; - attrs.sampleRate = 11025; - attrs.channelCount = 2; - - ret = render->attr.SetSampleAttributes(render, &attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->attr.GetSampleAttributes(render, &attrsValue); + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); @@ -293,30 +209,16 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_00 uint32_t ret1 = 22050; uint32_t ret2 = 2; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioSampleAttributes attrs = {}; struct AudioSampleAttributes attrsValue = {}; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 2, 22050); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - attrs.type = AUDIO_IN_MEDIA; - attrs.format = AUDIO_FORMAT_PCM_16_BIT; - attrs.sampleRate = 22050; - attrs.channelCount = 2; - - ret = render->attr.SetSampleAttributes(render, &attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->attr.GetSampleAttributes(render, &attrsValue); + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); @@ -343,29 +245,16 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_00 uint32_t ret1 = 32000; uint32_t ret2 = 2; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioSampleAttributes attrs = {}; struct AudioSampleAttributes attrsValue = {}; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 32000); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - attrs.type = AUDIO_IN_MEDIA; - attrs.format = AUDIO_FORMAT_PCM_24_BIT; - attrs.sampleRate = 32000; - attrs.channelCount = 2; - - ret = render->attr.SetSampleAttributes(render, &attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->attr.GetSampleAttributes(render, &attrsValue); + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); @@ -392,29 +281,16 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_00 uint32_t ret1 = 44100; uint32_t ret2 = 1; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioSampleAttributes attrs = {}; struct AudioSampleAttributes attrsValue = {}; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 44100); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - attrs.type = AUDIO_IN_MEDIA; - attrs.format = AUDIO_FORMAT_PCM_16_BIT; - attrs.sampleRate = 44100; - attrs.channelCount = 1; - - ret = render->attr.SetSampleAttributes(render, &attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->attr.GetSampleAttributes(render, &attrsValue); + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); @@ -440,29 +316,16 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_00 uint32_t ret1 = 48000; uint32_t ret2 = 2; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioSampleAttributes attrs = {}; struct AudioSampleAttributes attrsValue = {}; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 48000); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - attrs.type = AUDIO_IN_MEDIA; - attrs.format = AUDIO_FORMAT_PCM_24_BIT; - attrs.sampleRate = 48000; - attrs.channelCount = 2; - - ret = render->attr.SetSampleAttributes(render, &attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->attr.GetSampleAttributes(render, &attrsValue); + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); @@ -483,26 +346,14 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_00 { int32_t ret = -1; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioRender *renderNull = nullptr; struct AudioSampleAttributes attrs = {}; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - attrs.type = AUDIO_IN_MEDIA; - attrs.format = AUDIO_FORMAT_PCM_16_BIT; - attrs.sampleRate = AUDIO_SAMPLE_RATE_MASK_8000; - attrs.channelCount = 1; + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 8000); ret = render->attr.SetSampleAttributes(renderNull, &attrs); EXPECT_EQ(HDF_FAILURE, ret); @@ -513,110 +364,207 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_00 manager.UnloadAdapter(&manager, adapter); } /** -* @tc.name Test AudioRenderSetSampleAttributes API via illegal input. +* @tc.name Test AudioRenderSetSampleAttributes API via legal input. * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0008 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows. * attrs.type = AUDIO_IN_MEDIA; -* attrs.format = AUDIO_FORMAT_PCM_16/24_BIT; -* attrs.sampleRate = 12000/16000/24000; -* attrs.channelCount = 1/2; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = 12000; +* attrs.channelCount = 1; * @tc.author: ZHANGHAILIN */ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0008, TestSize.Level1) { int32_t ret = -1; + uint32_t ret1 = 1; + uint32_t ret2 = 12000; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; - struct AudioSampleAttributes attrs1 = {}; - struct AudioSampleAttributes attrs2 = {}; - struct AudioSampleAttributes attrs3 = {}; - struct AudioManager manager = *GetAudioManager(); + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); + ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 12000); + + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); + EXPECT_EQ(HDF_SUCCESS, ret); + + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(ret2, attrsValue.sampleRate); + EXPECT_EQ(ret1, attrsValue.channelCount); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0009 +* @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_24_BIT; +* attrs.sampleRate = 16000; +* attrs.channelCount = 1; +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0009, TestSize.Level1) +{ + int32_t ret = -1; + uint32_t ret1 = 1; + uint32_t ret2 = 16000; + struct AudioAdapter *adapter = nullptr; + struct AudioRender *render = nullptr; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 16000); + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); + EXPECT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(ret2, attrsValue.sampleRate); + EXPECT_EQ(ret1, attrsValue.channelCount); - attrs1.type = AUDIO_IN_MEDIA; - attrs1.format = AUDIO_FORMAT_PCM_16_BIT; - attrs1.sampleRate = 12000; - attrs1.channelCount = 1; - ret = render->attr.SetSampleAttributes(render, &attrs1); - EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0010 +* @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = 24000; +* attrs.channelCount = 2; +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0010, TestSize.Level1) +{ + int32_t ret = -1; + uint32_t ret1 = 2; + uint32_t ret2 = 24000; + struct AudioAdapter *adapter = nullptr; + struct AudioRender *render = nullptr; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); + ASSERT_EQ(HDF_SUCCESS, ret); - attrs2.type = AUDIO_IN_MEDIA; - attrs2.format = AUDIO_FORMAT_PCM_24_BIT; - attrs2.sampleRate = 16000; - attrs2.channelCount = 1; - ret = render->attr.SetSampleAttributes(render, &attrs2); - EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 2, 24000); + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); + EXPECT_EQ(HDF_SUCCESS, ret); - attrs3.type = AUDIO_IN_MEDIA; - attrs3.format = AUDIO_FORMAT_PCM_16_BIT; - attrs3.sampleRate = 24000; - attrs3.channelCount = 2; - ret = render->attr.SetSampleAttributes(render, &attrs3); - EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(ret2, attrsValue.sampleRate); + EXPECT_EQ(ret1, attrsValue.channelCount); adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); } /** -* @tc.name Test AudioRenderSetSampleAttributes API via illegal input. -* @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0009 +* @tc.name Test AudioRenderSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0011 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows. * attrs.type = AUDIO_IN_MEDIA; -* attrs.format = AUDIO_FORMAT_PCM_16/24_BIT; -* attrs.sampleRate = 64000/96000/0xFFFFFFFFu; -* attrs.channelCount = 1/2; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = 64000; +* attrs.channelCount = 2; * @tc.author: ZHANGHAILIN */ -HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0009, TestSize.Level1) +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0011, TestSize.Level1) { int32_t ret = -1; + uint32_t ret1 = 2; + uint32_t ret2 = 64000; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; - struct AudioSampleAttributes attrs1 = {}; - struct AudioSampleAttributes attrs2 = {}; - struct AudioSampleAttributes attrs3 = {}; - struct AudioManager manager = *GetAudioManager(); + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); + ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 2, 64000); + + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); + EXPECT_EQ(HDF_SUCCESS, ret); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(ret2, attrsValue.sampleRate); + EXPECT_EQ(ret1, attrsValue.channelCount); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0012 +* @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_24_BIT; +* attrs.sampleRate = 96000; +* attrs.channelCount = 1; +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0012, TestSize.Level1) +{ + int32_t ret = -1; + uint32_t ret1 = 1; + uint32_t ret2 = 96000; + struct AudioAdapter *adapter = nullptr; + struct AudioRender *render = nullptr; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 96000); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); + EXPECT_EQ(HDF_SUCCESS, ret); - attrs1.type = AUDIO_IN_MEDIA; - attrs1.format = AUDIO_FORMAT_PCM_16_BIT; - attrs1.sampleRate = 64000; - attrs1.channelCount = 1; - ret = render->attr.SetSampleAttributes(render, &attrs1); - EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(ret2, attrsValue.sampleRate); + EXPECT_EQ(ret1, attrsValue.channelCount); - attrs2.type = AUDIO_IN_MEDIA; - attrs2.format = AUDIO_FORMAT_PCM_24_BIT; - attrs2.sampleRate = 96000; - attrs2.channelCount = 1; - ret = render->attr.SetSampleAttributes(render, &attrs2); - EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderSetSampleAttributes API via illegal input. +* @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0013 +* @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = 0xFFFFFFFFu; +* attrs.channelCount = 2; +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0013, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = nullptr; + struct AudioRender *render = nullptr; + struct AudioSampleAttributes attrs = {}; + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); + ASSERT_EQ(HDF_SUCCESS, ret); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 2, 0xFFFFFFFFu); - attrs3.type = AUDIO_IN_MEDIA; - attrs3.format = AUDIO_FORMAT_PCM_16_BIT; - attrs3.sampleRate = 0xFFFFFFFFu; - attrs3.channelCount = 2; - ret = render->attr.SetSampleAttributes(render, &attrs3); + ret = render->attr.SetSampleAttributes(render, &attrs); EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); adapter->DestroyRender(adapter, render); @@ -624,7 +572,7 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_00 } /** * @tc.name Test AudioRenderSetSampleAttributes API via illegal input. -* @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0010 +* @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0014 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows. * attrs.type = AUDIO_IN_MEDIA; * attrs.format = AUDIO_FORMAT_PCM_8/32_BIT/AAC_MAIN; @@ -632,45 +580,29 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_00 * attrs.channelCount = 1/2; * @tc.author: ZHANGHAILIN */ -HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0010, TestSize.Level1) +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0014, TestSize.Level1) { int32_t ret = -1; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioSampleAttributes attrs1 = {}; struct AudioSampleAttributes attrs2 = {}; struct AudioSampleAttributes attrs3 = {}; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - attrs1.type = AUDIO_IN_MEDIA; - attrs1.format = AUDIO_FORMAT_PCM_8_BIT; - attrs1.sampleRate = 8000; - attrs1.channelCount = 1; + InitAttrsUpdate(attrs1, AUDIO_FORMAT_PCM_8_BIT, 1, 8000); ret = render->attr.SetSampleAttributes(render, &attrs1); EXPECT_EQ(HDF_FAILURE, ret); - attrs2.type = AUDIO_IN_MEDIA; - attrs2.format = AUDIO_FORMAT_PCM_32_BIT; - attrs2.sampleRate = 11025; - attrs2.channelCount = 2; + InitAttrsUpdate(attrs2, AUDIO_FORMAT_PCM_32_BIT, 2, 11025); ret = render->attr.SetSampleAttributes(render, &attrs2); EXPECT_EQ(HDF_FAILURE, ret); - attrs3.type = AUDIO_IN_MEDIA; - attrs3.format = AUDIO_FORMAT_AAC_MAIN; - attrs3.sampleRate = 22050; - attrs3.channelCount = 1; + InitAttrsUpdate(attrs3, AUDIO_FORMAT_AAC_MAIN, 1, 22050); ret = render->attr.SetSampleAttributes(render, &attrs3); EXPECT_EQ(HDF_FAILURE, ret); @@ -679,7 +611,7 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_00 } /** * @tc.name Test AudioRenderSetSampleAttributes API via illegal input. -* @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0011 +* @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0015 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows. * attrs.type = AUDIO_IN_MEDIA; * attrs.format = AUDIO_FORMAT_AAC_LC/LD/ELD; @@ -687,45 +619,28 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_00 * attrs.channelCount = 1/2; * @tc.author: ZHANGHAILIN */ -HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0011, TestSize.Level1) +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0015, TestSize.Level1) { int32_t ret = -1; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioSampleAttributes attrs1 = {}; struct AudioSampleAttributes attrs2 = {}; struct AudioSampleAttributes attrs3 = {}; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - attrs1.type = AUDIO_IN_MEDIA; - attrs1.format = AUDIO_FORMAT_AAC_LC; - attrs1.sampleRate = 32000; - attrs1.channelCount = 2; + InitAttrsUpdate(attrs1, AUDIO_FORMAT_AAC_LC, 2, 32000); ret = render->attr.SetSampleAttributes(render, &attrs1); EXPECT_EQ(HDF_FAILURE, ret); - attrs2.type = AUDIO_IN_MEDIA; - attrs2.format = AUDIO_FORMAT_AAC_LD; - attrs2.sampleRate = 44100; - attrs2.channelCount = 1; + InitAttrsUpdate(attrs2, AUDIO_FORMAT_AAC_LD, 1, 44100); ret = render->attr.SetSampleAttributes(render, &attrs2); EXPECT_EQ(HDF_FAILURE, ret); - attrs3.type = AUDIO_IN_MEDIA; - attrs3.format = AUDIO_FORMAT_AAC_ELD; - attrs3.sampleRate = 48000; - attrs3.channelCount = 2; + InitAttrsUpdate(attrs3, AUDIO_FORMAT_AAC_ELD, 2, 48000); ret = render->attr.SetSampleAttributes(render, &attrs3); EXPECT_EQ(HDF_FAILURE, ret); @@ -734,7 +649,7 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_00 } /** * @tc.name Test AudioRenderSetSampleAttributes API via illegal input. -* @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0012 +* @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0016 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows. * attrs.type = AUDIO_IN_MEDIA; * attrs.format = AUDIO_FORMAT_AAC_HE_V1/V2 @@ -742,37 +657,23 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_00 * attrs.channelCount = 1/2; * @tc.author: ZHANGHAILIN */ -HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0012, TestSize.Level1) +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0016, TestSize.Level1) { int32_t ret = -1; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioSampleAttributes attrs1 = {}; struct AudioSampleAttributes attrs2 = {}; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - attrs1.type = AUDIO_IN_MEDIA; - attrs1.format = AUDIO_FORMAT_AAC_HE_V1; - attrs1.sampleRate = 8000; - attrs1.channelCount = 1; + InitAttrsUpdate(attrs1, AUDIO_FORMAT_AAC_HE_V1, 1, 8000); ret = render->attr.SetSampleAttributes(render, &attrs1); EXPECT_EQ(HDF_FAILURE, ret); - attrs2.type = AUDIO_IN_MEDIA; - attrs2.format = AUDIO_FORMAT_AAC_HE_V2; - attrs2.sampleRate = 44100; - attrs2.channelCount = 2; + InitAttrsUpdate(attrs2, AUDIO_FORMAT_AAC_HE_V2, 2, 44100); ret = render->attr.SetSampleAttributes(render, &attrs2); EXPECT_EQ(HDF_FAILURE, ret); @@ -781,7 +682,7 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_00 } /** * @tc.name Test AudioRenderSetSampleAttributes API via illegal input. -* @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0013 +* @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0017 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows. * attrs.type = AUDIO_IN_MEDIA; * attrs.format = AUDIO_FORMAT_PCM_16_BIT @@ -789,29 +690,18 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_00 * attrs.channelCount = 5; * @tc.author: ZHANGHAILIN */ -HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0013, TestSize.Level1) +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0017, TestSize.Level1) { int32_t ret = -1; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioSampleAttributes attrs = {}; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - attrs.type = AUDIO_IN_MEDIA; - attrs.format = AUDIO_FORMAT_PCM_16_BIT; - attrs.sampleRate = 8000; - attrs.channelCount = 5; + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 5, 8000); ret = render->attr.SetSampleAttributes(render, &attrs); EXPECT_EQ(HDF_FAILURE, ret); @@ -834,34 +724,20 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderGetSampleAttributes_00 uint32_t ret1 = 8000; uint32_t ret2 = 1; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioSampleAttributes attrs = {}; struct AudioSampleAttributes attrsValue = {}; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - attrs.type = AUDIO_IN_MEDIA; - attrs.format = AUDIO_FORMAT_PCM_16_BIT; - attrs.sampleRate = 8000; - attrs.channelCount = 1; - - ret = render->attr.SetSampleAttributes(render, &attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->attr.GetSampleAttributes(render, &attrsValue); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 8000); + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); - EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); EXPECT_EQ(ret1, attrsValue.sampleRate); EXPECT_EQ(ret2, attrsValue.channelCount); @@ -878,27 +754,15 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderGetSampleAttributes_00 { int32_t ret = -1; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioRender *renderNull = nullptr; struct AudioSampleAttributes attrs = {}; struct AudioSampleAttributes *attrsValue = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - attrs.type = AUDIO_IN_MEDIA; - attrs.format = AUDIO_FORMAT_PCM_24_BIT; - attrs.sampleRate = 48000; - attrs.channelCount = 1; + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 44100); ret = render->attr.GetSampleAttributes(renderNull, &attrs); EXPECT_EQ(HDF_FAILURE, ret); @@ -917,22 +781,14 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderGetSampleAttributes_00 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; - struct AudioRender *render = nullptr; uint64_t size = 0; uint64_t zero = 0; - + struct AudioAdapter *adapter = nullptr; + struct AudioRender *render = nullptr; ASSERT_NE(nullptr, GetAudioManager); - manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->attr.GetFrameSize(render, &size); EXPECT_EQ(HDF_SUCCESS, ret); @@ -950,22 +806,14 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0001, TestSize HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; + uint64_t size = 0; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioRender *renderNull = nullptr; - uint64_t size = 0; - ASSERT_NE(nullptr, GetAudioManager); - manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->attr.GetFrameSize(renderNull, &size); EXPECT_EQ(HDF_FAILURE, ret); @@ -982,21 +830,13 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0002, TestSize HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0003, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; + uint64_t *sizeNull = nullptr; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; - uint64_t *sizeNull = nullptr; - ASSERT_NE(nullptr, GetAudioManager); - manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->attr.GetFrameSize(render, sizeNull); EXPECT_EQ(HDF_FAILURE, ret); @@ -1012,34 +852,23 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0003, TestSize */ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0004, TestSize.Level1) { - int32_t ret = -1; - struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; - struct AudioRender *render = nullptr; - struct AudioSampleAttributes attrs = {}; - struct AudioSampleAttributes attrsValue = {}; + int32_t ret = -1; uint64_t size = 0; uint64_t channelCountExp = 2; uint32_t sampleRateExp = 48000; - struct AudioManager manager = *GetAudioManager(); + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + struct AudioAdapter *adapter = nullptr; + struct AudioRender *render = nullptr; ASSERT_NE(nullptr, GetAudioManager); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - attrs.type = AUDIO_IN_MEDIA; - attrs.interleaved = false; - attrs.format = AUDIO_FORMAT_PCM_16_BIT; - attrs.sampleRate = 48000; - attrs.channelCount = 2; - ret = render->attr.SetSampleAttributes(render, &attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->attr.GetSampleAttributes(render, &attrsValue); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 48000); + + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); EXPECT_EQ(channelCountExp, attrsValue.channelCount); @@ -1058,32 +887,21 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0004, TestSize */ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0005, TestSize.Level1) { - int32_t ret = -1; - struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; - struct AudioRender *render = nullptr; - struct AudioSampleAttributes attrs = {}; - struct AudioSampleAttributes attrsValue = {}; + int32_t ret = -1; uint64_t size = 0; uint64_t channelCountExp = 1; uint32_t sampleRateExp = 48000; - struct AudioManager manager = *GetAudioManager(); + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + struct AudioAdapter *adapter = nullptr; + struct AudioRender *render = nullptr; ASSERT_NE(nullptr, GetAudioManager); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - attrs.type = AUDIO_IN_MEDIA; - attrs.interleaved = false; - attrs.format = AUDIO_FORMAT_PCM_16_BIT; - attrs.sampleRate = 48000; - attrs.channelCount = 1; - ret = render->attr.SetSampleAttributes(render, &attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->attr.GetSampleAttributes(render, &attrsValue); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 48000); + + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); @@ -1104,32 +922,21 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0005, TestSize */ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0006, TestSize.Level1) { - int32_t ret = -1; - struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; - struct AudioRender *render = nullptr; - struct AudioSampleAttributes attrs = {}; - struct AudioSampleAttributes attrsValue = {}; + int32_t ret = -1; uint64_t size = 0; uint64_t channelCountExp = 2; - uint32_t sampleRateExp = 48000; - struct AudioManager manager = *GetAudioManager(); + uint32_t sampleRateExp = 44100; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + struct AudioAdapter *adapter = nullptr; + struct AudioRender *render = nullptr; ASSERT_NE(nullptr, GetAudioManager); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - attrs.type = AUDIO_IN_MEDIA; - attrs.interleaved = false; - attrs.format = AUDIO_FORMAT_PCM_24_BIT; - attrs.sampleRate = 48000; - attrs.channelCount = 2; - ret = render->attr.SetSampleAttributes(render, &attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->attr.GetSampleAttributes(render, &attrsValue); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 44100); + + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); @@ -1150,32 +957,21 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0006, TestSize */ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0007, TestSize.Level1) { - int32_t ret = -1; - struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; - struct AudioRender *render = nullptr; - struct AudioSampleAttributes attrs = {}; - struct AudioSampleAttributes attrsValue = {}; + int32_t ret = -1; uint64_t size = 0; uint64_t channelCountExp = 1; - uint32_t sampleRateExp = 44100; - struct AudioManager manager = *GetAudioManager(); + uint32_t sampleRateExp = 48000; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + struct AudioAdapter *adapter = nullptr; + struct AudioRender *render = nullptr; ASSERT_NE(nullptr, GetAudioManager); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - attrs.type = AUDIO_IN_MEDIA; - attrs.interleaved = false; - attrs.format = AUDIO_FORMAT_PCM_24_BIT; - attrs.sampleRate = 44100; - attrs.channelCount = 1; - ret = render->attr.SetSampleAttributes(render, &attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->attr.GetSampleAttributes(render, &attrsValue); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 48000); + + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); @@ -1197,24 +993,15 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0007, TestSize HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; - struct AudioRender *render = nullptr; uint64_t count = 0; uint64_t zero = 0; - + TestAudioManager manager = {}; + struct AudioAdapter *adapter =nullptr; + struct AudioRender *render = nullptr; ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioRenderStart(AUDIO_FILE, render); - EXPECT_EQ(HDF_SUCCESS, ret); ret = render->attr.GetFrameCount(render, &count); EXPECT_EQ(HDF_SUCCESS, ret); @@ -1233,24 +1020,15 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0001, TestSiz HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; + uint64_t count = 0; + TestAudioManager manager = {}; + struct AudioAdapter *adapter =nullptr; struct AudioRender *render = nullptr; struct AudioRender *renderNull = nullptr; - uint64_t count = 0; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioRenderStart(AUDIO_FILE, render); - EXPECT_EQ(HDF_SUCCESS, ret); ret = render->attr.GetFrameCount(renderNull, &count); EXPECT_EQ(HDF_FAILURE, ret); @@ -1268,23 +1046,14 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0002, TestSiz HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0003, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; - struct AudioRender *render = nullptr; uint64_t *countNull = nullptr; - + TestAudioManager manager = {}; + struct AudioAdapter *adapter =nullptr; + struct AudioRender *render = nullptr; ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioRenderStart(AUDIO_FILE, render); - EXPECT_EQ(HDF_SUCCESS, ret); ret = render->attr.GetFrameCount(render, countNull); EXPECT_EQ(HDF_FAILURE, ret); @@ -1302,37 +1071,26 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0003, TestSiz HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0004, TestSize.Level1) { int32_t ret = -1; + uint64_t count = 0; + uint64_t channelCountExp = 2; + uint32_t sampleRateExp = 8000; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioSampleAttributes attrs = {}; struct AudioSampleAttributes attrsValue = {}; - uint64_t count = 0; - uint64_t channelCountExp = 2; - uint32_t sampleRateExp = 48000; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - attrs.type = AUDIO_IN_MEDIA; - attrs.interleaved = false; - attrs.format = AUDIO_FORMAT_PCM_16_BIT; - attrs.sampleRate = 48000; - attrs.channelCount = 2; - ret = render->attr.SetSampleAttributes(render, &attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->attr.GetSampleAttributes(render, &attrsValue); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 8000); + + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); EXPECT_EQ(channelCountExp, attrsValue.channelCount); - ret = AudioRenderStart(AUDIO_FILE, render); + ret = AudioRenderStartAndOneFrame(render); EXPECT_EQ(HDF_SUCCESS, ret); ret = render->attr.GetFrameCount(render, &count); EXPECT_EQ(HDF_SUCCESS, ret); @@ -1352,37 +1110,26 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0004, TestSiz HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0005, TestSize.Level1) { int32_t ret = -1; + uint64_t count = 0; + uint64_t channelCountExp = 2; + uint32_t sampleRateExp = 8000; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioSampleAttributes attrs = {}; struct AudioSampleAttributes attrsValue = {}; - uint64_t count = 0; - uint64_t channelCountExp = 2; - uint32_t sampleRateExp = 48000; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - attrs.type = AUDIO_IN_MEDIA; - attrs.interleaved = false; - attrs.format = AUDIO_FORMAT_PCM_24_BIT; - attrs.sampleRate = 48000; - attrs.channelCount = 2; - ret = render->attr.SetSampleAttributes(render, &attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->attr.GetSampleAttributes(render, &attrsValue); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 2, 8000); + + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); EXPECT_EQ(channelCountExp, attrsValue.channelCount); - ret = AudioRenderStart(AUDIO_FILE, render); + ret = AudioRenderStartAndOneFrame(render); EXPECT_EQ(HDF_SUCCESS, ret); ret = render->attr.GetFrameCount(render, &count); EXPECT_EQ(HDF_SUCCESS, ret); @@ -1402,44 +1149,32 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0005, TestSiz HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0006, TestSize.Level1) { int32_t ret = -1; + uint64_t count = 0; + uint64_t channelCountExp = 1; + uint32_t sampleRateExp = 44100; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioSampleAttributes attrs = {}; struct AudioSampleAttributes attrsValue = {}; - uint64_t count = 0; - uint64_t channelCountExp = 1; - uint32_t sampleRateExp = 48000; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - attrs.type = AUDIO_IN_MEDIA; - attrs.interleaved = false; - attrs.format = AUDIO_FORMAT_PCM_16_BIT; - attrs.sampleRate = 48000; - attrs.channelCount = 1; - ret = render->attr.SetSampleAttributes(render, &attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->attr.GetSampleAttributes(render, &attrsValue); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 44100); + + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); EXPECT_EQ(channelCountExp, attrsValue.channelCount); - ret = AudioRenderStart(AUDIO_FILE, render); + ret = AudioRenderStartAndOneFrame(render); EXPECT_EQ(HDF_SUCCESS, ret); ret = render->attr.GetFrameCount(render, &count); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_GT(count, INITIAL_VALUE); - ret = render->control.Stop((AudioHandle)render); - EXPECT_EQ(HDF_SUCCESS, ret); + render->control.Stop((AudioHandle)render); adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); } @@ -1452,44 +1187,32 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0006, TestSiz HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0007, TestSize.Level1) { int32_t ret = -1; + uint64_t count = 0; + uint64_t channelCountExp = 1; + uint32_t sampleRateExp = 32000; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioSampleAttributes attrs = {}; struct AudioSampleAttributes attrsValue = {}; - uint64_t count = 0; - uint64_t channelCountExp = 1; - uint32_t sampleRateExp = 48000; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - attrs.type = AUDIO_IN_MEDIA; - attrs.interleaved = false; - attrs.format = AUDIO_FORMAT_PCM_24_BIT; - attrs.sampleRate = 48000; - attrs.channelCount = 1; - ret = render->attr.SetSampleAttributes(render, &attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->attr.GetSampleAttributes(render, &attrsValue); + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 32000); + + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); EXPECT_EQ(channelCountExp, attrsValue.channelCount); - ret = AudioRenderStart(AUDIO_FILE, render); + ret = AudioRenderStartAndOneFrame(render); EXPECT_EQ(HDF_SUCCESS, ret); ret = render->attr.GetFrameCount(render, &count); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_GT(count, INITIAL_VALUE); - ret = render->control.Stop((AudioHandle)render); - EXPECT_EQ(HDF_SUCCESS, ret); + render->control.Stop((AudioHandle)render); adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); } @@ -1502,22 +1225,14 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0007, TestSiz HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetCurrentChannelId_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; - struct AudioRender *render = nullptr; uint32_t channelId = 0; uint32_t channelIdValue = CHANNELCOUNT; - + struct AudioAdapter *adapter = nullptr; + struct AudioRender *render = nullptr; ASSERT_NE(nullptr, GetAudioManager); - manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->attr.GetCurrentChannelId(render, &channelId); EXPECT_EQ(HDF_SUCCESS, ret); @@ -1535,32 +1250,20 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetCurrentChannelId_0001, T HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetCurrentChannelId_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; - struct AudioRender *render = nullptr; uint32_t channelId = 0; uint32_t channelIdExp = 1; uint32_t channelCountExp = 1; struct AudioSampleAttributes attrs = {}; - + struct AudioSampleAttributes attrsValue = {}; + struct AudioAdapter *adapter = nullptr; + struct AudioRender *render = nullptr; ASSERT_NE(nullptr, GetAudioManager); - manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 32000); - attrs.type = AUDIO_IN_MEDIA; - attrs.format = AUDIO_FORMAT_PCM_16_BIT; - attrs.sampleRate = 48000; - attrs.channelCount = 1; - ret = render->attr.SetSampleAttributes(render, &attrs); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->attr.GetSampleAttributes(render, &attrs); + ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(channelCountExp, attrs.channelCount); @@ -1580,22 +1283,14 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetCurrentChannelId_0002, T HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetCurrentChannelId_0003, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; - struct AudioRender *render = nullptr; uint32_t channelId = 0; uint32_t channelIdExp = 2; - + struct AudioAdapter *adapter = nullptr; + struct AudioRender *render = nullptr; ASSERT_NE(nullptr, GetAudioManager); - manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->attr.GetCurrentChannelId(render, &channelId); EXPECT_EQ(HDF_SUCCESS, ret); @@ -1613,22 +1308,14 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetCurrentChannelId_0003, T HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetCurrentChannelId_0004, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; + uint32_t channelId = 0; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioRender *renderNull = nullptr; - uint32_t channelId = 0; - ASSERT_NE(nullptr, GetAudioManager); - manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->attr.GetCurrentChannelId(renderNull, &channelId); EXPECT_EQ(HDF_FAILURE, ret); @@ -1645,26 +1332,376 @@ HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetCurrentChannelId_0004, T HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetCurrentChannelId_0005, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; + uint32_t *channelIdNull = nullptr; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; - uint32_t *channelIdNull = nullptr; + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); + ASSERT_EQ(HDF_SUCCESS, ret); + + ret = render->attr.GetCurrentChannelId(render, channelIdNull); + EXPECT_EQ(HDF_FAILURE, ret); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +#if defined (AUDIO_ADM_SERVICE) || defined (AUDIO_ADM_SO) +/** + * @tc.name Test RenderSetExtraParams API via setting ExtraParams during playback + * @tc.number SUB_Audio_HDI_RenderSetExtraParams_0001 + * @tc.desc Test RenderSetExtraParams interface,return 0 if the ExtraParams is set during playback + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_0001, TestSize.Level1) +{ + int32_t ret = -1; + char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000"; + char keyValueListValue[256] = {}; + int32_t listLenth = 256; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }; ASSERT_NE(nullptr, GetAudioManager); - manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); + + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); + sleep(1); + if (audiopara.render != nullptr) { + ret = audiopara.render->attr.SetExtraParams((AudioHandle)audiopara.render, keyValueList); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->attr.GetExtraParams((AudioHandle)audiopara.render, keyValueListValue, listLenth); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_STREQ(keyValueList, keyValueListValue); } - ret = render->attr.GetCurrentChannelId(render, channelIdNull); + ret = ThreadRelease(audiopara); + EXPECT_EQ(HDF_SUCCESS, ret); +} +/** + * @tc.name Test RenderSetExtraParams API via setting some parameters after playing + * @tc.number SUB_Audio_HDI_RenderSetExtraParams_0002 + * @tc.desc Test RenderSetExtraParams interface,return 0 if some parameters is set after playing + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = {}; + struct AudioRender *render = nullptr; + char keyValueListOne[] = "attr-route=1;"; + char keyValueListOneExp[] = "attr-route=1;attr-format=16;attr-channels=2;attr-frame-count=4096;\ +attr-sampling-rate=48000"; + char keyValueListTwo[] = "attr-route=0;attr-format=32;"; + char keyValueListTwoExp[] = "attr-route=0;attr-format=32;attr-channels=2;attr-frame-count=4096;\ +attr-sampling-rate=48000"; + char keyValueListThr[] = "attr-route=1;attr-format=24;attr-channels=1;"; + char keyValueListThrExp[] = "attr-route=1;attr-format=24;attr-channels=1;attr-frame-count=4096;\ +attr-sampling-rate=48000"; + char keyValueListFour[] = "attr-format=32;attr-channels=2;attr-frame-count=4096;attr-sampling-rate=48000"; + char keyValueListFourExp[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=4096;\ +attr-sampling-rate=48000"; + char keyValueListValueOne[256] = {}; + char keyValueListValueTwo[256] = {}; + char keyValueListValueThr[256] = {}; + char keyValueListValueFour[256] = {}; + int32_t listLenth = 256; + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = render->attr.SetExtraParams((AudioHandle)render, keyValueListOne); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValueOne, listLenth); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_STREQ(keyValueListOneExp, keyValueListValueOne); + ret = render->attr.SetExtraParams((AudioHandle)render, keyValueListTwo); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValueTwo, listLenth); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_STREQ(keyValueListTwoExp, keyValueListValueTwo); + ret = render->attr.SetExtraParams((AudioHandle)render, keyValueListThr); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValueThr, listLenth); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_STREQ(keyValueListThrExp, keyValueListValueThr); + ret = render->attr.SetExtraParams((AudioHandle)render, keyValueListFour); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValueFour, listLenth); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_STREQ(keyValueListFourExp, keyValueListValueFour); + ret = render->control.Stop((AudioHandle)render); + EXPECT_EQ(HDF_SUCCESS, ret); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderSetExtraParams API via setting keyvaluelist to a value outside the range + * @tc.number SUB_Audio_HDI_RenderSetExtraParams_0003 + * @tc.desc Test RenderSetExtraParams interface,return -1 if the Keyvaluelist is a value out of range + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = {}; + struct AudioRender *render = nullptr; + char keyValueList[] = "attr-para=abc;"; + + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = ret = render->attr.SetExtraParams((AudioHandle)render, keyValueList); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderSetExtraParams API via adding parameters to keyvaluelist + * @tc.number SUB_Audio_HDI_RenderSetExtraParams_0004 + * @tc.desc Test RenderSetExtraParams interface,return -1 if adding parameters to keyvaluelist + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_0004, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = {}; + struct AudioRender *render = nullptr; + char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000;\ +attr-para=123"; + + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = render->attr.SetExtraParams((AudioHandle)render, keyValueList); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderSetExtraParams API via setting ExtraParams When the key is the same and the value is + different + * @tc.number SUB_Audio_HDI_RenderSetExtraParams_0005 + * @tc.desc Test RenderSetExtraParams interface,return 0 if set ExtraParams When the key is the same and the value + is different + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_0005, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = {}; + struct AudioRender *render = nullptr; + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + char keyValueList[] = "attr-sampling-rate=48000;attr-sampling-rate=96000;"; + char keyValueListExp[] = "attr-route=0;attr-format=16;attr-channels=2;attr-frame-count=4096;\ +attr-sampling-rate=96000"; + char keyValueListValue[256] = {}; + int32_t listLenth = 256; + + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = render->attr.SetExtraParams((AudioHandle)render, keyValueList); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValue, listLenth); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_STREQ(keyValueListExp, keyValueListValue); + + ret = render->control.Stop((AudioHandle)render); + EXPECT_EQ(HDF_SUCCESS, ret); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderSetExtraParams API via setting the parameter in keyvaluelist as an abnormal value + * @tc.number SUB_Audio_HDI_RenderSetExtraParams_0006 + * @tc.desc Test RenderSetExtraParams interface,return -1 if Set the parameter in keyvaluelist as an abnormal value + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_0006, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = {}; + struct AudioRender *render = nullptr; + char attrSamplingRateError[] = "attr-sampling-rate=1234567;"; + char attrChannelsError[] = "attr-channels=3;"; + char attrFrameCountError[] = "attr-frame-count=111111111111111111111;"; + char attrRouteError[] = "attr-route=5;"; + char attrFormateError[] = "attr-formate=12;"; + + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = render->attr.SetExtraParams((AudioHandle)render, attrSamplingRateError); + EXPECT_EQ(HDF_FAILURE, ret); + ret = render->attr.SetExtraParams((AudioHandle)render, attrChannelsError); + EXPECT_EQ(HDF_FAILURE, ret); + ret = render->attr.SetExtraParams((AudioHandle)render, attrFrameCountError); + EXPECT_EQ(HDF_FAILURE, ret); + ret = render->attr.SetExtraParams((AudioHandle)render, attrRouteError); + EXPECT_EQ(HDF_FAILURE, ret); + ret = render->attr.SetExtraParams((AudioHandle)render, attrFormateError); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderSetExtraParams API via setting the parameter render is nullptr + * @tc.number SUB_Audio_HDI_RenderSetExtraParams_0007 + * @tc.desc Test RenderSetExtraParams interface,return -1 if set the parameter render is nullptr + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_0007, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = {}; + struct AudioRender *render = nullptr; + struct AudioRender *renderNull = nullptr; + char keyValueList[] = "attr-format=2;"; + + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = render->attr.SetExtraParams((AudioHandle)renderNull, keyValueList); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderSetExtraParams API via setting the format of ExtraParams is nullptr + * @tc.number SUB_Audio_HDI_RenderSetExtraParams_0008 + * @tc.desc Test RenderSetExtraParams interface,return -1 if set the format of ExtraParams is nullptr + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_0008, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = {}; + struct AudioRender *render = nullptr; + char keyValueListNull[] = "attr-format=;"; + + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = render->attr.SetExtraParams((AudioHandle)render, keyValueListNull); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderGetExtraParams API via legal input + * @tc.number SUB_Audio_HDI_RenderGetExtraParams_0001 + * @tc.desc Test RenderGetExtraParams interface,return 0 if the RenderGetExtraParams was obtained successfully + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetExtraParams_0001, TestSize.Level1) +{ + int32_t ret = -1; + uint64_t count = 0; + struct AudioAdapter *adapter = {}; + struct AudioRender *render = nullptr; + struct AudioSampleAttributes attrsValue = {}; + char keyValueList[] = "attr-format=24;"; + char keyValueListExp[] = "attr-route=0;attr-format=24;attr-channels=2;attr-frame-count=4096;\ +attr-sampling-rate=48000"; + char keyValueListValue[256] = {}; + int32_t listLenth = 256; + int32_t formatExp = 3; + uint32_t sampleRateExp = 48000; + uint32_t channelCountExp = 2; + uint32_t frameCountExp = 4096; + + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = render->attr.SetExtraParams((AudioHandle)render, keyValueList); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValue, listLenth); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_STREQ(keyValueListExp, keyValueListValue); + + ret = render->attr.GetSampleAttributes(render, &attrsValue); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(formatExp, attrsValue.format); + EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); + EXPECT_EQ(channelCountExp, attrsValue.channelCount); + ret = render->attr.GetFrameCount(render, &count); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(count, frameCountExp); + + ret = render->control.Stop((AudioHandle)render); + EXPECT_EQ(HDF_SUCCESS, ret); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderGetExtraParams API via setting the parameter render is nullptr + * @tc.number SUB_Audio_HDI_RenderGetExtraParams_0002 + * @tc.desc Test RenderGetExtraParams interface,return -1 if set the parameter render is nullptr + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetExtraParams_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = {}; + struct AudioRender *render = nullptr; + struct AudioRender *renderNull = nullptr; + char keyValueList[] = "attr-format=32;"; + char keyValueListValue[256] = {}; + int32_t listLenth = 256; + + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = render->attr.SetExtraParams((AudioHandle)render, keyValueList); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->attr.GetExtraParams((AudioHandle)renderNull, keyValueListValue, listLenth); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderGetExtraParams API via setting listlength to be less than the actual length + * @tc.number SUB_Audio_HDI_RenderGetExtraParams_0003 + * @tc.desc Test RenderGetExtraParams interface,return -1 if set listlength to be less than the actual length + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetExtraParams_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = {}; + struct AudioRender *render = nullptr; + char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000;"; + char keyValueListValue[256] = {}; + int32_t listLenth = 8; + + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = render->attr.SetExtraParams((AudioHandle)render, keyValueList); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValue, listLenth); EXPECT_EQ(HDF_FAILURE, ret); adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); } +#endif } \ No newline at end of file diff --git a/audio/test/systemtest/hdi/render/src/audio_hdirender_control_test.cpp b/audio/test/systemtest/hdi/render/src/audio_hdirender_control_test.cpp index 5ebef75232..e1d317b515 100755 --- a/audio/test/systemtest/hdi/render/src/audio_hdirender_control_test.cpp +++ b/audio/test/systemtest/hdi/render/src/audio_hdirender_control_test.cpp @@ -41,10 +41,8 @@ using namespace testing::ext; using namespace HMOS::Audio; namespace { -const string AUDIO_FILE = "//bin/audiorendertest.wav"; -const string ADAPTER_NAME = "hdmi"; -const string ADAPTER_NAME2 = "usb"; -const string ADAPTER_NAME3 = "internal"; +const string ADAPTER_NAME_USB = "usb"; +const string ADAPTER_NAME_INTERNAL = "internal"; class AudioHdiRenderControlTest : public testing::Test { public: @@ -52,129 +50,75 @@ public: static void TearDownTestCase(void); void SetUp(); void TearDown(); - struct AudioManager *(*GetAudioManager)() = nullptr; - void *handleSo = nullptr; - int32_t GetLoadAdapter(struct AudioManager manager, enum AudioPortDirection portType, - const string adapterName, struct AudioAdapter **adapter, struct AudioPort& audioPort) const; - int32_t AudioCreateRender(enum AudioPortPin pins, struct AudioManager manager, struct AudioAdapter *adapter, - const struct AudioPort renderPort, struct AudioRender **render) const; - int32_t AudioRenderStart(const string path, struct AudioRender *render) const; + static TestAudioManager *(*GetAudioManager)(); + static void *handleSo; +#ifdef AUDIO_MPI_SO + static int32_t (*SdkInit)(); + static void (*SdkExit)(); + static void *sdkSo; +#endif }; -void AudioHdiRenderControlTest::SetUpTestCase(void) {} +TestAudioManager *(*AudioHdiRenderControlTest::GetAudioManager)() = nullptr; +void *AudioHdiRenderControlTest::handleSo = nullptr; +#ifdef AUDIO_MPI_SO + int32_t (*AudioHdiRenderControlTest::SdkInit)() = nullptr; + void (*AudioHdiRenderControlTest::SdkExit)() = nullptr; + void *AudioHdiRenderControlTest::sdkSo = nullptr; +#endif -void AudioHdiRenderControlTest::TearDownTestCase(void) {} - -void AudioHdiRenderControlTest::SetUp(void) +void AudioHdiRenderControlTest::SetUpTestCase(void) { - char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; - handleSo = dlopen(resolvedPath, RTLD_LAZY); - if (handleSo == nullptr) { +#ifdef AUDIO_MPI_SO + char sdkResolvedPath[] = "//system/lib/libhdi_audio_interface_lib_render.z.so"; + sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY); + if (sdkSo == nullptr) { return; } - GetAudioManager = (struct AudioManager* (*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); - if (GetAudioManager == nullptr) { + SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit")); + if (SdkInit == nullptr) { return; } -} - -void AudioHdiRenderControlTest::TearDown(void) -{ - if (GetAudioManager != nullptr) { - GetAudioManager = nullptr; - } -} - -int32_t AudioHdiRenderControlTest::GetLoadAdapter(struct AudioManager manager, enum AudioPortDirection portType, - const string adapterName, struct AudioAdapter **adapter, struct AudioPort& audioPort) const -{ - int32_t ret = -1; - int size = 0; - struct AudioAdapterDescriptor *desc = nullptr; - struct AudioAdapterDescriptor *descs = nullptr; - if (adapter == nullptr) { - return HDF_FAILURE; - } - ret = manager.GetAllAdapters(&manager, &descs, &size); - if (ret < 0 || descs == nullptr || size == 0) { - return HDF_FAILURE; - } else { - int index = SwitchAdapter(descs, adapterName, portType, audioPort, size); - if (index < 0) { - return HDF_FAILURE; - } else { - desc = &descs[index]; - } - } - if (desc == nullptr) { - return HDF_FAILURE; - } else { - ret = manager.LoadAdapter(&manager, desc, adapter); - } - if (ret < 0 || adapter == nullptr) { - return HDF_FAILURE; - } - return HDF_SUCCESS; -} -int32_t AudioHdiRenderControlTest::AudioCreateRender(enum AudioPortPin pins, struct AudioManager manager, - struct AudioAdapter *adapter, const struct AudioPort renderPort, struct AudioRender **render) const -{ - int32_t ret = -1; - struct AudioSampleAttributes attrs = {}; - struct AudioDeviceDescriptor devDesc = {}; - if (adapter == nullptr || adapter->CreateRender == nullptr || render == nullptr) { - return HDF_FAILURE; - } - ret = InitAttrs(attrs); - if (ret < 0) { - return HDF_FAILURE; + SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit")); + if (SdkExit == nullptr) { + return; } - ret = InitDevDesc(devDesc, renderPort.portId, pins); - if (ret < 0) { - return HDF_FAILURE; + SdkInit(); +#endif + handleSo = dlopen(RESOLVED_PATH.c_str(), RTLD_LAZY); + if (handleSo == nullptr) { + return; } - ret = adapter->CreateRender(adapter, &devDesc, &attrs, render); - if (ret < 0 || *render == nullptr) { - manager.UnloadAdapter(&manager, adapter); - return HDF_FAILURE; + GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str())); + if (GetAudioManager == nullptr) { + return; } - return HDF_SUCCESS; } -int32_t AudioHdiRenderControlTest::AudioRenderStart(const string path, struct AudioRender *render) const + +void AudioHdiRenderControlTest::TearDownTestCase(void) { - int32_t ret = -1; - struct AudioSampleAttributes attrs = {}; - struct AudioHeadInfo headInfo = {}; - if (render == nullptr) { - return HDF_FAILURE; - } - ret = InitAttrs(attrs); - if (ret < 0) { - return HDF_FAILURE; - } - char absPath[PATH_MAX] = {0}; - if (realpath(path.c_str(), absPath) == nullptr) { - printf("path is not exist"); - return HDF_FAILURE; +#ifdef AUDIO_MPI_SO + SdkExit(); + if (sdkSo != nullptr) { + dlclose(sdkSo); + sdkSo = nullptr; } - FILE *file = fopen(absPath, "rb"); - if (file == nullptr) { - return HDF_FAILURE; + if (SdkInit != nullptr) { + SdkInit = nullptr; } - ret = WavHeadAnalysis(headInfo, file, attrs); - if (ret < 0) { - fclose(file); - return HDF_FAILURE; + if (SdkExit != nullptr) { + SdkExit = nullptr; } - ret = FrameStart(headInfo, render, file, attrs); - if (ret < 0) { - fclose(file); - return HDF_FAILURE; +#endif + if (GetAudioManager != nullptr) { + GetAudioManager = nullptr; } - fclose(file); - return HDF_SUCCESS; } +void AudioHdiRenderControlTest::SetUp(void) {} + +void AudioHdiRenderControlTest::TearDown(void) {} + /** * @tc.name Test AudioRenderStart API via legal input * @tc.number SUB_Audio_HDI_RenderStart_0001 @@ -184,30 +128,22 @@ int32_t AudioHdiRenderControlTest::AudioRenderStart(const string path, struct Au HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStart_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; + enum AudioPortPin pins = PIN_OUT_SPEAKER; ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); + ret = render->control.Start((AudioHandle)render); + EXPECT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } else { - ret = render->control.Start((AudioHandle)render); - EXPECT_EQ(HDF_SUCCESS, ret); - - ret = render->control.Stop((AudioHandle)render); - EXPECT_EQ(HDF_SUCCESS, ret); - - adapter->DestroyRender(adapter, render); - manager.UnloadAdapter(&manager, adapter); - } + ret = render->control.Stop((AudioHandle)render); + EXPECT_EQ(HDF_SUCCESS, ret); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); } /** * @tc.name Test AudioRenderStart API via setting the incoming parameter handle is nullptr @@ -218,28 +154,21 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStart_0001, TestSize.Lev HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStart_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; + enum AudioPortPin pins = PIN_OUT_SPEAKER; struct AudioRender *render = nullptr; struct AudioRender *renderNull = nullptr; ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); + ret = render->control.Start((AudioHandle)renderNull); + EXPECT_EQ(HDF_FAILURE, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } else { - ret = render->control.Start((AudioHandle)renderNull); - EXPECT_EQ(HDF_FAILURE, ret); - - adapter->DestroyRender(adapter, render); - manager.UnloadAdapter(&manager, adapter); - } + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); } /** * @tc.name Test AudioRenderStart API via the interface is called twice in a row @@ -250,28 +179,22 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStart_0002, TestSize.Lev HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStart_0003, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; + enum AudioPortPin pins = PIN_OUT_SPEAKER; struct AudioRender *render = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = render->control.Start((AudioHandle)render); EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->control.Start((AudioHandle)render); EXPECT_EQ(HDF_FAILURE, ret); - render->control.Stop((AudioHandle)render); + ret = render->control.Stop((AudioHandle)render); + EXPECT_EQ(HDF_SUCCESS, ret); adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); } @@ -284,30 +207,22 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStart_0003, TestSize.Lev HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStop_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; + enum AudioPortPin pins = PIN_OUT_SPEAKER; struct AudioRender *render = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); + ret = render->control.Start((AudioHandle)render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->control.Stop((AudioHandle)render); + EXPECT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } else { - ret = render->control.Start((AudioHandle)render); - EXPECT_EQ(HDF_SUCCESS, ret); - - ret = render->control.Stop((AudioHandle)render); - EXPECT_EQ(HDF_SUCCESS, ret); - - adapter->DestroyRender(adapter, render); - manager.UnloadAdapter(&manager, adapter); - } + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); } /** * @tc.name Test AudioRenderStop API via the render does not start and stop only @@ -318,26 +233,20 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStop_0001, TestSize.Leve HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStop_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; + enum AudioPortPin pins = PIN_OUT_SPEAKER; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } else { - ret = render->control.Stop((AudioHandle)render); - EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret); - - adapter->DestroyRender(adapter, render); - manager.UnloadAdapter(&manager, adapter); - } + ret = render->control.Stop((AudioHandle)render); + EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); } /** * @tc.name Test RenderStop API via the interface is called twice in a row @@ -348,32 +257,24 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStop_0002, TestSize.Leve HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStop_0003, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; + enum AudioPortPin pins = PIN_OUT_SPEAKER; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } else { - ret = render->control.Start((AudioHandle)render); - EXPECT_EQ(HDF_SUCCESS, ret); - - ret = render->control.Stop((AudioHandle)render); - EXPECT_EQ(HDF_SUCCESS, ret); - - ret = render->control.Stop((AudioHandle)render); - EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret); - - adapter->DestroyRender(adapter, render); - manager.UnloadAdapter(&manager, adapter); - } + ret = render->control.Start((AudioHandle)render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->control.Stop((AudioHandle)render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->control.Stop((AudioHandle)render); + EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); } /** * @tc.name Test RenderStop API via setting the incoming parameter handle is nullptr @@ -384,31 +285,25 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStop_0003, TestSize.Leve HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStop_0004, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; + enum AudioPortPin pins = PIN_OUT_SPEAKER; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioRender *renderNull = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } else { - ret = render->control.Start((AudioHandle)render); - EXPECT_EQ(HDF_SUCCESS, ret); - - ret = render->control.Stop((AudioHandle)renderNull); - EXPECT_EQ(HDF_FAILURE, ret); - - render->control.Stop((AudioHandle)render); - adapter->DestroyRender(adapter, render); - manager.UnloadAdapter(&manager, adapter); - } + ret = render->control.Start((AudioHandle)render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->control.Stop((AudioHandle)renderNull); + EXPECT_EQ(HDF_FAILURE, ret); + + ret = render->control.Stop((AudioHandle)render); + EXPECT_EQ(HDF_SUCCESS, ret); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); } /** * @tc.name Test RenderPause API via legal input @@ -419,29 +314,19 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStop_0004, TestSize.Leve HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderPause_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - ret = AudioRenderStart(AUDIO_FILE, render); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->control.Pause((AudioHandle)render); EXPECT_EQ(HDF_SUCCESS, ret); - render->control.Stop((AudioHandle)render); + ret = render->control.Stop((AudioHandle)render); + EXPECT_EQ(HDF_SUCCESS, ret); adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); } @@ -455,26 +340,15 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderPause_0002, TestSize.Lev { int32_t ret = -1; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; + TestAudioManager manager = {}; + manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - ret = AudioRenderStart(AUDIO_FILE, render); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->control.Pause((AudioHandle)render); EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->control.Pause((AudioHandle)render); EXPECT_EQ(HDF_FAILURE, ret); @@ -483,27 +357,23 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderPause_0002, TestSize.Lev manager.UnloadAdapter(&manager, adapter); } /** -* @tc.name Test AudioRenderPause API via the render is paused before Started. +* @tc.name Test AudioRenderPause API via the render is paused after created. * @tc.number SUB_Audio_HDI_RenderPause_0003 -* @tc.desc Test AudioRenderPause interface,return -1 if the render is paused before Started. +* @tc.desc Test AudioRenderPause interface,return -1 if the render is paused after created. * @tc.author: Xuhuandi */ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderPause_0003, TestSize.Level1) { int32_t ret = -1; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; + enum AudioPortPin pins = PIN_OUT_SPEAKER; + manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->control.Pause((AudioHandle)render); EXPECT_EQ(HDF_FAILURE, ret); adapter->DestroyRender(adapter, render); @@ -518,33 +388,23 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderPause_0003, TestSize.Lev HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderPause_0004, TestSize.Level1) { int32_t ret = -1; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; + manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - ret = AudioRenderStart(AUDIO_FILE, render); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->control.Pause((AudioHandle)render); EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->control.Resume((AudioHandle)render); EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->control.Pause((AudioHandle)render); EXPECT_EQ(HDF_SUCCESS, ret); - render->control.Stop((AudioHandle)render); + ret = render->control.Stop((AudioHandle)render); + EXPECT_EQ(HDF_SUCCESS, ret); adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); } @@ -558,31 +418,47 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderPause_0005, TestSize.Lev { int32_t ret = -1; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; + TestAudioManager manager = {}; + manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - ret = AudioRenderStart(AUDIO_FILE, render); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->control.Stop((AudioHandle)render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = render->control.Pause((AudioHandle)render); EXPECT_EQ(HDF_FAILURE, ret); adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); } +/** +* @tc.name Test RenderPause API via setting the incoming parameter handle is nullptr +* @tc.number SUB_Audio_HDI_RenderPause_0006 +* @tc.desc Test RenderPause interface, return -1 if the incoming parameter handle is nullptr +* @tc.author: Xuhuandi +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderPause_0006, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = nullptr; + struct AudioRender *render = nullptr; + struct AudioRender *renderNull = nullptr; + TestAudioManager manager = {}; + + manager = *GetAudioManager(); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = render->control.Pause((AudioHandle)renderNull); + EXPECT_EQ(HDF_FAILURE, ret); + + ret = render->control.Stop((AudioHandle)render); + EXPECT_EQ(HDF_SUCCESS, ret); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} /** * @tc.name Test RenderResume API via the render is resumed after started * @tc.number SUB_Audio_HDI_RenderResume_0001 @@ -593,25 +469,17 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderResume_0001, TestSize.Le { int32_t ret = -1; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; + TestAudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioRenderStart(AUDIO_FILE, render); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->control.Resume((AudioHandle)render); EXPECT_EQ(HDF_FAILURE, ret); - render->control.Stop((AudioHandle)render); + ret = render->control.Stop((AudioHandle)render); + EXPECT_EQ(HDF_SUCCESS, ret); adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); } @@ -625,24 +493,14 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderResume_0002, TestSize.Le { int32_t ret = -1; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; + TestAudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioRenderStart(AUDIO_FILE, render); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->control.Stop((AudioHandle)render); EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->control.Resume((AudioHandle)render); EXPECT_EQ(HDF_FAILURE, ret); @@ -659,29 +517,19 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderResume_0003, TestSize.Le { int32_t ret = -1; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; + TestAudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioRenderStart(AUDIO_FILE, render); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->control.Pause((AudioHandle)render); EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->control.Resume((AudioHandle)render); EXPECT_EQ(HDF_SUCCESS, ret); - render->control.Stop((AudioHandle)render); + ret = render->control.Stop((AudioHandle)render); + EXPECT_EQ(HDF_SUCCESS, ret); adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); } @@ -695,32 +543,21 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderResume_0004, TestSize.Le { int32_t ret = -1; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; + TestAudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - ret = AudioRenderStart(AUDIO_FILE, render); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->control.Pause((AudioHandle)render); EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->control.Resume((AudioHandle)render); EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->control.Resume((AudioHandle)render); EXPECT_EQ(HDF_FAILURE, ret); - render->control.Stop((AudioHandle)render); + ret = render->control.Stop((AudioHandle)render); + EXPECT_EQ(HDF_SUCCESS, ret); adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); } @@ -734,68 +571,48 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderResume_0005, TestSize.Le { int32_t ret = -1; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; + TestAudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioRenderStart(AUDIO_FILE, render); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->control.Pause((AudioHandle)render); EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->control.Resume((AudioHandle)render); EXPECT_EQ(HDF_SUCCESS, ret); - - ret = AudioRenderStart(AUDIO_FILE, render); + ret = render->control.Start((AudioHandle)render); EXPECT_EQ(HDF_FAILURE, ret); - render->control.Stop((AudioHandle)render); + ret = render->control.Stop((AudioHandle)render); + EXPECT_EQ(HDF_SUCCESS, ret); adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); } /** - * @tc.name Test RenderResume API via the render is resumed before stopped - * @tc.number SUB_Audio_HDI_RenderResume_0006 - * @tc.desc test HDI RenderResume interface,return 0 if the render is resumed before stopped - * @tc.author: Xuhuandi +* @tc.name Test RenderResume API via setting the incoming parameter handle is nullptr +* @tc.number SUB_Audio_HDI_RenderResume_0007 +* @tc.desc Test RenderResume interface, return -1 if the incoming parameter handle is nullptr +* @tc.author: Xuhuandi */ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderResume_0006, TestSize.Level1) { int32_t ret = -1; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; + struct AudioRender *renderNull = nullptr; + TestAudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioRenderStart(AUDIO_FILE, render); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->control.Pause((AudioHandle)render); EXPECT_EQ(HDF_SUCCESS, ret); - - ret = render->control.Resume((AudioHandle)render); - EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->control.Resume((AudioHandle)renderNull); + EXPECT_EQ(HDF_FAILURE, ret); ret = render->control.Stop((AudioHandle)render); EXPECT_EQ(HDF_SUCCESS, ret); - adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); } @@ -809,16 +626,13 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0001, TestSize.Le { int32_t ret = -1; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; + enum AudioPortPin pins = PIN_OUT_SPEAKER; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - EXPECT_EQ(HDF_SUCCESS, ret); adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); } @@ -831,28 +645,22 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0001, TestSize.Le HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_AudioCreateRender_0002, TestSize.Level1) { int32_t ret = -1; + enum AudioPortPin pins = PIN_OUT_SPEAKER; struct AudioAdapter *adapter = nullptr; struct AudioAdapter *adapter2 = nullptr; - struct AudioPort renderPort = {}; - struct AudioPort renderPort2 = {}; struct AudioRender *render = nullptr; struct AudioRender *render2 = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); + TestAudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - EXPECT_EQ(HDF_SUCCESS, ret); adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter2, renderPort2); - ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter2, renderPort2, &render2); - EXPECT_EQ(HDF_SUCCESS, ret); - adapter->DestroyRender(adapter2, render2); + ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter2, &render2); + ASSERT_EQ(HDF_SUCCESS, ret); + adapter2->DestroyRender(adapter2, render2); manager.UnloadAdapter(&manager, adapter2); } /** @@ -865,14 +673,13 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0003, TestSize.Le { int32_t ret = -1; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; + struct AudioPort renderPort = {}; struct AudioSampleAttributes attrs = {}; struct AudioDeviceDescriptor devDesc = {}; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, renderPort); ASSERT_EQ(HDF_SUCCESS, ret); InitAttrs(attrs); @@ -893,15 +700,14 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0004, TestSize.Le { int32_t ret = -1; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioSampleAttributes attrs = {}; struct AudioDeviceDescriptor devDesc = {}; + struct AudioPort renderPort = {}; uint32_t channelCountErr = 5; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, renderPort); ASSERT_EQ(HDF_SUCCESS, ret); InitAttrs(attrs); @@ -928,15 +734,14 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0005, TestSize.Le { int32_t ret = -1; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioAdapter *adapterNull = nullptr; + struct AudioPort renderPort = {}; struct AudioSampleAttributes attrs = {}; struct AudioDeviceDescriptor devDesc = {}; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, renderPort); ASSERT_EQ(HDF_SUCCESS, ret); InitAttrs(attrs); @@ -957,15 +762,14 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0005, TestSize.Le HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0006, TestSize.Level1) { int32_t ret = -1; + struct AudioRender *render = nullptr; struct AudioAdapter *adapter = nullptr; struct AudioPort renderPort = {}; - struct AudioRender *render = nullptr; struct AudioSampleAttributes attrs = {}; struct AudioDeviceDescriptor *devDescNull = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, renderPort); ASSERT_EQ(HDF_SUCCESS, ret); InitAttrs(attrs); @@ -985,15 +789,14 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0006, TestSize.Le HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0007, TestSize.Level1) { int32_t ret = -1; - struct AudioAdapter *adapter = nullptr; struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; struct AudioSampleAttributes *attrsNull = nullptr; struct AudioDeviceDescriptor devDesc = {}; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, renderPort); ASSERT_EQ(HDF_SUCCESS, ret); InitDevDesc(devDesc, renderPort.portId, PIN_OUT_SPEAKER); @@ -1014,14 +817,13 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0008, TestSize.Le { int32_t ret = -1; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender **renderNull = nullptr; + struct AudioPort renderPort = {}; struct AudioSampleAttributes attrs = {}; struct AudioDeviceDescriptor devDesc = {}; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, renderPort); ASSERT_EQ(HDF_SUCCESS, ret); InitAttrs(attrs); @@ -1043,15 +845,13 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0009, TestSize.Le { int32_t ret = -1; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioSampleAttributes attrs = {}; struct AudioDeviceDescriptor devDesc = {}; - + struct AudioPort renderPort = {}; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, renderPort); ASSERT_EQ(HDF_SUCCESS, ret); ret = InitAttrs(attrs); @@ -1069,7 +869,6 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0009, TestSize.Le manager.UnloadAdapter(&manager, adapter); } - /** * @tc.name Test AudioDestroyRender API via legal input. * @tc.number SUB_Audio_HDI_DestroyRender_0001 @@ -1080,18 +879,12 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_DestroyRender_0001, TestSize.L { int32_t ret = -1; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; - struct AudioManager manager = *GetAudioManager(); + enum AudioPortPin pins = PIN_OUT_SPEAKER; + TestAudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = adapter->DestroyRender(adapter, render); EXPECT_EQ(HDF_SUCCESS, ret); @@ -1106,20 +899,14 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_DestroyRender_0001, TestSize.L HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_DestroyRender_0002, TestSize.Level1) { int32_t ret = -1; + enum AudioPortPin pins = PIN_OUT_SPEAKER; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioRender *renderNull = nullptr; - struct AudioManager manager = *GetAudioManager(); + TestAudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = adapter->DestroyRender(adapter, renderNull); EXPECT_EQ(HDF_FAILURE, ret); @@ -1135,27 +922,16 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_DestroyRender_0002, TestSize.L HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderFlush_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - ret = AudioRenderStart(AUDIO_FILE, render); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->control.Stop((AudioHandle)render); EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->control.Flush((AudioHandle)render); EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); @@ -1165,37 +941,28 @@ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderFlush_0001, TestSize.Lev /** * @tc.name Test RenderFlush that the data in the buffer is flushed when handle is nullptr after paused * @tc.number SUB_Audio_HDI_RenderFlush_0002 - * @tc.desc Test RenderFlush, return -2 if the data in the buffer is flushed when handle is nullptr after paused + * @tc.desc Test RenderFlush, return -1 if the data in the buffer is flushed when handle is nullptr after paused * @tc.author: tiansuli */ HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderFlush_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; + TestAudioManager manager = {}; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioRender *renderNull = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + ASSERT_NE(nullptr, GetAudioManager); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - ret = AudioRenderStart(AUDIO_FILE, render); - EXPECT_EQ(HDF_SUCCESS, ret); ret = render->control.Pause((AudioHandle)render); EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->control.Flush((AudioHandle)renderNull); EXPECT_EQ(HDF_FAILURE, ret); - render->control.Stop((AudioHandle)render); + ret = render->control.Stop((AudioHandle)render); + EXPECT_EQ(HDF_SUCCESS, ret); adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); } diff --git a/audio/test/systemtest/hdi/render/src/audio_hdirender_scene_test.cpp b/audio/test/systemtest/hdi/render/src/audio_hdirender_scene_test.cpp index 37264cc961..67a2efdf1d 100755 --- a/audio/test/systemtest/hdi/render/src/audio_hdirender_scene_test.cpp +++ b/audio/test/systemtest/hdi/render/src/audio_hdirender_scene_test.cpp @@ -41,10 +41,8 @@ using namespace testing::ext; using namespace HMOS::Audio; namespace { -const string AUDIO_FILE = "//bin/audiorendertest.wav"; -const string ADAPTER_NAME = "hdmi"; -const string ADAPTER_NAME2 = "usb"; -const string ADAPTER_NAME3 = "internal"; +const string ADAPTER_NAME_USB = "usb"; +const string ADAPTER_NAME_INTERNAL = "internal"; class AudioHdiRenderSceneTest : public testing::Test { public: @@ -52,234 +50,76 @@ public: static void TearDownTestCase(void); void SetUp(); void TearDown(); - struct AudioManager *(*GetAudioManager)() = nullptr; - void *handleSo = nullptr; - int32_t GetLoadAdapter(struct AudioManager manager, enum AudioPortDirection portType, - const string adapterName, struct AudioAdapter **adapter, struct AudioPort& audioPort) const; - int32_t AudioCreateRender(enum AudioPortPin pins, struct AudioManager manager, struct AudioAdapter *adapter, - const struct AudioPort renderPort, struct AudioRender **render) const; - int32_t AudioRenderStart(const string path, struct AudioRender *render) const; - static int32_t GetLoadAdapterAudioPara(struct PrepareAudioPara& audiopara); - static int32_t PlayAudioFile(struct PrepareAudioPara& audiopara); + static TestAudioManager *(*GetAudioManager)(); + static void *handleSo; +#ifdef AUDIO_MPI_SO + static int32_t (*SdkInit)(); + static void (*SdkExit)(); + static void *sdkSo; +#endif }; using THREAD_FUNC = void *(*)(void *); -void AudioHdiRenderSceneTest::SetUpTestCase(void) {} +TestAudioManager *(*AudioHdiRenderSceneTest::GetAudioManager)() = nullptr; +void *AudioHdiRenderSceneTest::handleSo = nullptr; +#ifdef AUDIO_MPI_SO + int32_t (*AudioHdiRenderSceneTest::SdkInit)() = nullptr; + void (*AudioHdiRenderSceneTest::SdkExit)() = nullptr; + void *AudioHdiRenderSceneTest::sdkSo = nullptr; +#endif -void AudioHdiRenderSceneTest::TearDownTestCase(void) {} - -void AudioHdiRenderSceneTest::SetUp(void) +void AudioHdiRenderSceneTest::SetUpTestCase(void) { - char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; - handleSo = dlopen(resolvedPath, RTLD_LAZY); - if (handleSo == nullptr) { +#ifdef AUDIO_MPI_SO + char sdkResolvedPath[] = "//system/lib/libhdi_audio_interface_lib_render.z.so"; + sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY); + if (sdkSo == nullptr) { return; } - GetAudioManager = (struct AudioManager* (*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); - if (GetAudioManager == nullptr) { + SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit")); + if (SdkInit == nullptr) { return; } -} - -void AudioHdiRenderSceneTest::TearDown(void) -{ - if (GetAudioManager != nullptr) { - GetAudioManager = nullptr; - } -} - -int32_t AudioHdiRenderSceneTest::GetLoadAdapter(struct AudioManager manager, enum AudioPortDirection portType, - const string adapterName, struct AudioAdapter **adapter, struct AudioPort& audioPort) const -{ - int32_t ret = -1; - int size = 0; - struct AudioAdapterDescriptor *desc = nullptr; - struct AudioAdapterDescriptor *descs = nullptr; - if (adapter == nullptr) { - return HDF_FAILURE; - } - ret = manager.GetAllAdapters(&manager, &descs, &size); - if (ret < 0 || descs == nullptr || size == 0) { - return HDF_FAILURE; - } else { - int index = SwitchAdapter(descs, adapterName, portType, audioPort, size); - if (index < 0) { - return HDF_FAILURE; - } else { - desc = &descs[index]; - } - } - if (desc == nullptr) { - return HDF_FAILURE; - } else { - ret = manager.LoadAdapter(&manager, desc, adapter); - } - if (ret < 0 || adapter == nullptr) { - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t AudioHdiRenderSceneTest::AudioCreateRender(enum AudioPortPin pins, struct AudioManager manager, - struct AudioAdapter *adapter, const struct AudioPort renderPort, struct AudioRender **render) const -{ - int32_t ret = -1; - struct AudioSampleAttributes attrs = {}; - struct AudioDeviceDescriptor devDesc = {}; - if (adapter == nullptr || adapter->CreateRender == nullptr || render == nullptr) { - return HDF_FAILURE; - } - ret = InitAttrs(attrs); - if (ret < 0) { - return HDF_FAILURE; + SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit")); + if (SdkExit == nullptr) { + return; } - ret = InitDevDesc(devDesc, renderPort.portId, pins); - if (ret < 0) { - return HDF_FAILURE; + SdkInit(); +#endif + handleSo = dlopen(RESOLVED_PATH.c_str(), RTLD_LAZY); + if (handleSo == nullptr) { + return; } - ret = adapter->CreateRender(adapter, &devDesc, &attrs, render); - if (ret < 0 || *render == nullptr) { - manager.UnloadAdapter(&manager, adapter); - return HDF_FAILURE; + GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str())); + if (GetAudioManager == nullptr) { + return; } - return HDF_SUCCESS; } -int32_t AudioHdiRenderSceneTest::AudioRenderStart(const string path, struct AudioRender *render) const +void AudioHdiRenderSceneTest::TearDownTestCase(void) { - int32_t ret = -1; - struct AudioSampleAttributes attrs = {}; - struct AudioHeadInfo headInfo = {}; - - if (render == nullptr) { - return HDF_FAILURE; - } - ret = InitAttrs(attrs); - if (ret < 0) { - return HDF_FAILURE; +#ifdef AUDIO_MPI_SO + SdkExit(); + if (sdkSo != nullptr) { + dlclose(sdkSo); + sdkSo = nullptr; } - char absPath[PATH_MAX] = {0}; - if (realpath(path.c_str(), absPath) == nullptr) { - printf("path is not exist"); - return HDF_FAILURE; + if (SdkInit != nullptr) { + SdkInit = nullptr; } - FILE *file = fopen(absPath, "rb"); - if (file == nullptr) { - return HDF_FAILURE; + if (SdkExit != nullptr) { + SdkExit = nullptr; } - ret = WavHeadAnalysis(headInfo, file, attrs); - if (ret < 0) { - fclose(file); - return HDF_FAILURE; - } - ret = FrameStart(headInfo, render, file, attrs); - if (ret < 0) { - fclose(file); - return HDF_FAILURE; +#endif + if (GetAudioManager != nullptr) { + GetAudioManager = nullptr; } - fclose(file); - return HDF_SUCCESS; } -struct PrepareAudioPara { - struct AudioManager *manager; - enum AudioPortDirection portType; - const char *adapterName; - struct AudioAdapter *adapter; - struct AudioPort audioPort; - void *self; - enum AudioPortPin pins; - const char *path; - struct AudioRender *render; - struct AudioCapture *capture; - struct AudioHeadInfo headInfo; - struct AudioAdapterDescriptor *desc; - struct AudioAdapterDescriptor *descs; - char *frame; - uint64_t requestBytes; - uint64_t replyBytes; - uint64_t fileSize; - struct AudioSampleAttributes attrs; -}; +void AudioHdiRenderSceneTest::SetUp(void) {} -int32_t AudioHdiRenderSceneTest::GetLoadAdapterAudioPara(struct PrepareAudioPara& audiopara) -{ - int32_t ret = -1; - int size = 0; - auto *inst = (AudioHdiRenderSceneTest *)audiopara.self; - if (inst != nullptr && inst->GetAudioManager != nullptr) { - audiopara.manager = inst->GetAudioManager(); - } - if (audiopara.manager == nullptr) { - return HDF_FAILURE; - } - ret = audiopara.manager->GetAllAdapters(audiopara.manager, &audiopara.descs, &size); - if (ret < 0 || audiopara.descs == nullptr || size == 0) { - return HDF_FAILURE; - } else { - int index = SwitchAdapter(audiopara.descs, audiopara.adapterName, - audiopara.portType, audiopara.audioPort, size); - if (index < 0) { - return HDF_FAILURE; - } else { - audiopara.desc = &audiopara.descs[index]; - } - } - if (audiopara.desc == nullptr) { - return HDF_FAILURE; - } else { - ret = audiopara.manager->LoadAdapter(audiopara.manager, audiopara.desc, &audiopara.adapter); - } - if (ret < 0 || audiopara.adapter == nullptr) { - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t AudioHdiRenderSceneTest::PlayAudioFile(struct PrepareAudioPara& audiopara) -{ - int32_t ret = -1; - struct AudioDeviceDescriptor devDesc = {}; - char absPath[PATH_MAX] = {0}; - if (realpath(audiopara.path, absPath) == nullptr) { - printf("path is not exist"); - return HDF_FAILURE; - } - FILE *file = fopen(absPath, "rb"); - if (file == nullptr) { - return HDF_FAILURE; - } - if (audiopara.adapter == nullptr || audiopara.manager == nullptr) { - return HDF_FAILURE; - } - ret = HMOS::Audio::InitAttrs(audiopara.attrs); - if (ret < 0) { - return HDF_FAILURE; - } - if (WavHeadAnalysis(audiopara.headInfo, file, audiopara.attrs) < 0) { - return HDF_FAILURE; - } - - ret = HMOS::Audio::InitDevDesc(devDesc, (&audiopara.audioPort)->portId, audiopara.pins); - if (ret < 0) { - return HDF_FAILURE; - } - ret = audiopara.adapter->CreateRender(audiopara.adapter, &devDesc, &(audiopara.attrs), &audiopara.render); - if (ret < 0 || audiopara.render == nullptr) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - return HDF_FAILURE; - } - ret = HMOS::Audio::FrameStart(audiopara.headInfo, audiopara.render, file, audiopara.attrs); - if (ret == HDF_SUCCESS) { - fclose(file); - } else { - audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); - fclose(file); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} +void AudioHdiRenderSceneTest::TearDown(void) {} /** * @tc.name Test AudioRenderCheckSceneCapability API and check scene's capability @@ -292,19 +132,12 @@ HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0001, int32_t ret = -1; bool supported = false; struct AudioSceneDescriptor scenes = {}; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); + ASSERT_EQ(HDF_SUCCESS, ret); scenes.scene.id = 0; scenes.desc.pins = PIN_OUT_SPEAKER; @@ -326,19 +159,12 @@ HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0002, int32_t ret = -1; bool supported = true; struct AudioSceneDescriptor scenes = {}; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); + ASSERT_EQ(HDF_SUCCESS, ret); scenes.scene.id = 5; scenes.desc.pins = PIN_OUT_SPEAKER; @@ -359,20 +185,13 @@ HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0003, int32_t ret = -1; bool supported = true; struct AudioSceneDescriptor scenes = {}; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; struct AudioRender *renderNull = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); + ASSERT_EQ(HDF_SUCCESS, ret); scenes.scene.id = 0; scenes.desc.pins = PIN_OUT_SPEAKER; @@ -393,19 +212,12 @@ HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0004, int32_t ret = -1; bool supported = true; struct AudioSceneDescriptor *scenes = nullptr; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); + ASSERT_EQ(HDF_SUCCESS, ret); ret = render->scene.CheckSceneCapability(render, scenes, &supported); EXPECT_EQ(HDF_FAILURE, ret); @@ -423,19 +235,12 @@ HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0005, { int32_t ret = -1; struct AudioSceneDescriptor scenes = {}; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); + ASSERT_EQ(HDF_SUCCESS, ret); scenes.scene.id = 0; scenes.desc.pins = PIN_OUT_SPEAKER; @@ -455,32 +260,23 @@ HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0001, Tes { int32_t ret = -1; struct AudioSceneDescriptor scenes = {}; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - + TestAudioManager manager = *GetAudioManager(); scenes.scene.id = 0; scenes.desc.pins = PIN_OUT_SPEAKER; + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = render->scene.SelectScene(render, &scenes); EXPECT_EQ(HDF_SUCCESS, ret); - ret = AudioRenderStart(AUDIO_FILE, render); + ret = AudioRenderStartAndOneFrame(render); EXPECT_EQ(HDF_SUCCESS, ret); ret = render->control.Stop((AudioHandle)render); - EXPECT_EQ(HDF_SUCCESS, ret); - adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); } @@ -494,22 +290,13 @@ HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0002, Tes { int32_t ret = -1; struct AudioSceneDescriptor scenes = {}; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + TestAudioManager manager = {}; + struct AudioAdapter *adapter =nullptr; struct AudioRender *render = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - ret = AudioRenderStart(AUDIO_FILE, render); - EXPECT_EQ(HDF_SUCCESS, ret); + manager = *GetAudioManager(); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); + ASSERT_EQ(HDF_SUCCESS, ret); scenes.scene.id = 0; scenes.desc.pins = PIN_OUT_SPEAKER; @@ -517,8 +304,6 @@ HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0002, Tes EXPECT_EQ(HDF_SUCCESS, ret); ret = render->control.Stop((AudioHandle)render); - EXPECT_EQ(HDF_SUCCESS, ret); - adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); } @@ -532,20 +317,13 @@ HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0003, Tes { int32_t ret = -1; struct AudioSceneDescriptor scenes = {}; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; struct AudioRender *renderNull = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); + ASSERT_EQ(HDF_SUCCESS, ret); scenes.scene.id = 0; scenes.desc.pins = PIN_IN_MIC; @@ -565,19 +343,12 @@ HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0004, Tes { int32_t ret = -1; struct AudioSceneDescriptor *scenes = nullptr; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); + ASSERT_EQ(HDF_SUCCESS, ret); ret = render->scene.SelectScene(render, scenes); EXPECT_EQ(HDF_FAILURE, ret); @@ -595,19 +366,12 @@ HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0005, Tes { int32_t ret = -1; struct AudioSceneDescriptor scenes = {}; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); + ASSERT_EQ(HDF_SUCCESS, ret); scenes.scene.id = 5; scenes.desc.pins = PIN_OUT_HDMI; diff --git a/audio/test/systemtest/hdi/render/src/audio_hdirender_test.cpp b/audio/test/systemtest/hdi/render/src/audio_hdirender_test.cpp index 3a30b7ff01..2337c8d521 100755 --- a/audio/test/systemtest/hdi/render/src/audio_hdirender_test.cpp +++ b/audio/test/systemtest/hdi/render/src/audio_hdirender_test.cpp @@ -41,10 +41,8 @@ using namespace testing::ext; using namespace HMOS::Audio; namespace { -const string AUDIO_FILE = "//bin/audiorendertest.wav"; -const string ADAPTER_NAME = "hdmi"; -const string ADAPTER_NAME2 = "usb"; -const string ADAPTER_NAME3 = "internal"; +const string ADAPTER_NAME_USB = "usb"; +const string ADAPTER_NAME_INTERNAL = "internal"; class AudioHdiRenderTest : public testing::Test { public: @@ -52,155 +50,76 @@ public: static void TearDownTestCase(void); void SetUp(); void TearDown(); - struct AudioManager *(*GetAudioManager)() = nullptr; - void *handleSo = nullptr; - int32_t GetLoadAdapter(struct AudioManager manager, enum AudioPortDirection portType, - const string adapterName, struct AudioAdapter **adapter, struct AudioPort& audioPort) const; - int32_t AudioCreateRender(enum AudioPortPin pins, struct AudioManager manager, struct AudioAdapter *adapter, - const struct AudioPort renderPort, struct AudioRender **render) const; - int32_t AudioRenderStart(const string path, struct AudioRender *render) const; + static TestAudioManager *(*GetAudioManager)(); + static void *handleSo; +#ifdef AUDIO_MPI_SO + static int32_t (*SdkInit)(); + static void (*SdkExit)(); + static void *sdkSo; +#endif static int32_t GetLoadAdapterAudioPara(struct PrepareAudioPara& audiopara); - static int32_t PlayAudioFile(struct PrepareAudioPara& audiopara); }; using THREAD_FUNC = void *(*)(void *); -void AudioHdiRenderTest::SetUpTestCase(void) {} - -void AudioHdiRenderTest::TearDownTestCase(void) {} - -void AudioHdiRenderTest::SetUp(void) +TestAudioManager *(*AudioHdiRenderTest::GetAudioManager)() = nullptr; +void *AudioHdiRenderTest::handleSo = nullptr; +#ifdef AUDIO_MPI_SO + int32_t (*AudioHdiRenderTest::SdkInit)() = nullptr; + void (*AudioHdiRenderTest::SdkExit)() = nullptr; + void *AudioHdiRenderTest::sdkSo = nullptr; +#endif +void AudioHdiRenderTest::SetUpTestCase(void) { - char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; - handleSo = dlopen(resolvedPath, RTLD_LAZY); - if (handleSo == nullptr) { +#ifdef AUDIO_MPI_SO + char sdkResolvedPath[] = "//system/lib/libhdi_audio_interface_lib_render.z.so"; + sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY); + if (sdkSo == nullptr) { return; } - GetAudioManager = (struct AudioManager* (*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); - if (GetAudioManager == nullptr) { + SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit")); + if (SdkInit == nullptr) { return; } -} - -void AudioHdiRenderTest::TearDown(void) -{ - if (GetAudioManager != nullptr) { - GetAudioManager = nullptr; - } -} - -int32_t AudioHdiRenderTest::GetLoadAdapter(struct AudioManager manager, enum AudioPortDirection portType, - const string adapterName, struct AudioAdapter **adapter, struct AudioPort& audioPort) const -{ - int32_t ret = -1; - int size = 0; - struct AudioAdapterDescriptor *desc = nullptr; - struct AudioAdapterDescriptor *descs = nullptr; - if (adapter == nullptr) { - return HDF_FAILURE; - } - ret = manager.GetAllAdapters(&manager, &descs, &size); - if (ret < 0 || descs == nullptr || size == 0) { - return HDF_FAILURE; - } else { - int index = SwitchAdapter(descs, adapterName, portType, audioPort, size); - if (index < 0) { - return HDF_FAILURE; - } else { - desc = &descs[index]; - } + SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit")); + if (SdkExit == nullptr) { + return; } - if (desc == nullptr) { - return HDF_FAILURE; - } else { - ret = manager.LoadAdapter(&manager, desc, adapter); + SdkInit(); +#endif + handleSo = dlopen(RESOLVED_PATH.c_str(), RTLD_LAZY); + if (handleSo == nullptr) { + return; } - if (ret < 0 || adapter == nullptr) { - return HDF_FAILURE; + GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str())); + if (GetAudioManager == nullptr) { + return; } - return HDF_SUCCESS; } -int32_t AudioHdiRenderTest::AudioCreateRender(enum AudioPortPin pins, struct AudioManager manager, - struct AudioAdapter *adapter, const struct AudioPort renderPort, struct AudioRender **render) const +void AudioHdiRenderTest::TearDownTestCase(void) { - int32_t ret = -1; - struct AudioSampleAttributes attrs = {}; - struct AudioDeviceDescriptor devDesc = {}; - if (adapter == nullptr || adapter->CreateRender == nullptr || render == nullptr) { - return HDF_FAILURE; +#ifdef AUDIO_MPI_SO + SdkExit(); + if (sdkSo != nullptr) { + dlclose(sdkSo); + sdkSo = nullptr; } - ret = InitAttrs(attrs); - if (ret < 0) { - return HDF_FAILURE; + if (SdkInit != nullptr) { + SdkInit = nullptr; } - ret = InitDevDesc(devDesc, renderPort.portId, pins); - if (ret < 0) { - return HDF_FAILURE; + if (SdkExit != nullptr) { + SdkExit = nullptr; } - ret = adapter->CreateRender(adapter, &devDesc, &attrs, render); - if (ret < 0 || *render == nullptr) { - manager.UnloadAdapter(&manager, adapter); - return HDF_FAILURE; +#endif + if (GetAudioManager != nullptr) { + GetAudioManager = nullptr; } - return HDF_SUCCESS; } -int32_t AudioHdiRenderTest::AudioRenderStart(const string path, struct AudioRender *render) const -{ - int32_t ret = -1; - struct AudioSampleAttributes attrs = {}; - struct AudioHeadInfo headInfo = {}; - if (render == nullptr) { - return HDF_FAILURE; - } - ret = InitAttrs(attrs); - if (ret < 0) { - return HDF_FAILURE; - } - char absPath[PATH_MAX] = {0}; - if (realpath(path.c_str(), absPath) == nullptr) { - printf("path is not exist"); - return HDF_FAILURE; - } - FILE *file = fopen(absPath, "rb"); - if (file == nullptr) { - return HDF_FAILURE; - } - ret = WavHeadAnalysis(headInfo, file, attrs); - if (ret < 0) { - fclose(file); - return HDF_FAILURE; - } - ret = FrameStart(headInfo, render, file, attrs); - if (ret < 0) { - fclose(file); - return HDF_FAILURE; - } - fclose(file); - return HDF_SUCCESS; -} +void AudioHdiRenderTest::SetUp(void) {} -struct PrepareAudioPara { - struct AudioManager *manager; - enum AudioPortDirection portType; - const char *adapterName; - struct AudioAdapter *adapter; - struct AudioPort audioPort; - void *self; - enum AudioPortPin pins; - const char *path; - struct AudioRender *render; - struct AudioCapture *capture; - struct AudioHeadInfo headInfo; - struct AudioAdapterDescriptor *desc; - struct AudioAdapterDescriptor *descs; - char *frame; - uint64_t requestBytes; - uint64_t replyBytes; - uint64_t fileSize; - struct AudioSampleAttributes attrs; -}; +void AudioHdiRenderTest::TearDown(void) {} int32_t AudioHdiRenderTest::GetLoadAdapterAudioPara(struct PrepareAudioPara& audiopara) { @@ -236,52 +155,6 @@ int32_t AudioHdiRenderTest::GetLoadAdapterAudioPara(struct PrepareAudioPara& aud return HDF_SUCCESS; } -int32_t AudioHdiRenderTest::PlayAudioFile(struct PrepareAudioPara& audiopara) -{ - int32_t ret = -1; - struct AudioDeviceDescriptor devDesc = {}; - char absPath[PATH_MAX] = {0}; - if (audiopara.adapter == nullptr || audiopara.manager == nullptr) { - return HDF_FAILURE; - } - if (realpath(audiopara.path, absPath) == nullptr) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - return HDF_FAILURE; - } - FILE *file = fopen(absPath, "rb"); - if (file == nullptr) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - return HDF_FAILURE; - } - - HMOS::Audio::InitAttrs(audiopara.attrs); - - if (WavHeadAnalysis(audiopara.headInfo, file, audiopara.attrs) < 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - fclose(file); - return HDF_FAILURE; - } - - HMOS::Audio::InitDevDesc(devDesc, (&audiopara.audioPort)->portId, audiopara.pins); - - ret = audiopara.adapter->CreateRender(audiopara.adapter, &devDesc, &(audiopara.attrs), &audiopara.render); - if (ret < 0 || audiopara.render == nullptr) { - fclose(file); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - return HDF_FAILURE; - } - ret = HMOS::Audio::FrameStart(audiopara.headInfo, audiopara.render, file, audiopara.attrs); - if (ret == HDF_SUCCESS) { - fclose(file); - } else { - audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - fclose(file); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - /** * @tc.name Test RenderGetLatency API via legal * @tc.number SUB_Audio_HDI_RenderGetLatency_0001 @@ -292,30 +165,17 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetLatency_0001, TestSize. { int32_t ret = -1; uint32_t latencyTime = 0; - uint32_t hopeVolume = 0; - struct AudioPort audioPort = {}; + uint32_t expectLatency = 0; struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; - enum AudioPortPin pins = PIN_OUT_SPEAKER; - enum AudioPortDirection audioPortType = PORT_OUT; - - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, audioPortType, ADAPTER_NAME2, &adapter, audioPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(pins, manager, adapter, audioPort, &render); - if (render == nullptr || ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioRenderStart(AUDIO_FILE, render); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->GetLatency(render, &latencyTime); EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_LT(hopeVolume, latencyTime); + EXPECT_LT(expectLatency, latencyTime); ret = render->control.Stop((AudioHandle)render); adapter->DestroyRender(adapter, render); @@ -331,28 +191,14 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetLatency_0002, TestSize. { int32_t ret = -1; uint32_t latencyTime = 0; - struct AudioPort audioPort = {}; struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; struct AudioRender *renderNull = nullptr; - enum AudioPortPin pins = PIN_OUT_SPEAKER; - enum AudioPortDirection audioPortType = PORT_OUT; - - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, audioPortType, ADAPTER_NAME2, &adapter, audioPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(pins, manager, adapter, audioPort, &render); - if (render == nullptr || ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - ret = AudioRenderStart(AUDIO_FILE, render); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->GetLatency(renderNull, &latencyTime); EXPECT_EQ(HDF_FAILURE, ret); @@ -370,27 +216,13 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetLatency_0003, TestSize. { int32_t ret = -1; uint32_t *latencyTime = nullptr; - struct AudioPort audioPort = {}; - struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; - enum AudioPortPin pins = PIN_OUT_SPEAKER; - enum AudioPortDirection audioPortType = PORT_OUT; - - struct AudioManager manager = *GetAudioManager(); + struct AudioAdapter *adapter = nullptr; ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, audioPortType, ADAPTER_NAME2, &adapter, audioPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(pins, manager, adapter, audioPort, &render); - if (render == nullptr || ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - - ret = AudioRenderStart(AUDIO_FILE, render); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->GetLatency(render, latencyTime); EXPECT_EQ(HDF_FAILURE, ret); @@ -407,23 +239,14 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetLatency_0003, TestSize. HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetRenderSpeed_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; - struct AudioRender *render = nullptr; float speed = 100; - + TestAudioManager manager = {}; + struct AudioAdapter *adapter =nullptr; + struct AudioRender *render = nullptr; ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = render->control.Start((AudioHandle)render); - EXPECT_EQ(HDF_SUCCESS, ret); ret = render->SetRenderSpeed(render, speed); EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); @@ -441,24 +264,15 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetRenderSpeed_0001, TestS HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetRenderSpeed_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + float speed = 0; + TestAudioManager manager = {}; + struct AudioAdapter *adapter =nullptr; struct AudioRender *render = nullptr; struct AudioRender *renderNull = nullptr; - float speed = 0; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = render->control.Start((AudioHandle)render); - EXPECT_EQ(HDF_SUCCESS, ret); ret = render->SetRenderSpeed(renderNull, speed); EXPECT_EQ(HDF_FAILURE, ret); @@ -476,25 +290,14 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetRenderSpeed_0002, TestS HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderSpeed_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; - struct AudioRender *render = nullptr; float speed = 0; - + TestAudioManager manager = {}; + struct AudioAdapter *adapter =nullptr; + struct AudioRender *render = nullptr; ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = render->control.Start((AudioHandle)render); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->GetRenderSpeed(render, &speed); EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); @@ -511,24 +314,15 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderSpeed_0001, TestS HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderSpeed_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + TestAudioManager manager = {}; + struct AudioAdapter *adapter =nullptr; struct AudioRender *render = nullptr; struct AudioRender *renderNull = nullptr; float speed = 0; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = render->control.Start((AudioHandle)render); - EXPECT_EQ(HDF_SUCCESS, ret); ret = render->GetRenderSpeed(renderNull, &speed); EXPECT_EQ(HDF_FAILURE, ret); @@ -546,23 +340,14 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderSpeed_0002, TestS HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderSpeed_0003, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + TestAudioManager manager = {}; + struct AudioAdapter *adapter =nullptr; struct AudioRender *render = nullptr; float *speedNull = nullptr; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = render->control.Start((AudioHandle)render); - EXPECT_EQ(HDF_SUCCESS, ret); ret = render->GetRenderSpeed(render, speedNull); EXPECT_EQ(HDF_FAILURE, ret); @@ -582,22 +367,14 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderFrame_0001, TestSize.Level int32_t ret = -1; uint64_t requestBytes = 0; uint64_t replyBytes = 0; - struct AudioPort renderPort = {}; - enum AudioPortDirection portType = PORT_OUT; enum AudioPortPin pins = PIN_OUT_SPEAKER; struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; char *frame = nullptr; - ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(pins, manager, adapter, renderPort, &render); - if (ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->control.Start((AudioHandle)render); EXPECT_EQ(HDF_SUCCESS, ret); @@ -625,23 +402,15 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderFrame_0002, TestSize.Level int32_t ret = -1; uint64_t requestBytes = 0; uint64_t replyBytes = 0; - struct AudioPort renderPort = {}; - enum AudioPortDirection portType = PORT_OUT; - enum AudioPortPin pins = PIN_OUT_SPEAKER; struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; struct AudioRender *renderNull = nullptr; char *frame = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(pins, manager, adapter, renderPort, &render); - if (ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->control.Start((AudioHandle)render); EXPECT_EQ(HDF_SUCCESS, ret); @@ -669,22 +438,14 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderFrame_0003, TestSize.Level int32_t ret = -1; uint64_t requestBytes = 0; uint64_t replyBytes = 0; - struct AudioPort renderPort = {}; - enum AudioPortDirection portType = PORT_OUT; - enum AudioPortPin pins = PIN_OUT_SPEAKER; struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; char *frame = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(pins, manager, adapter, renderPort, &render); - if (ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->control.Start((AudioHandle)render); EXPECT_EQ(HDF_SUCCESS, ret); @@ -704,23 +465,15 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderFrame_0004, TestSize.Level { int32_t ret = -1; uint64_t requestBytes = 0; - struct AudioPort renderPort = {}; - enum AudioPortDirection portType = PORT_OUT; - enum AudioPortPin pins = PIN_OUT_SPEAKER; struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; char *frame = nullptr; uint64_t *replyBytes = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(pins, manager, adapter, renderPort, &render); - if (ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->control.Start((AudioHandle)render); EXPECT_EQ(HDF_SUCCESS, ret); @@ -746,24 +499,16 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderFrame_0004, TestSize.Level HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderFrame_0005, TestSize.Level1) { int32_t ret = -1; - uint64_t requestBytes = 0; uint64_t replyBytes = 0; - struct AudioPort renderPort = {}; - enum AudioPortDirection portType = PORT_OUT; - enum AudioPortPin pins = PIN_OUT_SPEAKER; + uint64_t requestBytes = 0; struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; char *frame = nullptr; ASSERT_NE(nullptr, GetAudioManager); - struct AudioManager manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, portType, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(pins, manager, adapter, renderPort, &render); - if (ret != 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = RenderFramePrepare(AUDIO_FILE, frame, requestBytes); EXPECT_EQ(HDF_SUCCESS, ret); ret = render->RenderFrame(render, frame, requestBytes, &replyBytes); @@ -785,9 +530,8 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderFrame_0005, TestSize.Level HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetChannelMode_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + TestAudioManager manager = {}; + struct AudioAdapter *adapter =nullptr; struct AudioRender *render = nullptr; enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; enum AudioChannelMode modeOne = AUDIO_CHANNEL_BOTH_LEFT; @@ -795,15 +539,8 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetChannelMode_0001, TestS enum AudioChannelMode modeTrd = AUDIO_CHANNEL_EXCHANGE; ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = render->control.Start((AudioHandle)render); - EXPECT_EQ(HDF_SUCCESS, ret); ret = render->SetChannelMode(render, mode); EXPECT_EQ(HDF_SUCCESS, ret); ret = render->GetChannelMode(render, &mode); @@ -837,9 +574,8 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetChannelMode_0001, TestS HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetChannelMode_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + TestAudioManager manager = {}; + struct AudioAdapter *adapter =nullptr; struct AudioRender *render = nullptr; enum AudioChannelMode mode = AUDIO_CHANNEL_MIX; enum AudioChannelMode modeOne = AUDIO_CHANNEL_LEFT_MUTE; @@ -847,15 +583,8 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetChannelMode_0002, TestS enum AudioChannelMode modeTrd = AUDIO_CHANNEL_BOTH_MUTE; ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = render->control.Start((AudioHandle)render); - EXPECT_EQ(HDF_SUCCESS, ret); ret = render->SetChannelMode(render, mode); EXPECT_EQ(HDF_SUCCESS, ret); ret = render->GetChannelMode(render, &mode); @@ -889,21 +618,15 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetChannelMode_0002, TestS HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetChannelMode_0003, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + TestAudioManager manager = {}; + struct AudioAdapter *adapter =nullptr; struct AudioRender *render = nullptr; enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; - + enum AudioPortPin pins = PIN_OUT_SPEAKER; ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->SetChannelMode(render, mode); EXPECT_EQ(HDF_SUCCESS, ret); ret = render->GetChannelMode(render, &mode); @@ -922,28 +645,20 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetChannelMode_0003, TestS HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetChannelMode_0004, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + TestAudioManager manager = {}; struct AudioRender *render = nullptr; + struct AudioAdapter *adapter =nullptr; struct AudioRender *renderNull = nullptr; enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; - + enum AudioPortPin pins = PIN_OUT_SPEAKER; ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = render->control.Start((AudioHandle)render); - EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->SetChannelMode(renderNull, mode); EXPECT_EQ(HDF_FAILURE, ret); - render->control.Stop((AudioHandle)render); adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); } @@ -956,23 +671,14 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetChannelMode_0004, TestS HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetChannelMode_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + TestAudioManager manager = {}; + struct AudioAdapter *adapter =nullptr; struct AudioRender *render = nullptr; enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = render->control.Start((AudioHandle)render); - EXPECT_EQ(HDF_SUCCESS, ret); ret = render->GetChannelMode(render, &mode); EXPECT_EQ(HDF_SUCCESS, ret); @@ -995,28 +701,21 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetChannelMode_0001, TestS HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetChannelMode_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; - struct AudioRender *render = nullptr; + TestAudioManager manager = {}; + struct AudioAdapter *adapter =nullptr; struct AudioRender *renderNull = nullptr; + struct AudioRender *render = nullptr; enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = render->control.Start((AudioHandle)render); - EXPECT_EQ(HDF_SUCCESS, ret); ret = render->GetChannelMode(renderNull, &mode); EXPECT_EQ(HDF_FAILURE, ret); + render->control.Stop((AudioHandle)render); adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); } @@ -1029,21 +728,15 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetChannelMode_0002, TestS HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetChannelMode_0003, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; + TestAudioManager manager = {}; + enum AudioPortPin pins = PIN_OUT_SPEAKER; enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; - ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->GetChannelMode(render, &mode); EXPECT_EQ(HDF_SUCCESS, ret); EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode); @@ -1062,37 +755,27 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0001, Te int32_t ret = -1; uint64_t frames = 0; int64_t timeExp = 0; - struct AudioTimeStamp time = {.tvSec = 0}; + struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; struct PrepareAudioPara audiopara = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); - ret = GetLoadAdapterAudioPara(audiopara); + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } sleep(1); if (audiopara.render != nullptr) { ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &time); EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_GT(time.tvSec, timeExp); + EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp); EXPECT_GT(frames, INITIAL_VALUE); } - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->control.Stop((AudioHandle)(audiopara.render)); + ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); } /** * @tc.name Test AudioRenderGetRenderPosition API via get RenderPosition after the audio file is Paused and resumed @@ -1103,91 +786,67 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0001, Te HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0002, TestSize.Level1) { int32_t ret = -1; - uint64_t frames = 0; int64_t timeExp = 0; - struct AudioTimeStamp time = {.tvSec = 0}; + uint64_t frames = 0; + struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; struct PrepareAudioPara audiopara = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, + .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; + ASSERT_NE(nullptr, GetAudioManager); + audiopara.manager = GetAudioManager(); + ASSERT_NE(nullptr, audiopara.manager); - ret = GetLoadAdapterAudioPara(audiopara); + ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); ASSERT_EQ(HDF_SUCCESS, ret); - - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } sleep(1); if (audiopara.render != nullptr) { ret = audiopara.render->control.Pause((AudioHandle)(audiopara.render)); EXPECT_EQ(HDF_SUCCESS, ret); ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &time); EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_GT(time.tvSec, timeExp); + EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp); EXPECT_GT(frames, INITIAL_VALUE); - sleep(1); + usleep(1000); ret = audiopara.render->control.Resume((AudioHandle)(audiopara.render)); EXPECT_EQ(HDF_SUCCESS, ret); ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &time); EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_GT(time.tvSec, timeExp); + EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp); EXPECT_GT(frames, INITIAL_VALUE); } - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->control.Stop((AudioHandle)(audiopara.render)); + ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); } /** * @tc.name Test GetRenderPosition API via get RenderPosition after the audio file is stopped * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0003 -* @tc.desc Test GetRenderPosition interface,Returns 0 if get RenderPosition after stop during playing +* @tc.desc Test GetRenderPosition interface,Returns 0 if get RenderPosition after stop * @tc.author: tiansuli */ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0003, TestSize.Level1) { int32_t ret = -1; - uint64_t frames = 0; int64_t timeExp = 0; - struct AudioTimeStamp time = {.tvSec = 0}; - struct PrepareAudioPara audiopara = { - .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, - .path = AUDIO_FILE.c_str() - }; - - ret = GetLoadAdapterAudioPara(audiopara); + uint64_t frames = 0; + struct AudioAdapter *adapter =nullptr; + struct AudioRender *render = nullptr; + struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; + ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); + ret = render->control.Stop((AudioHandle)render); + EXPECT_EQ(HDF_SUCCESS, ret); - pthread_t tids; - ret = pthread_create(&tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - sleep(1); - if (audiopara.render != nullptr) { - ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &time); - EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_GT(time.tvSec, timeExp); - EXPECT_GT(frames, INITIAL_VALUE); - } - - void *result = nullptr; - pthread_join(tids, &result); - ret = (intptr_t)result; - ASSERT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->control.Stop((AudioHandle)(audiopara.render)); + ret = render->GetRenderPosition(render, &frames, &time); EXPECT_EQ(HDF_SUCCESS, ret); - audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render); - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); + EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp); + EXPECT_GT(frames, INITIAL_VALUE); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); } /** * @tc.name Test AudioRenderGetRenderPosition API via setting the parameter render is nullptr @@ -1198,26 +857,19 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0003, Te HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0004, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; - struct AudioRender *render = nullptr; uint64_t frames = 0; - struct AudioTimeStamp time = {.tvSec = 0}; int64_t timeExp = 0; + struct AudioRender *render = nullptr; + struct AudioAdapter *adapter =nullptr; + struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; ASSERT_NE(nullptr, GetAudioManager); - manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->GetRenderPosition(render, &frames, &time); EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_EQ(time.tvSec, timeExp); + EXPECT_EQ((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp); adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); @@ -1231,26 +883,16 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0004, Te HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0005, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; - struct AudioRender *render = nullptr; - struct AudioRender *renderNull = nullptr; uint64_t frames = 0; struct AudioTimeStamp time = {}; + struct AudioAdapter *adapter =nullptr; + struct AudioRender *render = nullptr; + struct AudioRender *renderNull = nullptr; ASSERT_NE(nullptr, GetAudioManager); - manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioRenderStart(AUDIO_FILE, render); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->GetRenderPosition(renderNull, &frames, &time); EXPECT_EQ(HDF_FAILURE, ret); @@ -1267,25 +909,16 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0005, Te HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0006, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; - struct AudioRender *render = nullptr; uint64_t *framesNull = nullptr; - struct AudioTimeStamp time = {.tvSec = 0}; + TestAudioManager manager = {}; + struct AudioAdapter *adapter =nullptr; + struct AudioRender *render = nullptr; + struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioRenderStart(AUDIO_FILE, render); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = render->GetRenderPosition(render, framesNull, &time); EXPECT_EQ(HDF_FAILURE, ret); @@ -1302,24 +935,16 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0006, Te HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0007, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; - struct AudioRender *render = nullptr; uint64_t frames = 0; + TestAudioManager manager = {}; + struct AudioAdapter *adapter =nullptr; + struct AudioRender *render = nullptr; struct AudioTimeStamp *timeNull = nullptr; ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioRenderStart(AUDIO_FILE, render); - EXPECT_EQ(HDF_SUCCESS, ret); ret = render->GetRenderPosition(render, &frames, timeNull); EXPECT_EQ(HDF_FAILURE, ret); @@ -1337,31 +962,22 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0007, Te HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0008, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; - struct AudioRender *render = nullptr; - uint64_t frames = 0; - struct AudioTimeStamp time = {.tvSec = 0}; int64_t timeExp = 0; - + uint64_t frames = 0; + TestAudioManager manager = {}; + struct AudioAdapter *adapter =nullptr; + struct AudioRender *render = nullptr; + struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; ASSERT_NE(nullptr, GetAudioManager); manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioRenderStart(AUDIO_FILE, render); - EXPECT_EQ(HDF_SUCCESS, ret); ret = render->GetRenderPosition(render, &frames, &time); EXPECT_EQ(HDF_SUCCESS, ret); ret = render->GetRenderPosition(render, &frames, &time); EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_GT(time.tvSec, timeExp); + EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp); EXPECT_GT(frames, INITIAL_VALUE); render->control.Stop((AudioHandle)render); @@ -1378,24 +994,20 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0009, Te { int32_t ret = -1; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; + enum AudioPortPin pins = PIN_OUT_SPEAKER; struct AudioSampleAttributes attrs = {}; struct AudioSampleAttributes attrsValue = {}; uint64_t channelCountExp = 2; uint32_t sampleRateExp = 48000; uint64_t frames = 0; int64_t timeExp = 0; - struct AudioTimeStamp time = {.tvSec = 0}; - struct AudioManager manager = *GetAudioManager(); + struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; + TestAudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + InitAttrs(attrs); attrs.type = AUDIO_IN_MEDIA; attrs.interleaved = false; attrs.format = AUDIO_FORMAT_PCM_16_BIT; @@ -1408,14 +1020,12 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0009, Te EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); EXPECT_EQ(channelCountExp, attrsValue.channelCount); - - ret = AudioRenderStart(AUDIO_FILE, render); + ret = AudioRenderStartAndOneFrame(render); EXPECT_EQ(HDF_SUCCESS, ret); ret = render->GetRenderPosition(render, &frames, &time); EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_GT(time.tvSec, timeExp); + EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp); EXPECT_GT(frames, INITIAL_VALUE); - render->control.Stop((AudioHandle)render); adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); @@ -1429,25 +1039,20 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0009, Te HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0010, TestSize.Level1) { int32_t ret = -1; + uint64_t frames = 0; + int64_t timeExp = 0; + uint64_t channelCountExp = 2; + uint32_t sampleRateExp = 48000; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioSampleAttributes attrs = {}; struct AudioSampleAttributes attrsValue = {}; - uint64_t channelCountExp = 2; - uint32_t sampleRateExp = 48000; - uint64_t frames = 0; - int64_t timeExp = 0; - struct AudioTimeStamp time = {.tvSec = 0}; - struct AudioManager manager = *GetAudioManager(); + struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; ASSERT_NE(nullptr, GetAudioManager); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + InitAttrs(attrs); attrs.type = AUDIO_IN_MEDIA; attrs.interleaved = false; attrs.format = AUDIO_FORMAT_PCM_24_BIT; @@ -1460,14 +1065,12 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0010, Te EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); EXPECT_EQ(channelCountExp, attrsValue.channelCount); - - ret = AudioRenderStart(AUDIO_FILE, render); + ret = AudioRenderStartAndOneFrame(render); EXPECT_EQ(HDF_SUCCESS, ret); ret = render->GetRenderPosition(render, &frames, &time); EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_GT(time.tvSec, timeExp); + EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp); EXPECT_GT(frames, INITIAL_VALUE); - render->control.Stop((AudioHandle)render); adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); @@ -1481,25 +1084,20 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0010, Te HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0011, TestSize.Level1) { int32_t ret = -1; + uint64_t frames = 0; + int64_t timeExp = 0; + uint32_t sampleRateExp = 48000; + uint64_t channelCountExp = 1; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioSampleAttributes attrs = {}; struct AudioSampleAttributes attrsValue = {}; - uint64_t channelCountExp = 1; - uint32_t sampleRateExp = 48000; - uint64_t frames = 0; - int64_t timeExp = 0; - struct AudioTimeStamp time = {.tvSec = 0}; - struct AudioManager manager = *GetAudioManager(); + struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; ASSERT_NE(nullptr, GetAudioManager); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + InitAttrs(attrs); attrs.type = AUDIO_IN_MEDIA; attrs.interleaved = false; attrs.format = AUDIO_FORMAT_PCM_16_BIT; @@ -1509,17 +1107,15 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0011, Te EXPECT_EQ(HDF_SUCCESS, ret); ret = render->attr.GetSampleAttributes(render, &attrsValue); EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); EXPECT_EQ(channelCountExp, attrsValue.channelCount); - - ret = AudioRenderStart(AUDIO_FILE, render); + ret = AudioRenderStartAndOneFrame(render); EXPECT_EQ(HDF_SUCCESS, ret); ret = render->GetRenderPosition(render, &frames, &time); EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_GT(time.tvSec, timeExp); + EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp); EXPECT_GT(frames, INITIAL_VALUE); - render->control.Stop((AudioHandle)render); adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); @@ -1533,25 +1129,20 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0011, Te HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0012, TestSize.Level1) { int32_t ret = -1; - struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; + uint64_t frames = 0; + int64_t timeExp = 0; struct AudioRender *render = nullptr; + struct AudioAdapter *adapter = nullptr; struct AudioSampleAttributes attrs = {}; struct AudioSampleAttributes attrsValue = {}; + struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0}; uint64_t channelCountExp = 1; uint32_t sampleRateExp = 48000; - uint64_t frames = 0; - int64_t timeExp = 0; - struct AudioTimeStamp time = {.tvSec = 0}; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + InitAttrs(attrs); attrs.type = AUDIO_IN_MEDIA; attrs.interleaved = false; attrs.format = AUDIO_FORMAT_PCM_24_BIT; @@ -1564,14 +1155,12 @@ HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0012, Te EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); EXPECT_EQ(sampleRateExp, attrsValue.sampleRate); EXPECT_EQ(channelCountExp, attrsValue.channelCount); - - ret = AudioRenderStart(AUDIO_FILE, render); + ret = AudioRenderStartAndOneFrame(render); EXPECT_EQ(HDF_SUCCESS, ret); ret = render->GetRenderPosition(render, &frames, &time); EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_GT(time.tvSec, timeExp); + EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp); EXPECT_GT(frames, INITIAL_VALUE); - render->control.Stop((AudioHandle)render); adapter->DestroyRender(adapter, render); manager.UnloadAdapter(&manager, adapter); diff --git a/audio/test/systemtest/hdi/render/src/audio_hdirender_volume_test.cpp b/audio/test/systemtest/hdi/render/src/audio_hdirender_volume_test.cpp index 424101a1bf..ba93a8a2d3 100755 --- a/audio/test/systemtest/hdi/render/src/audio_hdirender_volume_test.cpp +++ b/audio/test/systemtest/hdi/render/src/audio_hdirender_volume_test.cpp @@ -41,10 +41,8 @@ using namespace testing::ext; using namespace HMOS::Audio; namespace { -const string AUDIO_FILE = "//bin/audiorendertest.wav"; -const string ADAPTER_NAME = "hdmi"; -const string ADAPTER_NAME2 = "usb"; -const string ADAPTER_NAME3 = "internal"; +const string ADAPTER_NAME_USB = "usb"; +const string ADAPTER_NAME_INTERNAL = "internal"; class AudioHdiRenderVolumeTest : public testing::Test { public: @@ -52,130 +50,74 @@ public: static void TearDownTestCase(void); void SetUp(); void TearDown(); - struct AudioManager *(*GetAudioManager)() = nullptr; - void *handleSo = nullptr; - int32_t GetLoadAdapter(struct AudioManager manager, enum AudioPortDirection portType, - const string adapterName, struct AudioAdapter **adapter, struct AudioPort& audioPort) const; - int32_t AudioCreateRender(enum AudioPortPin pins, struct AudioManager manager, struct AudioAdapter *adapter, - const struct AudioPort renderPort, struct AudioRender **render) const; - int32_t AudioRenderStart(const string path, struct AudioRender *render) const; + static TestAudioManager *(*GetAudioManager)(); + static void *handleSo; +#ifdef AUDIO_MPI_SO + static int32_t (*SdkInit)(); + static void (*SdkExit)(); + static void *sdkSo; +#endif }; -void AudioHdiRenderVolumeTest::SetUpTestCase(void) {} +TestAudioManager *(*AudioHdiRenderVolumeTest::GetAudioManager)() = nullptr; +void *AudioHdiRenderVolumeTest::handleSo = nullptr; +#ifdef AUDIO_MPI_SO + int32_t (*AudioHdiRenderVolumeTest::SdkInit)() = nullptr; + void (*AudioHdiRenderVolumeTest::SdkExit)() = nullptr; + void *AudioHdiRenderVolumeTest::sdkSo = nullptr; +#endif -void AudioHdiRenderVolumeTest::TearDownTestCase(void) {} - -void AudioHdiRenderVolumeTest::SetUp(void) +void AudioHdiRenderVolumeTest::SetUpTestCase(void) { - char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; - handleSo = dlopen(resolvedPath, RTLD_LAZY); - if (handleSo == nullptr) { +#ifdef AUDIO_MPI_SO + char sdkResolvedPath[] = "//system/lib/libhdi_audio_interface_lib_render.z.so"; + sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY); + if (sdkSo == nullptr) { return; } - GetAudioManager = (struct AudioManager* (*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); - if (GetAudioManager == nullptr) { + SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit")); + if (SdkInit == nullptr) { return; } -} - -void AudioHdiRenderVolumeTest::TearDown(void) -{ - if (GetAudioManager != nullptr) { - GetAudioManager = nullptr; - } -} - -int32_t AudioHdiRenderVolumeTest::GetLoadAdapter(struct AudioManager manager, enum AudioPortDirection portType, - const string adapterName, struct AudioAdapter **adapter, struct AudioPort& audioPort) const -{ - int32_t ret = -1; - int size = 0; - struct AudioAdapterDescriptor *desc = nullptr; - struct AudioAdapterDescriptor *descs = nullptr; - if (adapter == nullptr) { - return HDF_FAILURE; - } - ret = manager.GetAllAdapters(&manager, &descs, &size); - if (ret < 0 || descs == nullptr || size == 0) { - return HDF_FAILURE; - } else { - int index = SwitchAdapter(descs, adapterName, portType, audioPort, size); - if (index < 0) { - return HDF_FAILURE; - } else { - desc = &descs[index]; - } + SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit")); + if (SdkExit == nullptr) { + return; } - if (desc == nullptr) { - return HDF_FAILURE; - } else { - ret = manager.LoadAdapter(&manager, desc, adapter); + SdkInit(); +#endif + handleSo = dlopen(RESOLVED_PATH.c_str(), RTLD_LAZY); + if (handleSo == nullptr) { + return; } - if (ret < 0 || adapter == nullptr) { - return HDF_FAILURE; + GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str())); + if (GetAudioManager == nullptr) { + return; } - return HDF_SUCCESS; } -int32_t AudioHdiRenderVolumeTest::AudioCreateRender(enum AudioPortPin pins, struct AudioManager manager, - struct AudioAdapter *adapter, const struct AudioPort renderPort, struct AudioRender **render) const +void AudioHdiRenderVolumeTest::TearDownTestCase(void) { - int32_t ret = -1; - struct AudioSampleAttributes attrs = {}; - struct AudioDeviceDescriptor devDesc = {}; - if (adapter == nullptr || adapter->CreateRender == nullptr || render == nullptr) { - return HDF_FAILURE; +#ifdef AUDIO_MPI_SO + SdkExit(); + if (sdkSo != nullptr) { + dlclose(sdkSo); + sdkSo = nullptr; } - ret = InitAttrs(attrs); - if (ret < 0) { - return HDF_FAILURE; + if (SdkInit != nullptr) { + SdkInit = nullptr; } - ret = InitDevDesc(devDesc, renderPort.portId, pins); - if (ret < 0) { - return HDF_FAILURE; + if (SdkExit != nullptr) { + SdkExit = nullptr; } - ret = adapter->CreateRender(adapter, &devDesc, &attrs, render); - if (ret < 0 || *render == nullptr) { - manager.UnloadAdapter(&manager, adapter); - return HDF_FAILURE; +#endif + if (GetAudioManager != nullptr) { + GetAudioManager = nullptr; } - return HDF_SUCCESS; } -int32_t AudioHdiRenderVolumeTest::AudioRenderStart(const string path, struct AudioRender *render) const -{ - int32_t ret = -1; - struct AudioSampleAttributes attrs = {}; - struct AudioHeadInfo headInfo = {}; - if (render == nullptr) { - return HDF_FAILURE; - } - ret = InitAttrs(attrs); - if (ret < 0) { - return HDF_FAILURE; - } - char absPath[PATH_MAX] = {0}; - if (realpath(path.c_str(), absPath) == nullptr) { - printf("path is not exist"); - return HDF_FAILURE; - } - FILE *file = fopen(absPath, "rb"); - if (file == nullptr) { - return HDF_FAILURE; - } - ret = WavHeadAnalysis(headInfo, file, attrs); - if (ret < 0) { - fclose(file); - return HDF_FAILURE; - } - ret = FrameStart(headInfo, render, file, attrs); - if (ret < 0) { - fclose(file); - return HDF_FAILURE; - } - fclose(file); - return HDF_SUCCESS; -} +void AudioHdiRenderVolumeTest::SetUp(void) {} +void AudioHdiRenderVolumeTest::TearDown(void) {} + /** * @tc.name Test RenderGetGainThreshold API via legal input * @tc.number SUB_Audio_HDI_RenderGetGainThreshold_0001 @@ -185,22 +127,14 @@ int32_t AudioHdiRenderVolumeTest::AudioRenderStart(const string path, struct Aud HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGainThreshold_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; - struct AudioRender *render = nullptr; float min = 0; float max = 0; - + struct AudioAdapter *adapter = nullptr; + struct AudioRender *render = nullptr; ASSERT_NE(nullptr, GetAudioManager); - manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->volume.GetGainThreshold((AudioHandle)render, &min, &max); EXPECT_EQ(HDF_SUCCESS, ret); @@ -219,23 +153,15 @@ HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGainThreshold_0001, Te HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGainThreshold_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; + float min = 0; + float max = 0; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioRender *renderNull = nullptr; - float min = 0; - float max = 0; - ASSERT_NE(nullptr, GetAudioManager); - manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->volume.GetGainThreshold((AudioHandle)renderNull, &min, &max); EXPECT_EQ(HDF_FAILURE, ret); @@ -252,22 +178,14 @@ HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGainThreshold_0002, Te HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGainThreshold_0003, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; + float max = 0; + float *minNull = nullptr; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; - float *minNull = nullptr; - float max = 0; - ASSERT_NE(nullptr, GetAudioManager); - manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->volume.GetGainThreshold((AudioHandle)render, minNull, &max); EXPECT_EQ(HDF_FAILURE, ret); @@ -284,23 +202,14 @@ HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGainThreshold_0003, Te HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGainThreshold_0004, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; - struct AudioRender *render = nullptr; float min = 0; float *maxNull = nullptr; - + struct AudioAdapter *adapter = nullptr; + struct AudioRender *render = nullptr; ASSERT_NE(nullptr, GetAudioManager); - manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = render->volume.GetGainThreshold(render, &min, maxNull); EXPECT_EQ(HDF_FAILURE, ret); @@ -316,21 +225,14 @@ HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGainThreshold_0004, Te HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderSetGain_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; - struct AudioRender *render = nullptr; float min = 0; float max = 0; + struct AudioAdapter *adapter = nullptr; + struct AudioRender *render = nullptr; ASSERT_NE(nullptr, GetAudioManager); - manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->volume.GetGainThreshold((AudioHandle)render, &min, &max); EXPECT_EQ(HDF_SUCCESS, ret); float gain = 10.8; @@ -369,22 +271,14 @@ HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderSetGain_0001, TestSize.Le HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderSetGain_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; - struct AudioRender *render = nullptr; float min = 0; float max = 0; - + struct AudioAdapter *adapter = nullptr; + struct AudioRender *render = nullptr; ASSERT_NE(nullptr, GetAudioManager); - manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->volume.GetGainThreshold((AudioHandle)render, &min, &max); EXPECT_EQ(HDF_SUCCESS, ret); @@ -408,21 +302,13 @@ HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderSetGain_0002, TestSize.Le HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderSetGain_0003, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; + char gain = 'a'; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; - char gain = 'a'; - ASSERT_NE(nullptr, GetAudioManager); - manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->volume.SetGain(render, gain); EXPECT_EQ(HDF_FAILURE, ret); @@ -439,22 +325,14 @@ HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderSetGain_0003, TestSize.Le HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderSetGain_0004, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; + float gain = 1; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioRender *renderNull = nullptr; - float gain = 1; - ASSERT_NE(nullptr, GetAudioManager); - manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->volume.SetGain((AudioHandle)renderNull, gain); EXPECT_EQ(HDF_FAILURE, ret); @@ -471,22 +349,14 @@ HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderSetGain_0004, TestSize.Le HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGain_0001, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; - struct AudioRender *render = nullptr; float min = 0; float max = 0; - + struct AudioAdapter *adapter = nullptr; + struct AudioRender *render = nullptr; ASSERT_NE(nullptr, GetAudioManager); - manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->volume.GetGainThreshold((AudioHandle)render, &min, &max); EXPECT_EQ(HDF_SUCCESS, ret); @@ -511,22 +381,15 @@ HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGain_0001, TestSize.Le HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGain_0002, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; + float gain = 0; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; struct AudioRender *renderNull = nullptr; - float gain = 0; - ASSERT_NE(nullptr, GetAudioManager); - manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + ret = render->volume.GetGain((AudioHandle)renderNull, &gain); EXPECT_EQ(HDF_FAILURE, ret); adapter->DestroyRender(adapter, render); @@ -541,22 +404,14 @@ HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGain_0002, TestSize.Le HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGain_0003, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; - struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; - struct AudioRender *render = nullptr; float gain = GAIN_MAX-1; float gainOne = GAIN_MAX-1; - + struct AudioAdapter *adapter = nullptr; + struct AudioRender *render = nullptr; ASSERT_NE(nullptr, GetAudioManager); - manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->volume.SetGain(render, gain); EXPECT_EQ(HDF_SUCCESS, ret); @@ -576,21 +431,13 @@ HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGain_0003, TestSize.Le HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGain_0004, TestSize.Level1) { int32_t ret = -1; - struct AudioManager manager = {}; + float *gainNull = nullptr; struct AudioAdapter *adapter = nullptr; - struct AudioPort renderPort = {}; struct AudioRender *render = nullptr; - float *gainNull = nullptr; - ASSERT_NE(nullptr, GetAudioManager); - manager = *GetAudioManager(); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->volume.GetGain((AudioHandle)render, gainNull); EXPECT_EQ(HDF_FAILURE, ret); adapter->DestroyRender(adapter, render); @@ -607,19 +454,12 @@ HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderSetMute_0001, TestSi int32_t ret = -1; bool muteFalse = false; bool muteTrue = true; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->volume.SetMute(render, muteFalse); EXPECT_EQ(HDF_SUCCESS, ret); @@ -651,20 +491,13 @@ HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderSetMute_0002, TestSi { int32_t ret = -1; bool mute = true; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; struct AudioRender *renderNull = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->volume.SetMute(renderNull, mute); EXPECT_EQ(HDF_FAILURE, ret); adapter->DestroyRender(adapter, render); @@ -680,19 +513,12 @@ HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderSetMute_0003, TestSi { int32_t ret = -1; bool muteValue = 2; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->volume.SetMute(render, muteValue); EXPECT_EQ(HDF_SUCCESS, ret); @@ -715,19 +541,12 @@ HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderGetMute_0001, TestSi bool muteTrue = true; bool muteFalse = false; bool defaultmute = true; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->volume.GetMute(render, &muteTrue); EXPECT_EQ(HDF_SUCCESS, ret); @@ -753,20 +572,13 @@ HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderGetMute_0002, TestSi int32_t ret = -1; bool muteTrue = true; bool muteFalse = false; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; struct AudioRender *renderNull = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->volume.GetMute(renderNull, &muteTrue); EXPECT_EQ(HDF_FAILURE, ret); @@ -787,27 +599,20 @@ HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderGetMute_0002, TestSi HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderSetVolume_0001, TestSize.Level1) { int32_t ret = -1; - float volumeInit = 0.30; - float volumeInitExpc = 0.30; + float volumeInit = 0.20; + float volumeInitExpc = 0.20; float volumeLow = 0.10; float volumeLowExpc = 0.10; - float volumeMid = 0.40; - float volumeMidExpc = 0.40; - float volumeHigh = 0.70; - float volumeHighExpc = 0.70; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + float volumeMid = 0.50; + float volumeMidExpc = 0.50; + float volumeHigh = 0.80; + float volumeHighExpc = 0.80; + struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->volume.SetVolume(render, volumeInit); EXPECT_EQ(HDF_SUCCESS, ret); @@ -848,19 +653,12 @@ HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderSetVolume_0002, Test float volumeMaxExpc = 1.0; float volumeMinBoundary = -1; float volumeMaxBoundary = 1.01; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->volume.SetVolume(render, volumeMin); EXPECT_EQ(HDF_SUCCESS, ret); ret = render->volume.GetVolume(render, &volumeMin); @@ -892,20 +690,13 @@ HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderSetVolume_0003, Test { int32_t ret = -1; float volume = 0; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; struct AudioRender *renderNull = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->volume.SetVolume(renderNull, volume); EXPECT_EQ(HDF_FAILURE, ret); @@ -923,19 +714,13 @@ HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderGetVolume_001, TestS int32_t ret = -1; float volume = 0.30; float volumeDefault = 0.30; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); + ASSERT_EQ(HDF_SUCCESS, ret); - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->volume.SetVolume(render, volume); EXPECT_EQ(HDF_SUCCESS, ret); ret = render->volume.GetVolume(render, &volume); @@ -956,21 +741,12 @@ HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderGetVolume_002, TestS int32_t ret = -1; float volume = 0.30; float defaultVolume = 0.30; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - ret = AudioRenderStart(AUDIO_FILE, render); - EXPECT_EQ(HDF_SUCCESS, ret); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB); + ASSERT_EQ(HDF_SUCCESS, ret); ret = render->volume.SetVolume(render, volume); EXPECT_EQ(HDF_SUCCESS, ret); @@ -992,21 +768,14 @@ HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderGetVolume_002, TestS HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderGetVolume_0003, TestSize.Level1) { int32_t ret = -1; - float volume = 0; - struct AudioPort renderPort = {}; - struct AudioAdapter *adapter = {}; + float volume = 0.3; + struct AudioAdapter *adapter = nullptr; struct AudioRender *render = nullptr; struct AudioRender *renderNull = nullptr; - struct AudioManager manager = *GetAudioManager(); ASSERT_NE(nullptr, GetAudioManager); - - ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + TestAudioManager manager = *GetAudioManager(); + ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render); ASSERT_EQ(HDF_SUCCESS, ret); - ret = AudioCreateRender(PIN_OUT_SPEAKER, manager, adapter, renderPort, &render); - if (ret < 0) { - manager.UnloadAdapter(&manager, adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } ret = render->volume.GetVolume(renderNull, &volume); EXPECT_EQ(HDF_FAILURE, ret); adapter->DestroyRender(adapter, render); -- Gitee From 7087a5602b199e1c173ea869c82d4257dec1b6b0 Mon Sep 17 00:00:00 2001 From: vb6174 Date: Tue, 17 Aug 2021 07:01:18 +0000 Subject: [PATCH 2/4] modify gn format Signed-off-by: vb6174 --- audio/BUILD.gn | 17 +- audio/config/linux/BUILD.gn | 1 - audio/config/lite/BUILD.gn | 1 - audio/hal/hdi_binder/proxy/BUILD.gn | 40 ++-- audio/hal/hdi_binder/server/BUILD.gn | 27 ++- audio/hal/hdi_passthrough/BUILD.gn | 200 +++++++++--------- audio/hal/pathselect/BUILD.gn | 32 ++- audio/sample/BUILD.gn | 49 ++--- audio/supportlibs/adm_adapter/BUILD.gn | 58 +++-- audio/test/hdf/BUILD.gn | 10 +- audio/test/systemtest/BUILD.gn | 14 +- audio/test/systemtest/adm/BUILD.gn | 4 +- .../adm/audio_adm_interface/BUILD.gn | 32 +-- .../systemtest/adm_interface_lib/BUILD.gn | 6 +- .../adm_interface_lib/capture/BUILD.gn | 31 ++- .../adm_interface_lib/render/BUILD.gn | 29 ++- audio/test/systemtest/audio_function/BUILD.gn | 4 +- .../audio_function/audio_pathroute/BUILD.gn | 37 ++-- .../audio_function/audio_server/BUILD.gn | 13 +- .../audio_function/audio_smartpa/BUILD.gn | 31 +-- audio/test/systemtest/hdi/BUILD.gn | 20 +- audio/test/systemtest/hdi/adapter/BUILD.gn | 15 +- audio/test/systemtest/hdi/capture/BUILD.gn | 83 ++++---- .../systemtest/hdi/hdiperformace/BUILD.gn | 33 +-- .../systemtest/hdi/hdireliability/BUILD.gn | 93 ++++---- audio/test/systemtest/hdi/render/BUILD.gn | 76 ++++--- audio/test/unittest/BUILD.gn | 21 +- 27 files changed, 484 insertions(+), 493 deletions(-) diff --git a/audio/BUILD.gn b/audio/BUILD.gn index 0417f199f1..8ffdf5d402 100755 --- a/audio/BUILD.gn +++ b/audio/BUILD.gn @@ -20,26 +20,23 @@ import("//drivers/adapter/uhdf2/uhdf.gni") import("//drivers/peripheral/audio/audio.gni") group("hdi_audio") { - - deps = [ - "hal/hdi_passthrough:hdi_audio" - ] + deps = [ "hal/hdi_passthrough:hdi_audio" ] if (defined(ohos_lite)) { deps += [ "config/lite:hdf_audio_json" ] } else { - deps += [ + deps += [ "config/linux:hdf_audio_json", "hal/hdi_binder/proxy:audio_hdi_proxy_server", - "hal/hdi_binder/server:audio_hdi_adapter_server" + "hal/hdi_binder/server:audio_hdi_adapter_server", ] } if (enable_audio_device_mpi) { deps += [ "//device/hisilicon/hardware/media/proprietary/hal/audio:hdi_audio_interface_lib_capture", - "//device/hisilicon/hardware/media/proprietary/hal/audio:hdi_audio_interface_lib_render", "//device/hisilicon/hardware/media/proprietary/hal/audio:hdi_audio_interface_lib_mpi", + "//device/hisilicon/hardware/media/proprietary/hal/audio:hdi_audio_interface_lib_render", ] } else { deps += [ @@ -48,9 +45,7 @@ group("hdi_audio") { ] } if (enable_audio_hal_notsupport_pathselect == false) { - deps += [ - "hal/pathselect:hdi_audio_path_select", - ] + deps += [ "hal/pathselect:hdi_audio_path_select" ] if (defined(ohos_lite)) { deps += [ "config/lite:hdf_audio_path_json" ] @@ -62,7 +57,7 @@ group("hdi_audio") { group("audio_sample_client") { deps = [ + "sample:audio_sample_capture", "sample:audio_sample_render", - "sample:audio_sample_capture" ] } diff --git a/audio/config/linux/BUILD.gn b/audio/config/linux/BUILD.gn index 06f43537b2..3a5574dad9 100755 --- a/audio/config/linux/BUILD.gn +++ b/audio/config/linux/BUILD.gn @@ -14,4 +14,3 @@ if (is_standard_system) { part_name = "hdf" } } - diff --git a/audio/config/lite/BUILD.gn b/audio/config/lite/BUILD.gn index d439239d81..1980500a33 100755 --- a/audio/config/lite/BUILD.gn +++ b/audio/config/lite/BUILD.gn @@ -9,4 +9,3 @@ copy("hdf_audio_path_json") { sources = [ "//drivers/peripheral/audio/config/parse.json" ] outputs = [ "${root_out_dir}/etc/parse.json" ] } - diff --git a/audio/hal/hdi_binder/proxy/BUILD.gn b/audio/hal/hdi_binder/proxy/BUILD.gn index 1779f037d4..bf7b3b0b62 100755 --- a/audio/hal/hdi_binder/proxy/BUILD.gn +++ b/audio/hal/hdi_binder/proxy/BUILD.gn @@ -69,24 +69,24 @@ if (defined(ohos_lite)) { "//drivers/adapter/khdf/liteos/osal/include", "$hdf_uhdf_path/shared/include", "$hdf_uhdf_path/include/hdi/", - "$hdf_uhdf_path/host/include" + "$hdf_uhdf_path/host/include", ] sources = [ + "$hdf_framework_path/ability/sbuf/src/hdf_sbuf.c", + "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_adapter_info_common.c", + "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_common.c", + "//third_party/cJSON/cJSON.c", "src/audio_proxy_adapter.c", - "src/audio_proxy_common.c", "src/audio_proxy_capture.c", + "src/audio_proxy_common.c", "src/audio_proxy_manager.c", "src/audio_proxy_render.c", - "//third_party/cJSON/cJSON.c", - "$hdf_framework_path/ability/sbuf/src/hdf_sbuf.c", - "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_common.c", - "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_adapter_info_common.c" ] deps = [ "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio", - "//third_party/bounds_checking_function:libsec_shared" + "//third_party/bounds_checking_function:libsec_shared", ] public_configs = [ ":hdi_service_proxy_config" ] @@ -126,28 +126,28 @@ if (defined(ohos_lite)) { ] sources = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_adapter_info_common.c", + "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_common.c", + "//third_party/cJSON/cJSON.c", "src/audio_proxy_adapter.c", - "src/audio_proxy_common.c", "src/audio_proxy_capture.c", + "src/audio_proxy_common.c", "src/audio_proxy_manager.c", "src/audio_proxy_render.c", - "//third_party/cJSON/cJSON.c", - "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_common.c", - "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_adapter_info_common.c", ] deps = [ - "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio", - "$hdf_uhdf_path/osal:libhdf_utils", - "$hdf_uhdf_path/manager:hdf_devmgr", - "$hdf_uhdf_path/manager:hdf_devmgr.rc", - "//utils/native/base:utils", + "$hdf_uhdf_path/config:libhdf_hcs", + "$hdf_uhdf_path/hcs:hdf_default.hcb", "$hdf_uhdf_path/hdi:libhdi", - "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", "$hdf_uhdf_path/host:hdf_devhost", "$hdf_uhdf_path/host:libhdf_host", - "$hdf_uhdf_path/config:libhdf_hcs", - "$hdf_uhdf_path/hcs:hdf_default.hcb", + "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", + "$hdf_uhdf_path/manager:hdf_devmgr", + "$hdf_uhdf_path/manager:hdf_devmgr.rc", + "$hdf_uhdf_path/osal:libhdf_utils", + "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio", + "//utils/native/base:utils", ] if (is_standard_system) { @@ -160,4 +160,4 @@ if (defined(ohos_lite)) { subsystem_name = "hdf" } -} \ No newline at end of file +} diff --git a/audio/hal/hdi_binder/server/BUILD.gn b/audio/hal/hdi_binder/server/BUILD.gn index 1a26454a1d..c7a76442c8 100755 --- a/audio/hal/hdi_binder/server/BUILD.gn +++ b/audio/hal/hdi_binder/server/BUILD.gn @@ -68,21 +68,21 @@ if (defined(ohos_lite)) { "//third_party/bounds_checking_function/include", "//drivers/adapter/khdf/liteos/osal/include", "//drivers/adapter/uhdf2/shared/include", - "//drivers/adapter/uhdf2/include/hdi/" + "//drivers/adapter/uhdf2/include/hdi/", ] sources = [ + "$hdf_framework_path/ability/sbuf/src/hdf_sbuf.c", + "$hdf_framework_path/support/posix/src/osal_mem.c", "src/hdf_audio_server.c", "src/hdf_audio_server_capture.c", "src/hdf_audio_server_common.c", "src/hdf_audio_server_render.c", - "$hdf_framework_path/support/posix/src/osal_mem.c", - "$hdf_framework_path/ability/sbuf/src/hdf_sbuf.c" ] deps = [ "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio", - "//third_party/bounds_checking_function:libsec_shared" + "//third_party/bounds_checking_function:libsec_shared", ] public_configs = [ ":hdi_service_config" ] @@ -105,7 +105,7 @@ if (defined(ohos_lite)) { "$hdf_framework_path/ability/sbuf/include", "$hdf_framework_path/utils/include", "$hdf_framework_path/ability/sbuf/include", - "$hdf_uhdf_path/osal/include" + "$hdf_uhdf_path/osal/include", ] sources = [ @@ -116,17 +116,17 @@ if (defined(ohos_lite)) { ] deps = [ - "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio", - "$hdf_uhdf_path/osal:libhdf_utils", - "$hdf_uhdf_path/manager:hdf_devmgr", - "$hdf_uhdf_path/manager:hdf_devmgr.rc", - "//utils/native/base:utils", + "$hdf_uhdf_path/config:libhdf_hcs", + "$hdf_uhdf_path/hcs:hdf_default.hcb", "$hdf_uhdf_path/hdi:libhdi", - "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", "$hdf_uhdf_path/host:hdf_devhost", "$hdf_uhdf_path/host:libhdf_host", - "$hdf_uhdf_path/config:libhdf_hcs", - "$hdf_uhdf_path/hcs:hdf_default.hcb", + "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", + "$hdf_uhdf_path/manager:hdf_devmgr", + "$hdf_uhdf_path/manager:hdf_devmgr.rc", + "$hdf_uhdf_path/osal:libhdf_utils", + "//drivers/peripheral/audio/hal/hdi_passthrough:hdi_audio", + "//utils/native/base:utils", ] defines = [] @@ -144,4 +144,3 @@ if (defined(ohos_lite)) { subsystem_name = "hdf" } } - diff --git a/audio/hal/hdi_passthrough/BUILD.gn b/audio/hal/hdi_passthrough/BUILD.gn index 0ff957b523..f9d739792f 100755 --- a/audio/hal/hdi_passthrough/BUILD.gn +++ b/audio/hal/hdi_passthrough/BUILD.gn @@ -49,109 +49,105 @@ config("hdi_audio_config") { } if (defined(ohos_lite)) { - - shared_library("hdi_audio") { - sources = [ - "//third_party/cJSON/cJSON.c", - "src/audio_manager.c", - "src/audio_common.c", - "src/audio_adapter.c", - "src/audio_capture.c", - "src/audio_render.c", - "src/audio_adapter_info_common.c", - "$hdf_framework_path/support/posix/src/osal_time.c" - ] - - include_dirs = [ - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/supportlibs/adm_adapter/include", - "//third_party/cJSON", - "//drivers/peripheral/audio/interfaces/include", - "$hdf_framework_path/include/core", - "$hdf_framework_path/include/utils", - "$hdf_framework_path/include/osal", - "$hdf_framework_path/ability/sbuf/include", - "//drivers//adapter/khdf/liteos/osal/include", - "//third_party/bounds_checking_function/include" - ] - deps = [ - "//third_party/bounds_checking_function:libsec_shared" - ] - - if (enable_audio_hal_notsupport_pathselect) { - defines += [ "AUDIO_HAL_NOTSUPPORT_PATHSELECT" ] - } - - ldflags = [ - "-L$ohos_root_path/sysroot/usr/lib", - "-Wl,-rpath-link=$ohos_root_path/sysroot/usr/lib", - "-lstdc++", - "-ldl", - "-lm" - ] - - public_configs = [ ":hdi_audio_config" ] + shared_library("hdi_audio") { + sources = [ + "$hdf_framework_path/support/posix/src/osal_time.c", + "//third_party/cJSON/cJSON.c", + "src/audio_adapter.c", + "src/audio_adapter_info_common.c", + "src/audio_capture.c", + "src/audio_common.c", + "src/audio_manager.c", + "src/audio_render.c", + ] + + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/supportlibs/adm_adapter/include", + "//third_party/cJSON", + "//drivers/peripheral/audio/interfaces/include", + "$hdf_framework_path/include/core", + "$hdf_framework_path/include/utils", + "$hdf_framework_path/include/osal", + "$hdf_framework_path/ability/sbuf/include", + "//drivers//adapter/khdf/liteos/osal/include", + "//third_party/bounds_checking_function/include", + ] + deps = [ "//third_party/bounds_checking_function:libsec_shared" ] + + if (enable_audio_hal_notsupport_pathselect) { + defines += [ "AUDIO_HAL_NOTSUPPORT_PATHSELECT" ] } + + ldflags = [ + "-L$ohos_root_path/sysroot/usr/lib", + "-Wl,-rpath-link=$ohos_root_path/sysroot/usr/lib", + "-lstdc++", + "-ldl", + "-lm", + ] + + public_configs = [ ":hdi_audio_config" ] + } } else { - ohos_shared_library("hdi_audio") { - sources = [ - "//third_party/cJSON/cJSON.c", - "src/audio_manager.c", - "src/audio_common.c", - "src/audio_adapter.c", - "src/audio_capture.c", - "src/audio_render.c", - "src/audio_adapter_info_common.c", - ] - - include_dirs = [ - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/supportlibs/adm_adapter/include", - "//third_party/cJSON", - "//drivers/peripheral/audio/interfaces/include", - "$hdf_framework_path/include/core", - "$hdf_framework_path/include/utils", - "$hdf_framework_path/include/osal", - "$hdf_framework_path/include", - "//third_party/bounds_checking_function/include", - "$hdf_framework_path/ability/sbuf/include", - "$hdf_framework_path/utils/include", - "$hdf_framework_path/ability/sbuf/include", - "$hdf_uhdf_path/osal/include", - "$hdf_uhdf_path/common/include/core", - ] - - deps = [ - "$hdf_uhdf_path/osal:libhdf_utils", - "$hdf_uhdf_path/manager:hdf_devmgr", - "$hdf_uhdf_path/manager:hdf_devmgr.rc", - "//utils/native/base:utils", - "$hdf_uhdf_path/hdi:libhdi", - "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", - "$hdf_uhdf_path/host:hdf_devhost", - "$hdf_uhdf_path/host:libhdf_host", - "$hdf_uhdf_path/config:libhdf_hcs", - "$hdf_uhdf_path/hcs:hdf_default.hcb", - ] - - defines = [] - if (enable_audio_device_mpi) { - defines += [ "AUDIO_HAL_USER" ] - } - - if (enable_audio_hal_notsupport_pathselect) { - defines += [ "AUDIO_HAL_NOTSUPPORT_PATHSELECT" ] - } - - if (is_standard_system) { - external_deps = [ "hiviewdfx_hilog_native:libhilog" ] - } else { - external_deps = [ "hilog:libhilog" ] - } - - public_configs = [ ":hdi_audio_config" ] - - subsystem_name = "hdf" + ohos_shared_library("hdi_audio") { + sources = [ + "//third_party/cJSON/cJSON.c", + "src/audio_adapter.c", + "src/audio_adapter_info_common.c", + "src/audio_capture.c", + "src/audio_common.c", + "src/audio_manager.c", + "src/audio_render.c", + ] + + include_dirs = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/supportlibs/adm_adapter/include", + "//third_party/cJSON", + "//drivers/peripheral/audio/interfaces/include", + "$hdf_framework_path/include/core", + "$hdf_framework_path/include/utils", + "$hdf_framework_path/include/osal", + "$hdf_framework_path/include", + "//third_party/bounds_checking_function/include", + "$hdf_framework_path/ability/sbuf/include", + "$hdf_framework_path/utils/include", + "$hdf_framework_path/ability/sbuf/include", + "$hdf_uhdf_path/osal/include", + "$hdf_uhdf_path/common/include/core", + ] + + deps = [ + "$hdf_uhdf_path/config:libhdf_hcs", + "$hdf_uhdf_path/hcs:hdf_default.hcb", + "$hdf_uhdf_path/hdi:libhdi", + "$hdf_uhdf_path/host:hdf_devhost", + "$hdf_uhdf_path/host:libhdf_host", + "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", + "$hdf_uhdf_path/manager:hdf_devmgr", + "$hdf_uhdf_path/manager:hdf_devmgr.rc", + "$hdf_uhdf_path/osal:libhdf_utils", + "//utils/native/base:utils", + ] + + defines = [] + if (enable_audio_device_mpi) { + defines += [ "AUDIO_HAL_USER" ] + } + + if (enable_audio_hal_notsupport_pathselect) { + defines += [ "AUDIO_HAL_NOTSUPPORT_PATHSELECT" ] + } + + if (is_standard_system) { + external_deps = [ "hiviewdfx_hilog_native:libhilog" ] + } else { + external_deps = [ "hilog:libhilog" ] } -} + public_configs = [ ":hdi_audio_config" ] + + subsystem_name = "hdf" + } +} diff --git a/audio/hal/pathselect/BUILD.gn b/audio/hal/pathselect/BUILD.gn index 15161ba210..04664f3121 100755 --- a/audio/hal/pathselect/BUILD.gn +++ b/audio/hal/pathselect/BUILD.gn @@ -49,10 +49,10 @@ config("pathseltct_config") { if (defined(ohos_lite)) { shared_library("hdi_audio_path_select") { sources = [ - "src/audio_pathselect.c", - "//third_party/cJSON/cJSON.c", "$hdf_framework_path/support/posix/src/osal_time.c", - "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_common.c" + "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_common.c", + "//third_party/cJSON/cJSON.c", + "src/audio_pathselect.c", ] include_dirs = [ @@ -74,20 +74,18 @@ if (defined(ohos_lite)) { "//third_party/bounds_checking_function/include", "//drivers/adapter/khdf/liteos/osal/include", "//drivers/adapter/uhdf2/shared/include", - "//drivers/adapter/uhdf2/include/hdi/" + "//drivers/adapter/uhdf2/include/hdi/", ] - deps = [ - "//third_party/bounds_checking_function:libsec_shared" - ] + deps = [ "//third_party/bounds_checking_function:libsec_shared" ] public_configs = [ ":pathseltct_config" ] } } else { ohos_shared_library("hdi_audio_path_select") { sources = [ - "//third_party/cJSON/cJSON.c", "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_common.c", + "//third_party/cJSON/cJSON.c", "src/audio_pathselect.c", ] @@ -104,20 +102,20 @@ if (defined(ohos_lite)) { "$hdf_framework_path/ability/sbuf/include", "$hdf_framework_path/utils/include", "$hdf_framework_path/ability/sbuf/include", - "$hdf_uhdf_path/osal/include" + "$hdf_uhdf_path/osal/include", ] deps = [ - "$hdf_uhdf_path/osal:libhdf_utils", - "$hdf_uhdf_path/manager:hdf_devmgr", - "$hdf_uhdf_path/manager:hdf_devmgr.rc", - "//utils/native/base:utils", + "$hdf_uhdf_path/config:libhdf_hcs", + "$hdf_uhdf_path/hcs:hdf_default.hcb", "$hdf_uhdf_path/hdi:libhdi", - "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", "$hdf_uhdf_path/host:hdf_devhost", "$hdf_uhdf_path/host:libhdf_host", - "$hdf_uhdf_path/config:libhdf_hcs", - "$hdf_uhdf_path/hcs:hdf_default.hcb", + "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", + "$hdf_uhdf_path/manager:hdf_devmgr", + "$hdf_uhdf_path/manager:hdf_devmgr.rc", + "$hdf_uhdf_path/osal:libhdf_utils", + "//utils/native/base:utils", ] if (is_standard_system) { @@ -130,4 +128,4 @@ if (defined(ohos_lite)) { subsystem_name = "hdf" } -} \ No newline at end of file +} diff --git a/audio/sample/BUILD.gn b/audio/sample/BUILD.gn index c925846770..206ec3194c 100755 --- a/audio/sample/BUILD.gn +++ b/audio/sample/BUILD.gn @@ -45,16 +45,12 @@ if (defined(ohos_lite)) { "$hdf_uhdf_path/host/include", "$hdf_uhdf_path/include", "$hdf_uhdf_path/common/security/include", - "//third_party/bounds_checking_function/include" + "//third_party/bounds_checking_function/include", ] - sources = [ - "framework_render.c", - ] - - deps = [ - "//third_party/bounds_checking_function:libsec_shared" - ] + sources = [ "framework_render.c" ] + + deps = [ "//third_party/bounds_checking_function:libsec_shared" ] defines = [] if (enable_audio_device_mpi) { @@ -87,17 +83,13 @@ if (defined(ohos_lite)) { "$hdf_uhdf_path/host/include", "$hdf_uhdf_path/include", "$hdf_uhdf_path/common/security/include", - "//third_party/bounds_checking_function/include" + "//third_party/bounds_checking_function/include", ] - sources = [ - "framework_capture.c", - ] + sources = [ "framework_capture.c" ] + + deps = [ "//third_party/bounds_checking_function:libsec_shared" ] - deps = [ - "//third_party/bounds_checking_function:libsec_shared" - ] - defines = [] if (enable_audio_device_mpi) { defines += [ "AUDIO_HAL_USER" ] @@ -131,21 +123,19 @@ if (defined(ohos_lite)) { "$hdf_uhdf_path/common/security/include", ] - sources = [ - "framework_render.c", - ] + sources = [ "framework_render.c" ] deps = [ - "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", + "$hdf_uhdf_path/config:libhdf_hcs", "$hdf_uhdf_path/hcs:hdf_default.hcb", - "//utils/native/base:utils", "$hdf_uhdf_path/hdi:libhdi", "$hdf_uhdf_path/host:hdf_devhost", "$hdf_uhdf_path/host:libhdf_host", - "$hdf_uhdf_path/config:libhdf_hcs", - "$hdf_uhdf_path/manager:hdf_devmgr.rc", + "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", "$hdf_uhdf_path/manager:hdf_devmgr", + "$hdf_uhdf_path/manager:hdf_devmgr.rc", "$hdf_uhdf_path/osal:libhdf_utils", + "//utils/native/base:utils", ] defines = [] @@ -190,21 +180,19 @@ if (defined(ohos_lite)) { "$hdf_uhdf_path/common/security/include", ] - sources = [ - "framework_capture.c", - ] + sources = [ "framework_capture.c" ] deps = [ - "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", + "$hdf_uhdf_path/config:libhdf_hcs", "$hdf_uhdf_path/hcs:hdf_default.hcb", - "//utils/native/base:utils", "$hdf_uhdf_path/hdi:libhdi", "$hdf_uhdf_path/host:hdf_devhost", "$hdf_uhdf_path/host:libhdf_host", - "$hdf_uhdf_path/config:libhdf_hcs", - "$hdf_uhdf_path/manager:hdf_devmgr.rc", + "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", "$hdf_uhdf_path/manager:hdf_devmgr", + "$hdf_uhdf_path/manager:hdf_devmgr.rc", "$hdf_uhdf_path/osal:libhdf_utils", + "//utils/native/base:utils", ] defines = [] @@ -222,4 +210,3 @@ if (defined(ohos_lite)) { subsystem_name = "hdf" } } - diff --git a/audio/supportlibs/adm_adapter/BUILD.gn b/audio/supportlibs/adm_adapter/BUILD.gn index 88803ca156..539545a97f 100755 --- a/audio/supportlibs/adm_adapter/BUILD.gn +++ b/audio/supportlibs/adm_adapter/BUILD.gn @@ -51,10 +51,10 @@ config("audio_interface_config") { if (defined(ohos_lite)) { shared_library("hdi_audio_interface_lib_capture") { sources = [ + "$hdf_framework_path/ability/sbuf/src/hdf_sbuf.c", + "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_common.c", "src/audio_interface_lib_capture.c", "src/audio_interface_lib_common.c", - "$hdf_framework_path/ability/sbuf/src/hdf_sbuf.c", - "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_common.c" ] include_dirs = [ @@ -71,14 +71,14 @@ if (defined(ohos_lite)) { "$hdf_framework_path/ability/sbuf/include", "$hdf_uhdf_path/osal/include", "//base/hiviewdfx/hilog_lite/interfaces/native/kits/", - "//device/hisilicon/hispark_taurus/sdk_linux/huawei_proprietary/include" + "//device/hisilicon/hispark_taurus/sdk_linux/huawei_proprietary/include", ] deps = [ - "//third_party/bounds_checking_function:libsec_shared", "//base/hiviewdfx/hilog_lite/frameworks/featured:hilog_shared", "//drivers/adapter/uhdf/manager:hdf_core", - "//drivers/adapter/uhdf/posix:hdf_posix_osal" + "//drivers/adapter/uhdf/posix:hdf_posix_osal", + "//third_party/bounds_checking_function:libsec_shared", ] public_configs = [ ":audio_interface_config" ] @@ -86,10 +86,10 @@ if (defined(ohos_lite)) { shared_library("hdi_audio_interface_lib_render") { sources = [ - "src/audio_interface_lib_render.c", - "src/audio_interface_lib_common.c", "$hdf_framework_path/ability/sbuf/src/hdf_sbuf.c", - "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_common.c" + "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_common.c", + "src/audio_interface_lib_common.c", + "src/audio_interface_lib_render.c", ] include_dirs = [ @@ -106,14 +106,14 @@ if (defined(ohos_lite)) { "$hdf_framework_path/ability/sbuf/include", "$hdf_uhdf_path/osal/include", "//base/hiviewdfx/hilog_lite/interfaces/native/kits/", - "//device/hisilicon/hispark_taurus/sdk_linux/huawei_proprietary/include" + "//device/hisilicon/hispark_taurus/sdk_linux/huawei_proprietary/include", ] deps = [ - "//third_party/bounds_checking_function:libsec_shared", "//base/hiviewdfx/hilog_lite/frameworks/featured:hilog_shared", "//drivers/adapter/uhdf/manager:hdf_core", - "//drivers/adapter/uhdf/posix:hdf_posix_osal" + "//drivers/adapter/uhdf/posix:hdf_posix_osal", + "//third_party/bounds_checking_function:libsec_shared", ] public_configs = [ ":audio_interface_config" ] @@ -121,9 +121,9 @@ if (defined(ohos_lite)) { } else { ohos_shared_library("hdi_audio_interface_lib_capture") { sources = [ + "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_common.c", "src/audio_interface_lib_capture.c", "src/audio_interface_lib_common.c", - "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_common.c" ] include_dirs = [ @@ -143,16 +143,16 @@ if (defined(ohos_lite)) { ] deps = [ - "$hdf_uhdf_path/osal:libhdf_utils", - "$hdf_uhdf_path/manager:hdf_devmgr", - "$hdf_uhdf_path/manager:hdf_devmgr.rc", - "//utils/native/base:utils", + "$hdf_uhdf_path/config:libhdf_hcs", + "$hdf_uhdf_path/hcs:hdf_default.hcb", "$hdf_uhdf_path/hdi:libhdi", - "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", "$hdf_uhdf_path/host:hdf_devhost", "$hdf_uhdf_path/host:libhdf_host", - "$hdf_uhdf_path/config:libhdf_hcs", - "$hdf_uhdf_path/hcs:hdf_default.hcb", + "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", + "$hdf_uhdf_path/manager:hdf_devmgr", + "$hdf_uhdf_path/manager:hdf_devmgr.rc", + "$hdf_uhdf_path/osal:libhdf_utils", + "//utils/native/base:utils", ] if (is_standard_system) { @@ -168,9 +168,9 @@ if (defined(ohos_lite)) { ohos_shared_library("hdi_audio_interface_lib_render") { sources = [ - "src/audio_interface_lib_render.c", - "src/audio_interface_lib_common.c", "//drivers/peripheral/audio/hal/hdi_passthrough/src/audio_common.c", + "src/audio_interface_lib_common.c", + "src/audio_interface_lib_render.c", ] include_dirs = [ @@ -190,16 +190,16 @@ if (defined(ohos_lite)) { ] deps = [ - "$hdf_uhdf_path/osal:libhdf_utils", - "$hdf_uhdf_path/manager:hdf_devmgr", - "$hdf_uhdf_path/manager:hdf_devmgr.rc", - "//utils/native/base:utils", + "$hdf_uhdf_path/config:libhdf_hcs", + "$hdf_uhdf_path/hcs:hdf_default.hcb", "$hdf_uhdf_path/hdi:libhdi", - "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", "$hdf_uhdf_path/host:hdf_devhost", "$hdf_uhdf_path/host:libhdf_host", - "$hdf_uhdf_path/config:libhdf_hcs", - "$hdf_uhdf_path/hcs:hdf_default.hcb", + "$hdf_uhdf_path/ipc:libhdf_ipc_adapter", + "$hdf_uhdf_path/manager:hdf_devmgr", + "$hdf_uhdf_path/manager:hdf_devmgr.rc", + "$hdf_uhdf_path/osal:libhdf_utils", + "//utils/native/base:utils", ] if (is_standard_system) { @@ -213,5 +213,3 @@ if (defined(ohos_lite)) { subsystem_name = "hdf" } } - - diff --git a/audio/test/hdf/BUILD.gn b/audio/test/hdf/BUILD.gn index 1e81f2b36b..eae60faba0 100755 --- a/audio/test/hdf/BUILD.gn +++ b/audio/test/hdf/BUILD.gn @@ -29,16 +29,16 @@ ohos_unittest("hdf_audio_adm_test") { "//drivers/framework/test/unittest/include", "//drivers/framework/test/unittest/osal", "//drivers/framework/test/unittest/model/audio/include", - "//drivers/framework/model/audio/core/test/unittest/common" + "//drivers/framework/model/audio/core/test/unittest/common", ] defines = [ "__USER__" ] sources = [ + "//drivers/framework/model/audio/core/test/unittest/common/audio_core_test.cpp", "//drivers/framework/model/audio/core/test/unittest/common/audio_host_test.cpp", "//drivers/framework/model/audio/core/test/unittest/common/audio_parse_test.cpp", - "//drivers/framework/model/audio/core/test/unittest/common/audio_core_test.cpp", - "//drivers/framework/model/audio/sapm/test/unittest/common/audio_sapm_test.cpp", "//drivers/framework/model/audio/dispatch/test/unittest/common/audio_stream_dispatch_test.cpp", + "//drivers/framework/model/audio/sapm/test/unittest/common/audio_sapm_test.cpp", ] deps = [ "//drivers/adapter/uhdf2/osal:libhdf_utils", @@ -63,7 +63,5 @@ ohos_unittest("hdf_audio_adm_test") { group("hdf_test_audio") { testonly = true - deps = [ - ":hdf_audio_adm_test" - ] + deps = [ ":hdf_audio_adm_test" ] } diff --git a/audio/test/systemtest/BUILD.gn b/audio/test/systemtest/BUILD.gn index 9a1734f404..17b2ad41e2 100755 --- a/audio/test/systemtest/BUILD.gn +++ b/audio/test/systemtest/BUILD.gn @@ -23,13 +23,13 @@ group("systemtest") { if (!defined(ohos_lite)) { testonly = true } - deps = [] + deps = [] - deps += [ - "adm_interface_lib:lib", - "audio_function:function", - "hdi:hdi", - "adm:adm", - ] + deps += [ + "adm:adm", + "adm_interface_lib:lib", + "audio_function:function", + "hdi:hdi", + ] } ############################################################################### diff --git a/audio/test/systemtest/adm/BUILD.gn b/audio/test/systemtest/adm/BUILD.gn index af403e310f..94edb43955 100755 --- a/audio/test/systemtest/adm/BUILD.gn +++ b/audio/test/systemtest/adm/BUILD.gn @@ -24,7 +24,5 @@ group("adm") { testonly = true } deps = [] - deps += [ - "audio_adm_interface:hdf_audio_adm_interface_test", - ] + deps += [ "audio_adm_interface:hdf_audio_adm_interface_test" ] } diff --git a/audio/test/systemtest/adm/audio_adm_interface/BUILD.gn b/audio/test/systemtest/adm/audio_adm_interface/BUILD.gn index d9d5bb367b..ed05aaad23 100755 --- a/audio/test/systemtest/adm/audio_adm_interface/BUILD.gn +++ b/audio/test/systemtest/adm/audio_adm_interface/BUILD.gn @@ -20,13 +20,13 @@ if (defined(ohos_lite)) { } if (defined(ohos_lite)) { -###########################-LITEOS-############################################ -###########################hdf_audio_adm_interface_test########################### + ###########################-LITEOS-############################################ + ###########################hdf_audio_adm_interface_test########################### unittest("hdf_audio_adm_interface_test") { sources = [ - "src/audio_adm_interface_test.cpp", "../../common/adm_common/src/audio_adm_common.cpp", "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_adm_interface_test.cpp", ] include_dirs = [ "//drivers/peripheral/audio/hal/hdi_passthrough/include", @@ -59,25 +59,26 @@ if (defined(ohos_lite)) { "-fsigned-char", "-fno-common", "-fno-strict-aliasing", - "-std=c++11" + "-std=c++11", ] deps = [ - "//third_party/bounds_checking_function:libsec_shared", "//base/hiviewdfx/hilog_lite/frameworks/featured:hilog_shared", "//drivers/adapter/uhdf/manager:hdf_core", - "//drivers/adapter/uhdf/posix:hdf_posix_osal" + "//drivers/adapter/uhdf/posix:hdf_posix_osal", + "//third_party/bounds_checking_function:libsec_shared", ] } } else { module_output_path = "hdf/audio" + ###########################hdf_audio_adm_interface_test########################### ohos_systemtest("hdf_audio_adm_interface_test") { module_out_path = module_output_path sources = [ - "src/audio_adm_interface_test.cpp", "../../common/adm_common/src/audio_adm_common.cpp", "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_adm_interface_test.cpp", ] include_dirs = [ @@ -109,18 +110,18 @@ if (defined(ohos_lite)) { "-fno-strict-aliasing", ] deps = [ - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - "//utils/native/base:utils", + "//drivers/adapter/uhdf2/config:libhdf_hcs", + "//drivers/adapter/uhdf2/hcs:hdf_default.hcb", "//drivers/adapter/uhdf2/hdi:libhdi", + "//drivers/adapter/uhdf2/host:hdf_devhost", + "//drivers/adapter/uhdf2/host:libhdf_host", + "//drivers/adapter/uhdf2/ipc:libhdf_ipc_adapter", "//drivers/adapter/uhdf2/manager:hdf_devmgr", "//drivers/adapter/uhdf2/manager:hdf_devmgr.rc", - "//drivers/adapter/uhdf2/ipc:libhdf_ipc_adapter", "//drivers/adapter/uhdf2/osal:libhdf_utils", - "//drivers/adapter/uhdf2/host:hdf_devhost", - "//drivers/adapter/uhdf2/host:libhdf_host", - "//drivers/adapter/uhdf2/config:libhdf_hcs", - "//drivers/adapter/uhdf2/hcs:hdf_default.hcb", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + "//utils/native/base:utils", ] defines = [] if (enable_audio_adm_so) { @@ -137,5 +138,6 @@ if (defined(ohos_lite)) { } } } + ###########################end########################### diff --git a/audio/test/systemtest/adm_interface_lib/BUILD.gn b/audio/test/systemtest/adm_interface_lib/BUILD.gn index 87ef6296d0..a72364ea2c 100755 --- a/audio/test/systemtest/adm_interface_lib/BUILD.gn +++ b/audio/test/systemtest/adm_interface_lib/BUILD.gn @@ -25,7 +25,7 @@ group("lib") { } deps = [] deps += [ - "render:hdf_audio_lib_render_test", "capture:hdf_audio_lib_capture_test", - ] -} \ No newline at end of file + "render:hdf_audio_lib_render_test", + ] +} diff --git a/audio/test/systemtest/adm_interface_lib/capture/BUILD.gn b/audio/test/systemtest/adm_interface_lib/capture/BUILD.gn index 6433a68b2f..96b254e001 100755 --- a/audio/test/systemtest/adm_interface_lib/capture/BUILD.gn +++ b/audio/test/systemtest/adm_interface_lib/capture/BUILD.gn @@ -20,14 +20,14 @@ if (defined(ohos_lite)) { } if (defined(ohos_lite)) { -###########################LITEOS########################################## -###########################hdf_audio_lib_capture_test########################### + ###########################LITEOS########################################## + ###########################hdf_audio_lib_capture_test########################### unittest("hdf_audio_lib_capture_test") { sources = [ - "src/audio_libcapture_test.cpp", - "../../common/lib_common/src/audio_lib_common.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "../../common/lib_common/src/audio_lib_common.cpp", + "src/audio_libcapture_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/supportlibs/adm_adapter/include", @@ -61,23 +61,22 @@ if (defined(ohos_lite)) { "-fsigned-char", "-fno-common", "-fno-strict-aliasing", - "-std=c++11" + "-std=c++11", ] - deps = [ - "//third_party/bounds_checking_function:libsec_shared" - ] + deps = [ "//third_party/bounds_checking_function:libsec_shared" ] } } else { module_output_path = "hdf/audio" + ###########################hdf_audio_lib_capture_test########################### ohos_systemtest("hdf_audio_lib_capture_test") { module_out_path = module_output_path sources = [ - "src/audio_libcapture_test.cpp", - "../../common/lib_common/src/audio_lib_common.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "../../common/lib_common/src/audio_lib_common.cpp", + "src/audio_libcapture_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/supportlibs/adm_adapter/include", @@ -110,9 +109,9 @@ if (defined(ohos_lite)) { "-fno-strict-aliasing", ] deps = [ - "//utils/native/base:utils", "//third_party/googletest:gmock_main", "//third_party/googletest:gtest_main", + "//utils/native/base:utils", ] defines = [] if (enable_audio_adm_so) { @@ -129,4 +128,4 @@ if (defined(ohos_lite)) { } } } -###########################end########################### \ No newline at end of file +###########################end########################### diff --git a/audio/test/systemtest/adm_interface_lib/render/BUILD.gn b/audio/test/systemtest/adm_interface_lib/render/BUILD.gn index 1736442139..f6e9ba3cac 100755 --- a/audio/test/systemtest/adm_interface_lib/render/BUILD.gn +++ b/audio/test/systemtest/adm_interface_lib/render/BUILD.gn @@ -20,14 +20,14 @@ if (defined(ohos_lite)) { } if (defined(ohos_lite)) { -###########################LITEOS########################################## + ###########################LITEOS########################################## ###########################hdf_audio_lib_render_test########################### unittest("hdf_audio_lib_render_test") { sources = [ - "src/audio_librender_test.cpp", - "../../common/lib_common/src/audio_lib_common.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "../../common/lib_common/src/audio_lib_common.cpp", + "src/audio_librender_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/supportlibs/adm_adapter/include", @@ -61,23 +61,22 @@ if (defined(ohos_lite)) { "-fsigned-char", "-fno-common", "-fno-strict-aliasing", - "-std=c++11" + "-std=c++11", ] - deps = [ - "//third_party/bounds_checking_function:libsec_shared" - ] + deps = [ "//third_party/bounds_checking_function:libsec_shared" ] } } else { module_output_path = "hdf/audio" + ###########################hdf_audio_lib_render_test########################### ohos_systemtest("hdf_audio_lib_render_test") { module_out_path = module_output_path sources = [ - "src/audio_librender_test.cpp", - "../../common/lib_common/src/audio_lib_common.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "../../common/lib_common/src/audio_lib_common.cpp", + "src/audio_librender_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/supportlibs/adm_adapter/include", @@ -110,9 +109,9 @@ if (defined(ohos_lite)) { "-fno-strict-aliasing", ] deps = [ - "//utils/native/base:utils", "//third_party/googletest:gmock_main", "//third_party/googletest:gtest_main", + "//utils/native/base:utils", ] defines = [] if (enable_audio_adm_so) { @@ -129,4 +128,4 @@ if (defined(ohos_lite)) { } } } -###########################end########################### \ No newline at end of file +###########################end########################### diff --git a/audio/test/systemtest/audio_function/BUILD.gn b/audio/test/systemtest/audio_function/BUILD.gn index 3f42b0e533..83feefbda4 100755 --- a/audio/test/systemtest/audio_function/BUILD.gn +++ b/audio/test/systemtest/audio_function/BUILD.gn @@ -24,8 +24,8 @@ group("function") { testonly = true } deps = [ - "audio_server:hdf_audio_hdi_server_function_test", "audio_pathroute:hdf_audio_hdi_path_route_test", - "audio_smartpa:hdf_audio_smartpa_test" + "audio_server:hdf_audio_hdi_server_function_test", + "audio_smartpa:hdf_audio_smartpa_test", ] } diff --git a/audio/test/systemtest/audio_function/audio_pathroute/BUILD.gn b/audio/test/systemtest/audio_function/audio_pathroute/BUILD.gn index baf0413266..1a4662c3a4 100755 --- a/audio/test/systemtest/audio_function/audio_pathroute/BUILD.gn +++ b/audio/test/systemtest/audio_function/audio_pathroute/BUILD.gn @@ -20,13 +20,13 @@ if (defined(ohos_lite)) { } if (defined(ohos_lite)) { -###########################LITEOS########################################## -###########################hdf_audio_hdi_path_route_test########################### + ###########################LITEOS########################################## + ###########################hdf_audio_hdi_path_route_test########################### unittest("hdf_audio_hdi_path_route_test") { sources = [ - "src/audio_pathroute_test.cpp", "../../common/hdi_common/src/audio_hdi_common.cpp", - "//drivers/framework/ability/sbuf/src/hdf_sbuf.c" + "//drivers/framework/ability/sbuf/src/hdf_sbuf.c", + "src/audio_pathroute_test.cpp", ] include_dirs = [ @@ -62,21 +62,22 @@ if (defined(ohos_lite)) { ] deps = [ - "//third_party/bounds_checking_function:libsec_shared", "//base/hiviewdfx/hilog_lite/frameworks/featured:hilog_shared", "//drivers/adapter/uhdf/manager:hdf_core", - "//drivers/adapter/uhdf/posix:hdf_posix_osal" + "//drivers/adapter/uhdf/posix:hdf_posix_osal", + "//third_party/bounds_checking_function:libsec_shared", ] } } else { module_output_path = "hdf/audio" + ###########################hdf_audio_hdi_path_route_test########################### ohos_systemtest("hdf_audio_hdi_path_route_test") { module_out_path = module_output_path sources = [ - "src/audio_pathroute_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_pathroute_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/hal/hdi_passthrough/include", @@ -106,18 +107,18 @@ if (defined(ohos_lite)) { "-fno-strict-aliasing", ] deps = [ - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - "//utils/native/base:utils", + "//drivers/adapter/uhdf2/config:libhdf_hcs", + "//drivers/adapter/uhdf2/hcs:hdf_default.hcb", "//drivers/adapter/uhdf2/hdi:libhdi", + "//drivers/adapter/uhdf2/host:hdf_devhost", + "//drivers/adapter/uhdf2/host:libhdf_host", + "//drivers/adapter/uhdf2/ipc:libhdf_ipc_adapter", "//drivers/adapter/uhdf2/manager:hdf_devmgr", "//drivers/adapter/uhdf2/manager:hdf_devmgr.rc", - "//drivers/adapter/uhdf2/ipc:libhdf_ipc_adapter", "//drivers/adapter/uhdf2/osal:libhdf_utils", - "//drivers/adapter/uhdf2/host:hdf_devhost", - "//drivers/adapter/uhdf2/host:libhdf_host", - "//drivers/adapter/uhdf2/config:libhdf_hcs", - "//drivers/adapter/uhdf2/hcs:hdf_default.hcb", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + "//utils/native/base:utils", ] defines = [] if (enable_audio_adm_so) { @@ -134,4 +135,4 @@ if (defined(ohos_lite)) { } } } -###########################end########################### \ No newline at end of file +###########################end########################### diff --git a/audio/test/systemtest/audio_function/audio_server/BUILD.gn b/audio/test/systemtest/audio_function/audio_server/BUILD.gn index 390a450f26..0db8a98b37 100755 --- a/audio/test/systemtest/audio_function/audio_server/BUILD.gn +++ b/audio/test/systemtest/audio_function/audio_server/BUILD.gn @@ -20,12 +20,12 @@ if (defined(ohos_lite)) { } if (defined(ohos_lite)) { -###########################LITEOS########################################## -###########################hdf_audio_hdi_server_function_test########################### + ###########################LITEOS########################################## + ###########################hdf_audio_hdi_server_function_test########################### unittest("hdf_audio_hdi_server_function_test") { sources = [ + "../../common/hdi_common/src/audio_hdi_common.cpp", "src/audio_server_function_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" ] include_dirs = [ @@ -54,17 +54,18 @@ if (defined(ohos_lite)) { "-fsigned-char", "-fno-common", "-fno-strict-aliasing", - "-std=c++11" + "-std=c++11", ] } } else { module_output_path = "hdf/audio" + ###########################hdf_audio_hdi_server_function_test########################### ohos_systemtest("hdf_audio_hdi_server_function_test") { module_out_path = module_output_path sources = [ + "../../common/hdi_common/src/audio_hdi_common.cpp", "src/audio_server_function_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" ] include_dirs = [ @@ -113,4 +114,4 @@ if (defined(ohos_lite)) { } } } -###########################end########################### \ No newline at end of file +###########################end########################### diff --git a/audio/test/systemtest/audio_function/audio_smartpa/BUILD.gn b/audio/test/systemtest/audio_function/audio_smartpa/BUILD.gn index 079f37211d..d88143f70b 100755 --- a/audio/test/systemtest/audio_function/audio_smartpa/BUILD.gn +++ b/audio/test/systemtest/audio_function/audio_smartpa/BUILD.gn @@ -15,16 +15,17 @@ import("//build/test.gni") import("//drivers/adapter/uhdf2/uhdf.gni") module_output_path = "hdf/audio" + ###########################systemtest############################## ###########################hdfAudioSmartPaTest########################### ohos_systemtest("hdfAudioSmartPaTest") { module_out_path = module_output_path sources = [ - "src/audio_smartpa_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp", - "../../common/lib_common/src/audio_lib_common.cpp", - "../../common/adm_common/src/audio_adm_common.cpp" - ] + "../../common/adm_common/src/audio_adm_common.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp", + "../../common/lib_common/src/audio_lib_common.cpp", + "src/audio_smartpa_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/supportlibs/adm_adapter/include", @@ -59,19 +60,19 @@ ohos_systemtest("hdfAudioSmartPaTest") { "-fno-strict-aliasing", ] deps = [ - "//utils/native/base:utils", - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - "//utils/native/base:utils", + "//drivers/adapter/uhdf2/config:libhdf_hcs", + "//drivers/adapter/uhdf2/hcs:hdf_default.hcb", "//drivers/adapter/uhdf2/hdi:libhdi", + "//drivers/adapter/uhdf2/host:hdf_devhost", + "//drivers/adapter/uhdf2/host:libhdf_host", + "//drivers/adapter/uhdf2/ipc:libhdf_ipc_adapter", "//drivers/adapter/uhdf2/manager:hdf_devmgr", "//drivers/adapter/uhdf2/manager:hdf_devmgr.rc", - "//drivers/adapter/uhdf2/ipc:libhdf_ipc_adapter", "//drivers/adapter/uhdf2/osal:libhdf_utils", - "//drivers/adapter/uhdf2/host:hdf_devhost", - "//drivers/adapter/uhdf2/host:libhdf_host", - "//drivers/adapter/uhdf2/config:libhdf_hcs", - "//drivers/adapter/uhdf2/hcs:hdf_default.hcb", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + "//utils/native/base:utils", + "//utils/native/base:utils", ] } -###########################end########################### \ No newline at end of file +###########################end########################### diff --git a/audio/test/systemtest/hdi/BUILD.gn b/audio/test/systemtest/hdi/BUILD.gn index a78e6ff03e..1343865c9e 100755 --- a/audio/test/systemtest/hdi/BUILD.gn +++ b/audio/test/systemtest/hdi/BUILD.gn @@ -27,25 +27,25 @@ group("hdi") { } deps = [ "adapter:hdf_audio_hdi_adapter_test", - "hdireliability:hdf_audio_hdi_capture_reliability_test", - "hdireliability:hdf_audio_hdi_render_reliability_test", + "capture:hdf_audio_hdi_capture_attr_test", + "capture:hdf_audio_hdi_capture_control_test", + "capture:hdf_audio_hdi_capture_scene_test", + "capture:hdf_audio_hdi_capture_test", + "capture:hdf_audio_hdi_capture_volume_test", "hdireliability:hdf_audio_hdi_capture_control_reliability_test", + "hdireliability:hdf_audio_hdi_capture_reliability_test", "hdireliability:hdf_audio_hdi_render_control_reliability_test", + "hdireliability:hdf_audio_hdi_render_reliability_test", "render:hdf_audio_hdi_render_attr_test", "render:hdf_audio_hdi_render_control_test", - "render:hdf_audio_hdi_render_volume_test", "render:hdf_audio_hdi_render_scene_test", "render:hdf_audio_hdi_render_test", - "capture:hdf_audio_hdi_capture_attr_test", - "capture:hdf_audio_hdi_capture_control_test", - "capture:hdf_audio_hdi_capture_volume_test", - "capture:hdf_audio_hdi_capture_scene_test", - "capture:hdf_audio_hdi_capture_test", - ] + "render:hdf_audio_hdi_render_volume_test", + ] if (!enable_audio_mpi_so && !enable_audio_mpi_service) { deps += [ + "hdiperformace:hdf_audio_hdi_capture_performace_test", "hdiperformace:hdf_audio_hdi_render_performace_test", - "hdiperformace:hdf_audio_hdi_capture_performace_test" ] } } diff --git a/audio/test/systemtest/hdi/adapter/BUILD.gn b/audio/test/systemtest/hdi/adapter/BUILD.gn index 8f9840b677..4d0c0a56e7 100755 --- a/audio/test/systemtest/hdi/adapter/BUILD.gn +++ b/audio/test/systemtest/hdi/adapter/BUILD.gn @@ -24,9 +24,9 @@ if (defined(ohos_lite)) { ###########################hdf_audio_hdi_adapter_test##################### unittest("hdf_audio_hdi_adapter_test") { sources = [ - "src/audio_hdiadapter_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdiadapter_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/interfaces/include", @@ -63,13 +63,14 @@ if (defined(ohos_lite)) { } else { ###########################NOT LITEOS############################## module_output_path = "hdf/audio" + ###########################hdf_audio_hdi_adapter_test##################### ohos_systemtest("hdf_audio_hdi_adapter_test") { module_out_path = module_output_path sources = [ - "src/audio_hdiadapter_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdiadapter_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/hal/hdi_passthrough/include", @@ -117,4 +118,4 @@ if (defined(ohos_lite)) { } } } -###########################end########################### \ No newline at end of file +###########################end########################### diff --git a/audio/test/systemtest/hdi/capture/BUILD.gn b/audio/test/systemtest/hdi/capture/BUILD.gn index 516cd821f2..4749f1cb34 100755 --- a/audio/test/systemtest/hdi/capture/BUILD.gn +++ b/audio/test/systemtest/hdi/capture/BUILD.gn @@ -20,13 +20,13 @@ if (defined(ohos_lite)) { } if (defined(ohos_lite)) { -###########################LITEOS########################################## + ###########################LITEOS########################################## ###########################hdf_audio_hdi_capture_attr_test##################### unittest("hdf_audio_hdi_capture_attr_test") { sources = [ - "src/audio_hdicapture_attr_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdicapture_attr_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/interfaces/include", @@ -46,7 +46,7 @@ if (defined(ohos_lite)) { "//third_party/bounds_checking_function/include", "//drivers/adapter/khdf/liteos/osal/include", "//drivers/adapter/uhdf2/shared/include", - "//drivers/adapter/uhdf2/include/hdi/" , + "//drivers/adapter/uhdf2/include/hdi/", "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", "//third_party/googletest/googletest/include/gtest", "//drivers/peripheral/audio/test/systemtest/hdi/capture/include", @@ -60,13 +60,14 @@ if (defined(ohos_lite)) { "-fno-strict-aliasing", ] } + ###########################end########################### ###########################hdf_audio_hdi_capture_control_test##################### unittest("hdf_audio_hdi_capture_control_test") { sources = [ - "src/audio_hdicapture_control_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdicapture_control_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/interfaces/include", @@ -86,7 +87,7 @@ if (defined(ohos_lite)) { "//third_party/bounds_checking_function/include", "//drivers/adapter/khdf/liteos/osal/include", "//drivers/adapter/uhdf2/shared/include", - "//drivers/adapter/uhdf2/include/hdi/" , + "//drivers/adapter/uhdf2/include/hdi/", "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", "//third_party/googletest/googletest/include/gtest", "//drivers/peripheral/audio/test/systemtest/hdi/capture/include", @@ -100,13 +101,14 @@ if (defined(ohos_lite)) { "-fno-strict-aliasing", ] } + ###########################end########################### ###########################hdf_audio_hdi_capture_volume_test##################### unittest("hdf_audio_hdi_capture_volume_test") { sources = [ - "src/audio_hdicapture_volume_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdicapture_volume_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/interfaces/include", @@ -126,7 +128,7 @@ if (defined(ohos_lite)) { "//third_party/bounds_checking_function/include", "//drivers/adapter/khdf/liteos/osal/include", "//drivers/adapter/uhdf2/shared/include", - "//drivers/adapter/uhdf2/include/hdi/" , + "//drivers/adapter/uhdf2/include/hdi/", "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", "//third_party/googletest/googletest/include/gtest", "//drivers/peripheral/audio/test/systemtest/hdi/capture/include", @@ -140,13 +142,14 @@ if (defined(ohos_lite)) { "-fno-strict-aliasing", ] } + ###########################end########################### ###########################hdf_audio_hdi_capture_scene_test##################### unittest("hdf_audio_hdi_capture_scene_test") { sources = [ - "src/audio_hdicapture_scene_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdicapture_scene_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/interfaces/include", @@ -166,7 +169,7 @@ if (defined(ohos_lite)) { "//third_party/bounds_checking_function/include", "//drivers/adapter/khdf/liteos/osal/include", "//drivers/adapter/uhdf2/shared/include", - "//drivers/adapter/uhdf2/include/hdi/" , + "//drivers/adapter/uhdf2/include/hdi/", "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", "//third_party/googletest/googletest/include/gtest", "//drivers/peripheral/audio/test/systemtest/hdi/capture/include", @@ -180,13 +183,14 @@ if (defined(ohos_lite)) { "-fno-strict-aliasing", ] } + ###########################end########################### ###########################hdf_audio_hdi_capture_test##################### unittest("hdf_audio_hdi_capture_test") { sources = [ - "src/audio_hdicapture_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdicapture_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/interfaces/include", @@ -206,7 +210,7 @@ if (defined(ohos_lite)) { "//third_party/bounds_checking_function/include", "//drivers/adapter/khdf/liteos/osal/include", "//drivers/adapter/uhdf2/shared/include", - "//drivers/adapter/uhdf2/include/hdi/" , + "//drivers/adapter/uhdf2/include/hdi/", "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", "//third_party/googletest/googletest/include/gtest", "//drivers/peripheral/audio/test/systemtest/hdi/capture/include", @@ -223,13 +227,14 @@ if (defined(ohos_lite)) { } else { ###########################systemtest############################## module_output_path = "hdf/audio" + ###########################hdf_audio_hdi_capture_attr_test##################### ohos_systemtest("hdf_audio_hdi_capture_attr_test") { module_out_path = module_output_path sources = [ - "src/audio_hdicapture_attr_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdicapture_attr_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/hal/hdi_passthrough/include", @@ -276,14 +281,15 @@ if (defined(ohos_lite)) { defines += [ "AUDIO_MPI_SERVICE" ] } } + ###########################end########################### ###########################hdf_audio_hdi_capture_control_test##################### ohos_systemtest("hdf_audio_hdi_capture_control_test") { module_out_path = module_output_path sources = [ - "src/audio_hdicapture_control_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdicapture_control_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/hal/hdi_passthrough/include", @@ -330,14 +336,15 @@ if (defined(ohos_lite)) { defines += [ "AUDIO_MPI_SERVICE" ] } } + ###########################end########################### ###########################hdf_audio_hdi_capture_volume_test##################### ohos_systemtest("hdf_audio_hdi_capture_volume_test") { module_out_path = module_output_path sources = [ - "src/audio_hdicapture_volume_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdicapture_volume_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/hal/hdi_passthrough/include", @@ -384,14 +391,15 @@ if (defined(ohos_lite)) { defines += [ "AUDIO_MPI_SERVICE" ] } } + ###########################end########################################### ###########################hdf_audio_hdi_capture_scene_test##################### ohos_systemtest("hdf_audio_hdi_capture_scene_test") { module_out_path = module_output_path sources = [ - "src/audio_hdicapture_scene_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdicapture_scene_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/hal/hdi_passthrough/include", @@ -438,14 +446,15 @@ if (defined(ohos_lite)) { defines += [ "AUDIO_MPI_SERVICE" ] } } + ###########################end########################### ###########################hdf_audio_hdi_capture_test##################### ohos_systemtest("hdf_audio_hdi_capture_test") { module_out_path = module_output_path sources = [ - "src/audio_hdicapture_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdicapture_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/hal/hdi_passthrough/include", @@ -493,4 +502,4 @@ if (defined(ohos_lite)) { } } } -###########################end########################### \ No newline at end of file +###########################end########################### diff --git a/audio/test/systemtest/hdi/hdiperformace/BUILD.gn b/audio/test/systemtest/hdi/hdiperformace/BUILD.gn index 39564653f6..7520293e6e 100755 --- a/audio/test/systemtest/hdi/hdiperformace/BUILD.gn +++ b/audio/test/systemtest/hdi/hdiperformace/BUILD.gn @@ -20,13 +20,13 @@ if (defined(ohos_lite)) { } if (defined(ohos_lite)) { -###########################LITEOS########################################## -###########################hdf_audio_hdi_render_performace_test##################### + ###########################LITEOS########################################## + ###########################hdf_audio_hdi_render_performace_test##################### unittest("hdf_audio_hdi_render_performace_test") { sources = [ - "src/audio_hdirender_performace_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdirender_performace_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/hal/hdi_passthrough/include", @@ -60,13 +60,14 @@ if (defined(ohos_lite)) { "-fno-strict-aliasing", ] } + ###########################end########################### ###########################hdf_audio_hdi_capture_performace_test##################### unittest("hdf_audio_hdi_capture_performace_test") { sources = [ - "src/audio_hdicapture_performace_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdicapture_performace_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/hal/hdi_passthrough/include", @@ -103,13 +104,14 @@ if (defined(ohos_lite)) { } else { ###########################SystemTest########################################## module_output_path = "hdf/audio" + ###########################hdf_audio_hdi_render_performace_test##################### ohos_systemtest("hdf_audio_hdi_render_performace_test") { module_out_path = module_output_path sources = [ - "src/audio_hdirender_performace_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdirender_performace_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/hal/hdi_passthrough/include", @@ -156,14 +158,15 @@ if (defined(ohos_lite)) { defines += [ "AUDIO_MPI_SERVICE" ] } } + ###########################end########################### ###########################hdf_audio_hdi_capture_performace_test##################### ohos_systemtest("hdf_audio_hdi_capture_performace_test") { module_out_path = module_output_path sources = [ - "src/audio_hdicapture_performace_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdicapture_performace_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/hal/hdi_passthrough/include", @@ -211,4 +214,4 @@ if (defined(ohos_lite)) { } } } -###########################end########################### \ No newline at end of file +###########################end########################### diff --git a/audio/test/systemtest/hdi/hdireliability/BUILD.gn b/audio/test/systemtest/hdi/hdireliability/BUILD.gn index 12e022fd57..48d1c9e6fd 100755 --- a/audio/test/systemtest/hdi/hdireliability/BUILD.gn +++ b/audio/test/systemtest/hdi/hdireliability/BUILD.gn @@ -20,13 +20,13 @@ if (defined(ohos_lite)) { } if (defined(ohos_lite)) { -###########################LITEOS########################################## + ###########################LITEOS########################################## ###########################hdf_audio_hdi_render_reliability_test########################### unittest("hdf_audio_hdi_render_reliability_test") { sources = [ - "src/audio_hdirender_reliability_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdirender_reliability_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/interfaces/include", @@ -46,7 +46,7 @@ if (defined(ohos_lite)) { "//third_party/bounds_checking_function/include", "//drivers/adapter/khdf/liteos/osal/include", "//drivers/adapter/uhdf2/shared/include", - "//drivers/adapter/uhdf2/include/hdi/" , + "//drivers/adapter/uhdf2/include/hdi/", "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", "//third_party/googletest/googletest/include/gtest", "//drivers/peripheral/audio/test/systemtest/hdi/hdireliability/include", @@ -58,20 +58,19 @@ if (defined(ohos_lite)) { "-fsigned-char", "-fno-common", "-fno-strict-aliasing", - "-std=c++11" + "-std=c++11", ] - deps = [ - "//third_party/bounds_checking_function:libsec_shared" - ] + deps = [ "//third_party/bounds_checking_function:libsec_shared" ] } + ###########################end########################### ###########################hdf_audio_hdi_capture_reliability_test########################### unittest("hdf_audio_hdi_capture_reliability_test") { sources = [ - "src/audio_hdicapture_reliability_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdicapture_reliability_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/interfaces/include", @@ -91,23 +90,22 @@ if (defined(ohos_lite)) { "//third_party/bounds_checking_function/include", "//drivers/adapter/khdf/liteos/osal/include", "//drivers/adapter/uhdf2/shared/include", - "//drivers/adapter/uhdf2/include/hdi/" , + "//drivers/adapter/uhdf2/include/hdi/", "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", "//third_party/googletest/googletest/include/gtest", "//drivers/peripheral/audio/test/systemtest/hdi/hdireliability/include", ] - deps = [ - "//third_party/bounds_checking_function:libsec_shared" - ] + deps = [ "//third_party/bounds_checking_function:libsec_shared" ] } + ###########################end########################### ###########################hdf_audio_hdi_capture_control_reliability_test########################### unittest("hdf_audio_hdi_capture_control_reliability_test") { sources = [ - "src/audio_hdicapture_control_reliability_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdicapture_control_reliability_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/interfaces/include", @@ -127,23 +125,22 @@ if (defined(ohos_lite)) { "//third_party/bounds_checking_function/include", "//drivers/adapter/khdf/liteos/osal/include", "//drivers/adapter/uhdf2/shared/include", - "//drivers/adapter/uhdf2/include/hdi/" , + "//drivers/adapter/uhdf2/include/hdi/", "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", "//third_party/googletest/googletest/include/gtest", "//drivers/peripheral/audio/test/systemtest/hdi/hdireliability/include", ] - deps = [ - "//third_party/bounds_checking_function:libsec_shared" - ] + deps = [ "//third_party/bounds_checking_function:libsec_shared" ] } + ###########################end########################### ###########################hdf_audio_hdi_render_control_reliability_test########################### unittest("hdf_audio_hdi_render_control_reliability_test") { sources = [ - "src/audio_hdirender_control_reliability_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdirender_control_reliability_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/interfaces/include", @@ -163,26 +160,25 @@ if (defined(ohos_lite)) { "//third_party/bounds_checking_function/include", "//drivers/adapter/khdf/liteos/osal/include", "//drivers/adapter/uhdf2/shared/include", - "//drivers/adapter/uhdf2/include/hdi/" , + "//drivers/adapter/uhdf2/include/hdi/", "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", "//third_party/googletest/googletest/include/gtest", "//drivers/peripheral/audio/test/systemtest/hdi/hdireliability/include", ] - deps = [ - "//third_party/bounds_checking_function:libsec_shared" - ] + deps = [ "//third_party/bounds_checking_function:libsec_shared" ] } } else { ###########################systemtest############################## module_output_path = "hdf/audio" + ###########################hdf_audio_hdi_render_reliability_test########################### ohos_systemtest("hdf_audio_hdi_render_reliability_test") { module_out_path = module_output_path sources = [ - "src/audio_hdirender_reliability_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdirender_reliability_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/hal/hdi_passthrough/include", @@ -205,9 +201,9 @@ if (defined(ohos_lite)) { "//drivers/peripheral/audio/test/systemtest/hdi/hdireliability/include", ] deps = [ - "//utils/native/base:utils", "//third_party/googletest:gmock_main", "//third_party/googletest:gtest_main", + "//utils/native/base:utils", ] cflags = [ "-Wall", @@ -231,14 +227,15 @@ if (defined(ohos_lite)) { defines += [ "AUDIO_MPI_SERVICE" ] } } + ###########################end########################### ###########################hdf_audio_hdi_capture_reliability_test########################### ohos_systemtest("hdf_audio_hdi_capture_reliability_test") { module_out_path = module_output_path sources = [ - "src/audio_hdicapture_reliability_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdicapture_reliability_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/hal/hdi_passthrough/include", @@ -261,9 +258,9 @@ if (defined(ohos_lite)) { "//drivers/peripheral/audio/test/systemtest/hdi/hdireliability/include", ] deps = [ - "//utils/native/base:utils", "//third_party/googletest:gmock_main", "//third_party/googletest:gtest_main", + "//utils/native/base:utils", ] cflags = [ "-Wall", @@ -287,14 +284,15 @@ if (defined(ohos_lite)) { defines += [ "AUDIO_MPI_SERVICE" ] } } + ###########################end########################### ###########################hdf_audio_hdi_capture_control_reliability_test########################### ohos_systemtest("hdf_audio_hdi_capture_control_reliability_test") { module_out_path = module_output_path sources = [ - "src/audio_hdicapture_control_reliability_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdicapture_control_reliability_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/hal/hdi_passthrough/include", @@ -317,9 +315,9 @@ if (defined(ohos_lite)) { "//drivers/peripheral/audio/test/systemtest/hdi/hdireliability/include", ] deps = [ - "//utils/native/base:utils", "//third_party/googletest:gmock_main", "//third_party/googletest:gtest_main", + "//utils/native/base:utils", ] cflags = [ "-Wall", @@ -343,14 +341,15 @@ if (defined(ohos_lite)) { defines += [ "AUDIO_MPI_SERVICE" ] } } + ###########################end########################### ###########################hdf_audio_hdi_render_control_reliability_test########################### ohos_systemtest("hdf_audio_hdi_render_control_reliability_test") { module_out_path = module_output_path sources = [ - "src/audio_hdirender_control_reliability_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdirender_control_reliability_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/hal/hdi_passthrough/include", @@ -373,9 +372,9 @@ if (defined(ohos_lite)) { "//drivers/peripheral/audio/test/systemtest/hdi/hdireliability/include", ] deps = [ - "//utils/native/base:utils", "//third_party/googletest:gmock_main", "//third_party/googletest:gtest_main", + "//utils/native/base:utils", ] cflags = [ "-Wall", @@ -400,4 +399,4 @@ if (defined(ohos_lite)) { } } } -###########################end########################### \ No newline at end of file +###########################end########################### diff --git a/audio/test/systemtest/hdi/render/BUILD.gn b/audio/test/systemtest/hdi/render/BUILD.gn index dd68c82db9..89560210ba 100755 --- a/audio/test/systemtest/hdi/render/BUILD.gn +++ b/audio/test/systemtest/hdi/render/BUILD.gn @@ -20,13 +20,13 @@ if (defined(ohos_lite)) { } if (defined(ohos_lite)) { -###########################LITEOS########################################## + ###########################LITEOS########################################## ###########################hdf_audio_hdi_render_attr_test###################### unittest("hdf_audio_hdi_render_attr_test") { sources = [ - "src/audio_hdirender_attr_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdirender_attr_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/interfaces/include", @@ -60,13 +60,14 @@ if (defined(ohos_lite)) { "-fno-strict-aliasing", ] } + ###########################end########################### ###########################hdf_audio_hdi_render_control_test###################### unittest("hdf_audio_hdi_render_control_test") { sources = [ - "src/audio_hdirender_control_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdirender_control_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/interfaces/include", @@ -100,13 +101,14 @@ if (defined(ohos_lite)) { "-fno-strict-aliasing", ] } + ###########################end########################### ###########################hdf_audio_hdi_render_volume_test###################### unittest("hdf_audio_hdi_render_volume_test") { sources = [ - "src/audio_hdirender_volume_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdirender_volume_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/interfaces/include", @@ -126,7 +128,7 @@ if (defined(ohos_lite)) { "//third_party/bounds_checking_function/include", "//drivers/adapter/khdf/liteos/osal/include", "//drivers/adapter/uhdf2/shared/include", - "//drivers/adapter/uhdf2/include/hdi/" , + "//drivers/adapter/uhdf2/include/hdi/", "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", "//third_party/googletest/googletest/include/gtest", "//drivers/peripheral/audio/test/systemtest/hdi/render/include", @@ -140,14 +142,14 @@ if (defined(ohos_lite)) { "-fno-strict-aliasing", ] } + ###########################end########################### ###########################hdf_audio_hdi_render_scene_test###################### unittest("hdf_audio_hdi_render_scene_test") { - sources = [ - "src/audio_hdirender_scene_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdirender_scene_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/interfaces/include", @@ -181,13 +183,14 @@ if (defined(ohos_lite)) { "-fno-strict-aliasing", ] } + ###########################end########################### ###########################hdf_audio_hdi_render_test###################### unittest("hdf_audio_hdi_render_test") { sources = [ - "src/audio_hdirender_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdirender_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/interfaces/include", @@ -224,13 +227,14 @@ if (defined(ohos_lite)) { } else { ###########################systemtest############################## module_output_path = "hdf/audio" + ###########################hdf_audio_hdi_render_attr_test###################### ohos_systemtest("hdf_audio_hdi_render_attr_test") { module_out_path = module_output_path sources = [ - "src/audio_hdirender_attr_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdirender_attr_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/hal/hdi_passthrough/include", @@ -277,14 +281,15 @@ if (defined(ohos_lite)) { defines += [ "AUDIO_MPI_SERVICE" ] } } + ###########################end########################### ###########################hdf_audio_hdi_render_control_test###################### ohos_systemtest("hdf_audio_hdi_render_control_test") { module_out_path = module_output_path sources = [ - "src/audio_hdirender_control_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdirender_control_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/hal/hdi_passthrough/include", @@ -331,14 +336,15 @@ if (defined(ohos_lite)) { defines += [ "AUDIO_MPI_SERVICE" ] } } + ###########################end########################### ###########################hdf_audio_hdi_render_volume_test###################### ohos_systemtest("hdf_audio_hdi_render_volume_test") { module_out_path = module_output_path sources = [ - "src/audio_hdirender_volume_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdirender_volume_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/hal/hdi_passthrough/include", @@ -385,14 +391,15 @@ if (defined(ohos_lite)) { defines += [ "AUDIO_MPI_SERVICE" ] } } + ###########################end########################### ###########################hdf_audio_hdi_render_scene_test###################### ohos_systemtest("hdf_audio_hdi_render_scene_test") { module_out_path = module_output_path sources = [ - "src/audio_hdirender_scene_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdirender_scene_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/hal/hdi_passthrough/include", @@ -439,14 +446,15 @@ if (defined(ohos_lite)) { defines += [ "AUDIO_MPI_SERVICE" ] } } + ###########################end########################### ###########################hdf_audio_hdi_render_test###################### ohos_systemtest("hdf_audio_hdi_render_test") { module_out_path = module_output_path sources = [ - "src/audio_hdirender_test.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp" - ] + "../../common/hdi_common/src/audio_hdi_common.cpp", + "src/audio_hdirender_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/hal/hdi_passthrough/include", @@ -494,4 +502,4 @@ if (defined(ohos_lite)) { } } } -###########################end########################### \ No newline at end of file +###########################end########################### diff --git a/audio/test/unittest/BUILD.gn b/audio/test/unittest/BUILD.gn index 51f10aa81c..01a2cf9256 100755 --- a/audio/test/unittest/BUILD.gn +++ b/audio/test/unittest/BUILD.gn @@ -7,13 +7,14 @@ module_output_path = "hdf/audio_hdi" ohos_unittest("AudioHdiTest") { module_out_path = module_output_path - sources = [ "common/audio_manager_test.cpp", - "common/audio_adapter_test.cpp", - "common/audio_render_test.cpp", - "common/audio_capture_test.cpp", - "common/audio_interface_lib_render_test.cpp", - "common/audio_interface_lib_capture_test.cpp" - ] + sources = [ + "common/audio_adapter_test.cpp", + "common/audio_capture_test.cpp", + "common/audio_interface_lib_capture_test.cpp", + "common/audio_interface_lib_render_test.cpp", + "common/audio_manager_test.cpp", + "common/audio_render_test.cpp", + ] include_dirs = [ "//drivers/peripheral/audio/test/unittest/common", @@ -33,11 +34,11 @@ ohos_unittest("AudioHdiTest") { deps = [ "$hdf_uhdf_path/osal:libhdf_utils", - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", "//drivers/peripheral/audio:hdi_audio", - "//drivers/peripheral/audio:hdi_audio_interface_lib_render", "//drivers/peripheral/audio:hdi_audio_interface_lib_capture", + "//drivers/peripheral/audio:hdi_audio_interface_lib_render", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", ] cflags = [ -- Gitee From abf2e2dcb1512197fc0f3a315000da554d13a374 Mon Sep 17 00:00:00 2001 From: vb6174 Date: Tue, 17 Aug 2021 08:57:47 +0000 Subject: [PATCH 3/4] modify gn format Signed-off-by: vb6174 --- audio/audio.gni | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/audio/audio.gni b/audio/audio.gni index 61f94ac29c..9a583159e2 100755 --- a/audio/audio.gni +++ b/audio/audio.gni @@ -2,16 +2,20 @@ #If set flag is false, the ADM version will be built; if set flag is true, the MPI version will be built. enable_audio_device_mpi = false + #If set flag is false, the pathselect will be built; if set flag is true, the notSupport pathselect version will be built. enable_audio_hal_notsupport_pathselect = false # testcase build switch #If flag is true, the ADM_SO version testcase will be built; if set flag is true, the other version will be built. enable_audio_adm_so = false + #If flag is true, the MPI_SO version testcase will be built; if set flag is true, the other version will be built. enable_audio_mpi_so = false + #If flag is true, the ADM_SERVICE version testcase will be built; if set flag is true, the other version will be built. enable_audio_adm_service = true + #If flag is true, the MPI_SERVICE version testcase will be built; if set flag is true, the other version will be built. enable_audio_mpi_service = false -#If all above flag is setted to false, it will build failure.so forbid setting all above flag to false. \ No newline at end of file +#If all above flag is setted to false, it will build failure.so forbid setting all above flag to false. -- Gitee From 82775256669b168da85ff2ecc737e7bd7b461893 Mon Sep 17 00:00:00 2001 From: vb6174 Date: Tue, 17 Aug 2021 11:55:40 +0000 Subject: [PATCH 4/4] update audio code Signed-off-by: vb6174 --- .../hdi_binder/server/src/hdf_audio_server.c | 26 +++ audio/hal/hdi_passthrough/src/audio_capture.c | 14 ++ audio/hal/hdi_passthrough/src/audio_render.c | 13 ++ audio/sample/framework_capture.c | 27 +++ audio/sample/framework_render.c | 33 ++- audio/test/{hdf => }/BUILD.gn | 0 .../audio_function/audio_smartpa/BUILD.gn | 191 ++++++++++++------ .../audio_smartpa/src/audio_smartpa_test.cpp | 191 ++++++++---------- 8 files changed, 332 insertions(+), 163 deletions(-) rename audio/test/{hdf => }/BUILD.gn (100%) diff --git a/audio/hal/hdi_binder/server/src/hdf_audio_server.c b/audio/hal/hdi_binder/server/src/hdf_audio_server.c index 2b17a4ccde..95b4b6dfa1 100755 --- a/audio/hal/hdi_binder/server/src/hdf_audio_server.c +++ b/audio/hal/hdi_binder/server/src/hdf_audio_server.c @@ -480,6 +480,17 @@ void AudioHdiServerRelease(struct HdfDeviceObject *deviceObject) return; } deviceObject->service = NULL; +#ifdef AUDIO_HAL_USER + if (g_mpiInitSo == NULL) { + return; + } + int32_t (*mpiExit)() = dlsym(g_mpiInitSo, "AudioMpiSysExit"); + if (mpiExit == NULL) { + return; + } + mpiExit(); + dlclose(g_mpiInitSo); +#endif return; } @@ -509,6 +520,21 @@ int AudioHdiServerInit(struct HdfDeviceObject *deviceObject) HDF_LOGE("%{public}s: deviceObject is null!", __func__); return HDF_FAILURE; } +#ifdef AUDIO_HAL_USER + g_mpiInitSo = dlopen(SO_INTERFACE_LIB_MPI_PATH, RTLD_LAZY); + if (g_mpiInitSo == NULL) { + LOG_FUN_ERR("Open so Fail, reason:%s", dlerror()); + return HDF_FAILURE; + } + int32_t (*mpiInit)() = dlsym(g_mpiInitSo, "AudioMpiSysInit"); + if (mpiInit == NULL) { + dlclose(g_mpiInitSo); + return HDF_FAILURE; + } + if (mpiInit() < 0) { + return HDF_FAILURE; + } +#endif return HDF_SUCCESS; } diff --git a/audio/hal/hdi_passthrough/src/audio_capture.c b/audio/hal/hdi_passthrough/src/audio_capture.c index 7e4c1880cd..0a03a094dd 100755 --- a/audio/hal/hdi_passthrough/src/audio_capture.c +++ b/audio/hal/hdi_passthrough/src/audio_capture.c @@ -849,6 +849,20 @@ int32_t AudioCaptureGetMmapPosition(AudioHandle handle, uint64_t *frames, struct if (capture == NULL || frames == NULL || time == NULL) { return HDF_FAILURE; } +#ifndef AUDIO_HAL_USER + InterfaceLibModeCaptureSo *pInterfaceLibModeCapture = AudioSoGetInterfaceLibModeCapture(); + if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) { + LOG_FUN_ERR("pInterfaceLibModeCapture Fail!"); + return HDF_FAILURE; + } + int32_t ret = (*pInterfaceLibModeCapture)(capture->devDataHandle, &capture->captureParam, + AUDIO_DRV_PCM_IOCTL_MMAP_POSITION_CAPTURE); + if (ret < 0) { + LOG_FUN_ERR("GetMmapPosition SetParams FAIL"); + return HDF_FAILURE; + } + LOG_PARA_INFO("GetMmapPosition SUCCESS!"); +#endif *frames = capture->captureParam.frameCaptureMode.frames; capture->captureParam.frameCaptureMode.time.tvSec = capture->captureParam.frameCaptureMode.frames / (int64_t)capture->captureParam.frameCaptureMode.attrs.sampleRate; diff --git a/audio/hal/hdi_passthrough/src/audio_render.c b/audio/hal/hdi_passthrough/src/audio_render.c index 9f8fb89b6e..8789c699e9 100755 --- a/audio/hal/hdi_passthrough/src/audio_render.c +++ b/audio/hal/hdi_passthrough/src/audio_render.c @@ -935,6 +935,19 @@ int32_t AudioRenderGetMmapPosition(AudioHandle handle, uint64_t *frames, struct if (render == NULL || frames == NULL || time == NULL) { return HDF_FAILURE; } +#ifndef AUDIO_HAL_USER + InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender(); + if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) { + LOG_FUN_ERR("pInterfaceLibModeRender Is NULL"); + return HDF_FAILURE; + } + int ret = (*pInterfaceLibModeRender)(render->devDataHandle, + &render->renderParam, AUDIO_DRV_PCM_IOCTL_MMAP_POSITION); + if (ret < 0) { + LOG_FUN_ERR("Get Position FAIL!"); + return HDF_FAILURE; + } +#endif *frames = render->renderParam.frameRenderMode.frames; render->renderParam.frameRenderMode.time.tvSec = render->renderParam.frameRenderMode.frames / (int64_t)render->renderParam.frameRenderMode.attrs.sampleRate; diff --git a/audio/sample/framework_capture.c b/audio/sample/framework_capture.c index 97a64bd982..74e506d7b8 100755 --- a/audio/sample/framework_capture.c +++ b/audio/sample/framework_capture.c @@ -639,6 +639,25 @@ int32_t InitParam() LOG_FUN_ERR("GetCapturePassthroughManagerFunc Fail"); return HDF_FAILURE; } +#ifdef AUDIO_HAL_USER + char sdkResolvedPath[] = "//system/lib/libhdi_audio_interface_lib_capture.z.so"; + g_sdkHandle = dlopen(sdkResolvedPath, 1); + if (g_sdkHandle == NULL) { + LOG_FUN_ERR("Open so Invalid, reason:%s", dlerror()); + return HDF_FAILURE; + } + g_sdkInitSp = (int32_t (*)())(dlsym(g_sdkHandle, "MpiSdkInit")); + if (g_sdkInitSp == NULL) { + LOG_FUN_ERR("Get sdk init Funcs Invalid"); + return HDF_FAILURE; + } + g_sdkExitSp = (void (*)())(dlsym(g_sdkHandle, "MpiSdkExit")); + if (g_sdkExitSp == NULL) { + LOG_FUN_ERR("Get sdk exit Funcs Invalid"); + return HDF_FAILURE; + } + g_sdkInitSp(); +#endif } else { // (strcmp(func,"GetAudioProxyManagerFuncs") == 0) if (GetCaptureProxyManagerFunc(adapterNameCase) < 0) { @@ -1058,6 +1077,14 @@ int32_t main(int32_t argc, char const *argv[]) } else { g_proxyManager->UnloadAdapter(g_proxyManager, g_adapter); } +#ifdef AUDIO_HAL_USER + if (soMode) { + g_sdkExitSp(); + if (g_sdkHandle != NULL) { + dlclose(g_sdkHandle); + } + } +#endif dlclose(g_handle); printf("Record file path:%s\n", g_path); return 0; diff --git a/audio/sample/framework_render.c b/audio/sample/framework_render.c index d85e4b0334..23ffd20c60 100755 --- a/audio/sample/framework_render.c +++ b/audio/sample/framework_render.c @@ -110,7 +110,11 @@ static int32_t g_closeEnd = 0; pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER; pthread_cond_t g_functionCond = PTHREAD_COND_INITIALIZER; int g_waitSleep = 0; - +#ifdef AUDIO_HAL_USER +void *g_sdkHandle; +int (*g_sdkInitSp)() = NULL; +void (*g_sdkExitSp)() = NULL; +#endif enum RenderMenuId { RENDER_START = 1, RENDER_STOP, @@ -783,6 +787,25 @@ int32_t InitParam() LOG_FUN_ERR("GetPassthroughManagerFunc Fail"); return HDF_FAILURE; } +#ifdef AUDIO_HAL_USER + char sdkResolvedPath[] = "//system/lib/libhdi_audio_interface_lib_render.z.so"; + g_sdkHandle = dlopen(sdkResolvedPath, 1); + if (g_sdkHandle == NULL) { + LOG_FUN_ERR("Open so Fail, reason:%s", dlerror()); + return HDF_FAILURE; + } + g_sdkInitSp = (int32_t (*)())(dlsym(g_sdkHandle, "MpiSdkInit")); + if (g_sdkInitSp == NULL) { + LOG_FUN_ERR("Get sdk init Funcs Fail"); + return HDF_FAILURE; + } + g_sdkExitSp = (void (*)())(dlsym(g_sdkHandle, "MpiSdkExit")); + if (g_sdkExitSp == NULL) { + LOG_FUN_ERR("Get sdk exit Funcs Fail"); + return HDF_FAILURE; + } + g_sdkInitSp(); +#endif } else { if (GetRenderProxyManagerFunc(adapterNameCase) < 0) { LOG_FUN_ERR("GetProxyManagerFunc Fail"); @@ -1192,6 +1215,14 @@ int32_t main(int32_t argc, char const *argv[]) } else { g_proxyManager->UnloadAdapter(g_proxyManager, g_adapter); } +#ifdef AUDIO_HAL_USER + if (soMode) { + g_sdkExitSp(); + if (g_sdkHandle != NULL) { + dlclose(g_sdkHandle); + } + } +#endif dlclose(g_handle); return 0; } diff --git a/audio/test/hdf/BUILD.gn b/audio/test/BUILD.gn similarity index 100% rename from audio/test/hdf/BUILD.gn rename to audio/test/BUILD.gn diff --git a/audio/test/systemtest/audio_function/audio_smartpa/BUILD.gn b/audio/test/systemtest/audio_function/audio_smartpa/BUILD.gn index d88143f70b..2f4445656e 100755 --- a/audio/test/systemtest/audio_function/audio_smartpa/BUILD.gn +++ b/audio/test/systemtest/audio_function/audio_smartpa/BUILD.gn @@ -11,68 +11,139 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build/test.gni") -import("//drivers/adapter/uhdf2/uhdf.gni") +if (defined(ohos_lite)) { + import("//build/lite/config/test.gni") +} else { + import("//build/test.gni") + import("//drivers/adapter/uhdf2/uhdf.gni") + import("//drivers/peripheral/audio/audio.gni") +} +if (defined(ohos_lite)) { + ###########################LITEOS########################################## + ###########################hdf_audio_smartpa_test########################### + unittest("hdf_audio_smartpa_test") { + sources = [ + "../../common/adm_common/src/audio_adm_common.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp", + "../../common/lib_common/src/audio_lib_common.cpp", + "src/audio_smartpa_test.cpp", + ] + + include_dirs = [ + "//drivers/peripheral/audio/supportlibs/adm_adapter/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/include", + "//third_party/bounds_checking_function/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/adapter/uhdf2/osal/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//drivers/peripheral/audio/test/systemtest/audio_function/audio_smartpa/include", + "//drivers/peripheral/audio/test/systemtest/common/lib_common/include", + "//drivers/peripheral/audio/test/systemtest/common/adm_common/include", + "//drivers/peripheral/audio/test/systemtest/adm_interface_lib/render/include", + "//drivers/peripheral/audio/test/systemtest/adm/audio_adm_interface/include", + "//third_party/googletest/googletest/include/gtest", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + "-std=c++11", + ] -module_output_path = "hdf/audio" + deps = [ + "//base/hiviewdfx/hilog_lite/frameworks/featured:hilog_shared", + "//drivers/adapter/uhdf/manager:hdf_core", + "//drivers/adapter/uhdf/posix:hdf_posix_osal", + "//third_party/bounds_checking_function:libsec_shared", + ] + } +} else { + module_output_path = "hdf/audio" -###########################systemtest############################## -###########################hdfAudioSmartPaTest########################### -ohos_systemtest("hdfAudioSmartPaTest") { - module_out_path = module_output_path - sources = [ - "../../common/adm_common/src/audio_adm_common.cpp", - "../../common/hdi_common/src/audio_hdi_common.cpp", - "../../common/lib_common/src/audio_lib_common.cpp", - "src/audio_smartpa_test.cpp", - ] + ###########################systemtest############################## + ###########################hdf_audio_smartpa_test########################### + ohos_systemtest("hdf_audio_smartpa_test") { + module_out_path = module_output_path + sources = [ + "../../common/adm_common/src/audio_adm_common.cpp", + "../../common/hdi_common/src/audio_hdi_common.cpp", + "../../common/lib_common/src/audio_lib_common.cpp", + "src/audio_smartpa_test.cpp", + ] - include_dirs = [ - "//drivers/peripheral/audio/supportlibs/adm_adapter/include", - "//drivers/peripheral/audio/hal/hdi_passthrough/include", - "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", - "//drivers/adapter/uhdf2/include/hdi", - "//drivers/adapter/uhdf2/shared/include", - "//drivers/peripheral/audio/interfaces/include", - "//drivers/framework/include/core", - "//drivers/framework/include/utils", - "//drivers/framework/include/osal", - "//drivers/framework/include", - "//third_party/bounds_checking_function/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/framework/utils/include", - "//drivers/framework/ability/sbuf/include", - "//drivers/adapter/uhdf2/osal/include", - "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", - "//drivers/peripheral/audio/test/systemtest/audio_function/audio_smartpa/include", - "//drivers/peripheral/audio/test/systemtest/common/lib_common/include", - "//drivers/peripheral/audio/test/systemtest/common/adm_common/include", - "//drivers/peripheral/audio/test/systemtest/adm_interface_lib/render/include", - "//drivers/peripheral/audio/test/systemtest/adm/audio_adm_interface/include", - "//third_party/googletest/googletest/include/gtest", - ] - cflags = [ - "-Wall", - "-Wextra", - "-Werror", - "-fsigned-char", - "-fno-common", - "-fno-strict-aliasing", - ] - deps = [ - "//drivers/adapter/uhdf2/config:libhdf_hcs", - "//drivers/adapter/uhdf2/hcs:hdf_default.hcb", - "//drivers/adapter/uhdf2/hdi:libhdi", - "//drivers/adapter/uhdf2/host:hdf_devhost", - "//drivers/adapter/uhdf2/host:libhdf_host", - "//drivers/adapter/uhdf2/ipc:libhdf_ipc_adapter", - "//drivers/adapter/uhdf2/manager:hdf_devmgr", - "//drivers/adapter/uhdf2/manager:hdf_devmgr.rc", - "//drivers/adapter/uhdf2/osal:libhdf_utils", - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - "//utils/native/base:utils", - "//utils/native/base:utils", - ] + include_dirs = [ + "//drivers/peripheral/audio/supportlibs/adm_adapter/include", + "//drivers/peripheral/audio/hal/hdi_passthrough/include", + "//drivers/peripheral/audio/hal/hdi_binder/proxy/include", + "//drivers/adapter/uhdf2/include/hdi", + "//drivers/adapter/uhdf2/shared/include", + "//drivers/peripheral/audio/interfaces/include", + "//drivers/framework/include/core", + "//drivers/framework/include/utils", + "//drivers/framework/include/osal", + "//drivers/framework/include", + "//third_party/bounds_checking_function/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/framework/utils/include", + "//drivers/framework/ability/sbuf/include", + "//drivers/adapter/uhdf2/osal/include", + "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include", + "//drivers/peripheral/audio/test/systemtest/audio_function/audio_smartpa/include", + "//drivers/peripheral/audio/test/systemtest/common/lib_common/include", + "//drivers/peripheral/audio/test/systemtest/common/adm_common/include", + "//drivers/peripheral/audio/test/systemtest/adm_interface_lib/render/include", + "//drivers/peripheral/audio/test/systemtest/adm/audio_adm_interface/include", + "//third_party/googletest/googletest/include/gtest", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + deps = [ + "//drivers/adapter/uhdf2/config:libhdf_hcs", + "//drivers/adapter/uhdf2/hcs:hdf_default.hcb", + "//drivers/adapter/uhdf2/hdi:libhdi", + "//drivers/adapter/uhdf2/host:hdf_devhost", + "//drivers/adapter/uhdf2/host:libhdf_host", + "//drivers/adapter/uhdf2/ipc:libhdf_ipc_adapter", + "//drivers/adapter/uhdf2/manager:hdf_devmgr", + "//drivers/adapter/uhdf2/manager:hdf_devmgr.rc", + "//drivers/adapter/uhdf2/osal:libhdf_utils", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + "//utils/native/base:utils", + "//utils/native/base:utils", + ] + defines = [] + if (enable_audio_adm_so) { + defines += [ "AUDIO_ADM_SO" ] + } + if (enable_audio_mpi_so) { + defines += [ "AUDIO_MPI_SO" ] + } + if (enable_audio_adm_service) { + defines += [ "AUDIO_ADM_SERVICE" ] + } + if (enable_audio_mpi_service) { + defines += [ "AUDIO_MPI_SERVICE" ] + } + } } ###########################end########################### diff --git a/audio/test/systemtest/audio_function/audio_smartpa/src/audio_smartpa_test.cpp b/audio/test/systemtest/audio_function/audio_smartpa/src/audio_smartpa_test.cpp index 8ec55fdc12..afbeb25438 100755 --- a/audio/test/systemtest/audio_function/audio_smartpa/src/audio_smartpa_test.cpp +++ b/audio/test/systemtest/audio_function/audio_smartpa/src/audio_smartpa_test.cpp @@ -21,7 +21,6 @@ using namespace testing::ext; using namespace HMOS::Audio; namespace { -const string AUDIO_FILE = "//bin/audiorendertest.wav"; const string ADAPTER_NAME_HDMI = "hdmi"; const string ADAPTER_NAME_USB = "usb"; const string ADAPTER_NAME_INTERNAL = "internal"; @@ -35,7 +34,7 @@ public: static void TearDownTestCase(void); void SetUp(); void TearDown(); - static struct AudioManager *(*GetAudioManager)(); + static TestAudioManager *(*GetAudioManager)(); static void *handleSo; static struct DevHandle *(*BindServiceRenderSo)(const char *); static int32_t (*InterfaceLibOutputRender)(struct DevHandle *, int, struct AudioHwRenderParam *); @@ -44,11 +43,11 @@ public: static void *PtrHandle; static int32_t GetManager(struct PrepareAudioPara& audiopara); uint32_t FrameSizeExpect(const struct AudioSampleAttributes attrs); - uint32_t BindServiceAndHwRender(struct AudioHwRender *&hwRender, const std::string BindName, + int32_t BindServiceAndHwRender(struct AudioHwRender *&hwRender, const std::string BindName, const std::string adapterNameCase, struct DevHandle *&handle) const; }; -struct AudioManager *(*AudioSmartPaTest::GetAudioManager)() = nullptr; +TestAudioManager *(*AudioSmartPaTest::GetAudioManager)() = nullptr; void *AudioSmartPaTest::handleSo = nullptr; struct DevHandle *(*AudioSmartPaTest::BindServiceRenderSo)(const char *) = nullptr; int32_t (*AudioSmartPaTest::InterfaceLibOutputRender)(struct DevHandle *, int, struct AudioHwRenderParam *) = nullptr; @@ -59,21 +58,19 @@ using THREAD_FUNC = void *(*)(void *); void AudioSmartPaTest::SetUpTestCase(void) { - string functionName = "GetAudioManagerFuncs"; - string resolvedPath = "//system/lib/libhdi_audio.z.so"; - if (IS_SERVICE) { - functionName = "GetAudioProxyManagerFuncs"; - resolvedPath = "//system/lib/libaudio_hdi_proxy_server.z.so"; - } - handleSo = dlopen(resolvedPath.c_str(), RTLD_LAZY); + handleSo = dlopen(RESOLVED_PATH.c_str(), RTLD_LAZY); if (handleSo == nullptr) { return; } - GetAudioManager = (struct AudioManager *(*)())(dlsym(handleSo, functionName.c_str())); + GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str())); if (GetAudioManager == nullptr) { return; } +#ifdef __LITEOS__ + string resolvedPathOne = "/usr/lib/libhdi_audio_interface_lib_render.so"; +#else string resolvedPathOne = "//system/lib/libhdi_audio_interface_lib_render.z.so"; +#endif PtrHandle = dlopen(resolvedPathOne.c_str(), RTLD_LAZY); if (PtrHandle == nullptr) { return; @@ -139,7 +136,7 @@ uint32_t AudioSmartPaTest::FrameSizeExpect(const struct AudioSampleAttributes at return sizeExpect; } -uint32_t AudioSmartPaTest::BindServiceAndHwRender(struct AudioHwRender *&hwRender, +int32_t AudioSmartPaTest::BindServiceAndHwRender(struct AudioHwRender *&hwRender, const std::string BindName, const std::string adapterNameCase, struct DevHandle *&handle) const { handle = BindServiceRenderSo(BindName.c_str()); @@ -154,6 +151,7 @@ uint32_t AudioSmartPaTest::BindServiceAndHwRender(struct AudioHwRender *&hwRende if (InitHwRender(hwRender, adapterNameCase)) { CloseServiceRenderSo(handle); free(hwRender); + hwRender = nullptr; return HDF_FAILURE; } return HDF_SUCCESS; @@ -167,33 +165,31 @@ uint32_t AudioSmartPaTest::BindServiceAndHwRender(struct AudioHwRender *&hwRende HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0001, TestSize.Level1) { int32_t ret = -1; - uint32_t latencyTime = 0; - uint32_t expectedValue = 0; struct PrepareAudioPara audiopara = { .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; + uint32_t latencyTime = 0; + uint32_t expectedValue = 0; ret = GetManager(audiopara); ASSERT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(ret, HDF_SUCCESS); - } + ASSERT_EQ(HDF_SUCCESS, ret); sleep(1); - ret = audiopara.render->GetLatency(audiopara.render, &latencyTime); - EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_LT(expectedValue, latencyTime); - ret = audiopara.render->control.Pause((AudioHandle)(audiopara.render)); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->control.Flush((AudioHandle)audiopara.render); - EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); - sleep(3); - ret = audiopara.render->control.Resume((AudioHandle)(audiopara.render)); - EXPECT_EQ(HDF_SUCCESS, ret); - + if (audiopara.render != nullptr) { + ret = audiopara.render->GetLatency(audiopara.render, &latencyTime); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_LT(expectedValue, latencyTime); + ret = audiopara.render->control.Pause((AudioHandle)(audiopara.render)); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->control.Flush((AudioHandle)audiopara.render); + EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); + sleep(1); + ret = audiopara.render->control.Resume((AudioHandle)(audiopara.render)); + EXPECT_EQ(HDF_SUCCESS, ret); + } ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); } @@ -207,32 +203,30 @@ HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0002, TestSize.Level1 { int32_t ret = -1; float volumeMax = 1.0; - float volumeValue[10] = {0}; - float volumeArr[10] = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0}; struct PrepareAudioPara audiopara = { .portType = PORT_OUT, .adapterName = ADAPTER_NAME_HDMI.c_str(), .self = this, .pins = PIN_OUT_SPEAKER, .path = AUDIO_FILE.c_str() }; + float volumeValue[10] = {0}; + float volumeArr[10] = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0}; ret = GetManager(audiopara); ASSERT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(ret, HDF_SUCCESS); - } + ASSERT_EQ(HDF_SUCCESS, ret); sleep(1); - ret = audiopara.render->volume.SetVolume(audiopara.render, volumeMax); - for (int i = 0; i < 10; i++) { - ret = audiopara.render->volume.SetVolume(audiopara.render, volumeArr[i]); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->volume.GetVolume(audiopara.render, &volumeValue[i]); - EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_EQ(volumeArr[i], volumeValue[i]); - sleep(3); + if (audiopara.render != nullptr) { + ret = audiopara.render->volume.SetVolume(audiopara.render, volumeMax); + for (int i = 0; i < 10; i++) { + ret = audiopara.render->volume.SetVolume(audiopara.render, volumeArr[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->volume.GetVolume(audiopara.render, &volumeValue[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(volumeArr[i], volumeValue[i]); + usleep(30000); + } } - ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); } @@ -254,25 +248,23 @@ HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0003, TestSize.Level1 ASSERT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + ASSERT_EQ(HDF_SUCCESS, ret); sleep(1); bool muteTrue = true; bool muteFalse = false; - ret = audiopara.render->volume.SetMute(audiopara.render, muteTrue); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->volume.GetMute(audiopara.render, &muteTrue); - EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_EQ(true, muteTrue); - sleep(3); - ret = audiopara.render->volume.SetMute(audiopara.render, muteFalse); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->volume.GetMute(audiopara.render, &muteFalse); - EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_EQ(false, muteFalse); - + if (audiopara.render != nullptr) { + ret = audiopara.render->volume.SetMute(audiopara.render, muteTrue); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->volume.GetMute(audiopara.render, &muteTrue); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(true, muteTrue); + sleep(1); + ret = audiopara.render->volume.SetMute(audiopara.render, muteFalse); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->volume.GetMute(audiopara.render, &muteFalse); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(false, muteFalse); + } ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); } @@ -297,16 +289,14 @@ HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0004, TestSize.Level1 ASSERT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(HDF_SUCCESS, ret); + ASSERT_EQ(HDF_SUCCESS, ret); + sleep(2); + if (audiopara.render != nullptr) { + ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &time); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(time.tvSec, timeExp); + EXPECT_GT(frames, INITIAL_VALUE); } - sleep(3); - ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &time); - EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_GT(time.tvSec, timeExp); - EXPECT_GT(frames, INITIAL_VALUE); - ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); } @@ -332,20 +322,18 @@ HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0005, TestSize.Level1 ASSERT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } + ASSERT_EQ(HDF_SUCCESS, ret); sleep(1); - ret = audiopara.render->attr.GetFrameSize(audiopara.render, &size); - EXPECT_EQ(HDF_SUCCESS, ret); - sizeExpect = FrameSizeExpect(audiopara.attrs); - EXPECT_EQ(size, sizeExpect); - - ret = audiopara.render->attr.GetFrameCount(audiopara.render, &count); - EXPECT_EQ(HDF_SUCCESS, ret); - EXPECT_GT(count, zero); + if (audiopara.render != nullptr) { + ret = audiopara.render->attr.GetFrameSize(audiopara.render, &size); + EXPECT_EQ(HDF_SUCCESS, ret); + sizeExpect = FrameSizeExpect(audiopara.attrs); + EXPECT_EQ(size, sizeExpect); + ret = audiopara.render->attr.GetFrameCount(audiopara.render, &count); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(count, zero); + } ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); } @@ -370,28 +358,27 @@ HWTEST_F(AudioSmartPaTest, SUB_Audio_Function_Smartpa_Test_0006, TestSize.Level1 ASSERT_EQ(HDF_SUCCESS, ret); ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara); - if (ret != 0) { - audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); - ASSERT_EQ(HDF_SUCCESS, ret); - } - sleep(1); - audiopara.attrs.type = AUDIO_IN_MEDIA; - audiopara.attrs.format = AUDIO_FORMAT_PCM_16_BIT; - audiopara.attrs.sampleRate = 48000; - audiopara.attrs.channelCount = 1; - audiopara.attrs.stopThreshold = INT_32_MAX; - - ret = audiopara.render->attr.SetSampleAttributes(audiopara.render, &(audiopara.attrs)); - EXPECT_EQ(HDF_SUCCESS, ret); - ret = audiopara.render->attr.GetSampleAttributes(audiopara.render, &attrsValue); - EXPECT_EQ(HDF_SUCCESS, ret); + ASSERT_EQ(HDF_SUCCESS, ret); - EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); - EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); - EXPECT_EQ(samplerateValue, attrsValue.sampleRate); - EXPECT_EQ(channelcountValue, attrsValue.channelCount); - EXPECT_EQ(INT_32_MAX, attrsValue.stopThreshold); + sleep(1); + if (audiopara.render != nullptr) { + audiopara.attrs.type = AUDIO_IN_MEDIA; + audiopara.attrs.format = AUDIO_FORMAT_PCM_16_BIT; + audiopara.attrs.sampleRate = 48000; + audiopara.attrs.channelCount = 1; + audiopara.attrs.stopThreshold = INT_32_MAX; + + ret = audiopara.render->attr.SetSampleAttributes(audiopara.render, &(audiopara.attrs)); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.render->attr.GetSampleAttributes(audiopara.render, &attrsValue); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format); + EXPECT_EQ(samplerateValue, attrsValue.sampleRate); + EXPECT_EQ(channelcountValue, attrsValue.channelCount); + EXPECT_EQ(INT_32_MAX, attrsValue.stopThreshold); + } ret = ThreadRelease(audiopara); EXPECT_EQ(HDF_SUCCESS, ret); } -- Gitee