diff --git a/audio/BUILD.gn b/audio/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..7e5100ba5c62a8546c81f7edfe3b6446b539272d --- /dev/null +++ b/audio/BUILD.gn @@ -0,0 +1,66 @@ +# 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") + +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", + ] + if (enable_audio_hal_notsupport_pathselect == false) { + deps += [ + ":hdf_audio_path_json", + "hal/pathselect/src:hdi_audio_path_select", + ] + } + } +} + +group("audio_test") { + if(is_standard_system) { + deps = [ + "sample:audio_test_render", + "sample:audio_test_capture", + ] + } +} + +ohos_prebuilt_etc("hdf_audio_json") { + if (is_standard_system) { + source = "//drivers/peripheral/audio/hal/hdi_passthrough/src/adapter_config.json" + relative_install_dir = "hdfconfig" + subsystem_name = "hdf" + part_name = "hdf" + } +} + +ohos_prebuilt_etc("hdf_audio_path_json") { + if (is_standard_system) { + source = "//drivers/peripheral/audio/hal/pathselect/src/parse.json" + relative_install_dir = "hdfconfig" + subsystem_name = "hdf" + part_name = "hdf" + } +} diff --git a/audio/audio.gni b/audio/audio.gni new file mode 100755 index 0000000000000000000000000000000000000000..4b337a5bc559a71ddd527e61c44d939bc33c5de4 --- /dev/null +++ b/audio/audio.gni @@ -0,0 +1,7 @@ +# Copyright (c) Huawei Technologies Co., Ltd. 2020-2020. 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 diff --git a/audio/chipsets/accessory/tfa9879_smartPA/include/tfa9879_codec.h b/audio/chipsets/accessory/tfa9879_smartPA/include/tfa9879_codec.h new file mode 100755 index 0000000000000000000000000000000000000000..fa832100383456a208f957c91552a4d5cd0049e4 --- /dev/null +++ b/audio/chipsets/accessory/tfa9879_smartPA/include/tfa9879_codec.h @@ -0,0 +1,142 @@ +/* + * 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 _TFA9879_CODEC_H +#define _TFA9879_CODEC_H + +#include "osal_mem.h" +#include "osal_time.h" +#include "osal_io.h" +#include "securec.h" +#include + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +/* Hi35xx IO register address */ +#define HI35XX_I2C_REG_BASE_ADDR 0x114F0000 +#define HI35XX_I2S_REG_BASE_ADDR 0x112F0000 + +typedef enum Hi35xxRegAddr { + IOCFG_REG36_ADDR = 0x114F0048, // I2C6_SCL + IOCFG_REG37_ADDR = 0x114F004C, // I2C6_SDA + IOCFG_REG73_ADDR = 0x112F0020, // I2S_MCLK + IOCFG_REG74_ADDR = 0x112F0024, // I2S_BCLK_TX + IOCFG_REG75_ADDR = 0x112F0028, // I2S_WS_TX + IOCFG_REG76_ADDR = 0x112F002C, // I2S_SD_TX + IOCFG_REG77_ADDR = 0x112F0030 // I2S_SD_RX +} Hi35xxRegAddr; + +/* TFA9879 I2C Device address 1 1 0 1 1 A2 A1 R/W */ +typedef enum Tfa9879I2cDevAddr { + TFA9879_I2C_DEV_ADDR_ADSEL1 = 0x6D, // 1101101 + TFA9879_I2C_DEV_ADDR_ADSEL2 = 0x6E, // 1101110 + TFA9879_I2C_DEV_ADDR_ADSEL1_READ = 0xDB, // 1101 1011 + TFA9879_I2C_DEV_ADDR_ADSEL1_WRITE = 0xDA, // 1101 1010 + TFA9879_I2C_DEV_ADDR_ADSEL2_READ = 0xDD, // 1101 1101 + TFA9879_I2C_DEV_ADDR_ADSEL2_WRITE = 0xDC // 1101 1100 +} Tfa9879I2cDevAddr; + +/* TFA9879 register address */ +#define TFA9879_REG_BASE_ADDR 0x00; +typedef enum Tfa9879RegAddr { + DEVICE_CONTROL_REG_ADDR = 0x00, + SERIAL_INTERFACE_INPUT1_REG_ADDR = 0x01, + PCM_IOM2_FMT_INPUT1_REG_ADDR = 0x02, + SERIAL_INTERFACE_INPUT2_REG_ADDR = 0x03, + PCM_IOM2_FMT_INPUT2_REG_ADDR = 0x04, + EQUALIZER_A_WORD1_REG_ADDR = 0x05, + EQUALIZER_A_WORD2_REG_ADDR = 0x06, + EQUALIZER_B_WORD1_REG_ADDR = 0x07, + EQUALIZER_B_WORD2_REG_ADDR = 0x08, + EQUALIZER_C_WORD1_REG_ADDR = 0x09, + EQUALIZER_C_WORD2_REG_ADDR = 0x0A, + EQUALIZER_D_WORD1_REG_ADDR = 0x0B, + EQUALIZER_D_WORD2_REG_ADDR = 0x0C, + EQUALIZER_E_WORD1_REG_ADDR = 0x0D, + EQUALIZER_E_WORD2_REG_ADDR = 0x0E, + BYPASS_CONTROL_REG_ADDR = 0x0F, + DYNAMIC_RANGE_COMP_REG_ADDR = 0x10, + BASS_TREBLE_REG_ADDR = 0x11, + HIGH_PASS_FILTER_REG_ADDR = 0x12, + VOLUME_CONTROL_REG_ADDR = 0x13, + DE_EMPHASIS_REG_ADDR = 0x14, + 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 +}; + +enum CodecOpMode { + OFF_MODE = 0, + AMPLIFIER_MODE = 1 +}; + +struct Tfa9879RegAttr { + uint8_t regAddr; + uint16_t regValue; // 16bit +}; + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif + +#endif diff --git a/audio/chipsets/accessory/tfa9879_smartPA/src/tfa9879_codec.c b/audio/chipsets/accessory/tfa9879_smartPA/src/tfa9879_codec.c new file mode 100755 index 0000000000000000000000000000000000000000..e83ab8cd85e32ecd7a31a24b7be04da3eda18e4e --- /dev/null +++ b/audio/chipsets/accessory/tfa9879_smartPA/src/tfa9879_codec.c @@ -0,0 +1,846 @@ +/* + * 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 "tfa9879_codec.h" +#include "accessory_adapter.h" +#include "audio_core.h" +#include "audio_device_log.h" +#include "audio_sapm.h" +#include "gpio_if.h" +#include "hdf_log.h" +#include "i2c_if.h" + +#define HDF_LOG_TAG "tfa9879_codec" + +#define CTRL_REG_NUM 21 + +#define CHANNEL_MAX_NUM 2 +#define CHANNEL_MIN_NUM 1 + +#define I2C_BUS_NUM 6 +#define I2C_8BIT 8 +#define I2C_REG_LEN 1 +#define I2C_MSG_NUM 2 +#define I2C_MSG_BUF_SIZE 2 +#define I2C_WAIT_TIMES 10 // ms + +#define VOLUME_MIN 0 +#define VOLUME_MAX 100 +#define MUTE__MAX 255 +#define MUTE_MIN 189 + +#define TFA9879_MSG_SIZE 2 +#define TFA9879_REG_MSGLEN 3 +#define TFA9879_RIGHT_SHIFT 8 +#define TFA9879_MUST_SLEEP 10 +#define TFA9879_REG_MASK 0xFF +#define TFA9879_REG_MASK_4 0xF +#define TFA9879_REG_MASK_16 0xFFFF + +const int MUTE_SHIFT = 9; +const int CHANNEL_SHIFT = 10; + +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; +} + +/* tfa9879 21 control register default value */ +struct Tfa9879RegAttr g_tfa9879RegDefaultAttr[] = { + { + .regAddr = DEVICE_CONTROL_REG_ADDR, + .regValue = 0x0001 // 0x0009 + }, { + .regAddr = SERIAL_INTERFACE_INPUT1_REG_ADDR, + .regValue = 0x0a18 // 48khz, up to 24 bits + }, { + .regAddr = PCM_IOM2_FMT_INPUT1_REG_ADDR, + .regValue = 0x0007 + }, { + .regAddr = SERIAL_INTERFACE_INPUT2_REG_ADDR, + .regValue = 0x0a18 + }, { + .regAddr = PCM_IOM2_FMT_INPUT2_REG_ADDR, + .regValue = 0x0007 + }, { + .regAddr = EQUALIZER_A_WORD1_REG_ADDR, + .regValue = 0x59DD + }, { + .regAddr = EQUALIZER_A_WORD2_REG_ADDR, + .regValue = 0xC63E + }, { + .regAddr = EQUALIZER_B_WORD1_REG_ADDR, + .regValue = 0x651A + }, { + .regAddr = EQUALIZER_B_WORD2_REG_ADDR, + .regValue = 0xE53E + }, { + .regAddr = EQUALIZER_C_WORD1_REG_ADDR, + .regValue = 0x4616 + }, { + .regAddr = EQUALIZER_C_WORD2_REG_ADDR, + .regValue = 0xD33E + }, { + .regAddr = EQUALIZER_D_WORD1_REG_ADDR, + .regValue = 0x4DF3 + }, { + .regAddr = EQUALIZER_D_WORD2_REG_ADDR, + .regValue = 0xEA3E + }, { + .regAddr = EQUALIZER_E_WORD1_REG_ADDR, + .regValue = 0x5EE0 + }, { + .regAddr = EQUALIZER_E_WORD2_REG_ADDR, + .regValue = 0xF93E + }, { + .regAddr = BYPASS_CONTROL_REG_ADDR, + .regValue = 0x0008 // 0x00ff // 0x0093 + }, { + .regAddr = DYNAMIC_RANGE_COMP_REG_ADDR, + .regValue = 0x92BA + }, { + .regAddr = BASS_TREBLE_REG_ADDR, + .regValue = 0x12A5 + }, { + .regAddr = HIGH_PASS_FILTER_REG_ADDR, + .regValue = 0x0004 + }, { + .regAddr = VOLUME_CONTROL_REG_ADDR, + .regValue = 0x1031 // 0x101A + }, { + .regAddr = DE_EMPHASIS_REG_ADDR, + .regValue = 0x0000 + } +}; + +/* + * release object public function + */ +static void ReleaseObject(struct I2cMsg *msgs, int16_t msgSize, DevHandle i2cHandle) +{ + if (msgs != NULL) { + if (msgSize == 0 && msgs->buf != NULL) { + OsalMemFree(msgs->buf); + msgs->buf = NULL; + } else if (msgSize == 1 && msgs[0].buf != NULL) { + OsalMemFree(msgs[0].buf); + msgs[0].buf = NULL; + } else if (msgSize >= TFA9879_MSG_SIZE) { + if (msgs[0].buf != NULL) { + msgs[0].buf = NULL; + } + if (msgs[1].buf != NULL) { + OsalMemFree(msgs[1].buf); + msgs[1].buf = NULL; + } + } + msgs = NULL; + AUDIO_DEVICE_LOG_DEBUG("OsalMemFree msgBuf success.\n"); + } + // close i2c device + if (i2cHandle != NULL) { + I2cClose(i2cHandle); + i2cHandle = NULL; + AUDIO_DEVICE_LOG_DEBUG("I2cClose success.\n"); + } +} + +static int Tfa9879FillMsg(const struct Tfa9879RegAttr *regAttr, uint16_t rwFlag, + uint8_t *regs, struct I2cMsg *msgs) +{ + uint8_t *msgBuf = NULL; + if (rwFlag != 0 && rwFlag != I2C_FLAG_READ) { + AUDIO_DEVICE_LOG_ERR("invalid rwFlag value: %d.", rwFlag); + return HDF_ERR_INVALID_PARAM; + } + regs[0] = regAttr->regAddr; + msgs[0].addr = g_i2cDevAddr; + msgs[0].flags = 0; + msgs[0].len = TFA9879_REG_MSGLEN; + AUDIO_DEVICE_LOG_DEBUG("msgs[0].addr=0x%02x, regs[0]=0x%02x.", msgs[0].addr, regs[0]); + if (rwFlag == 0) { // write + // S 11011A2A1 0 A ADDR A MS1 A LS1 A <....> P + msgBuf = OsalMemCalloc(TFA9879_REG_MSGLEN); + if (msgBuf == NULL) { + AUDIO_DEVICE_LOG_ERR("[write]: malloc buf fail!"); + return HDF_ERR_MALLOC_FAIL; + } + msgBuf[0] = regs[0]; + msgBuf[1] = (uint8_t)(regAttr->regValue >> I2C_8BIT); // High 8 bit + msgBuf[I2C_MSG_BUF_SIZE] = (uint8_t)(regAttr->regValue & TFA9879_REG_MASK); // Low 8 bit + msgs[0].buf = msgBuf; + AUDIO_DEVICE_LOG_DEBUG("msgBuf[1]=0x%02x.", msgBuf[1]); + AUDIO_DEVICE_LOG_DEBUG("msgBuf[2]=0x%02x.", msgBuf[I2C_MSG_BUF_SIZE]); + } else { + // S 11011A2A1 0 A ADDR A Sr 11011A2A1 1 A MS1 A LS1 A <....> NA P + msgBuf = OsalMemCalloc(I2C_MSG_NUM); + if (msgBuf == NULL) { + AUDIO_DEVICE_LOG_ERR("[read]: malloc buf fail!"); + return HDF_ERR_MALLOC_FAIL; + } + msgs[0].len = 1; + msgs[0].buf = regs; + msgs[1].addr = g_i2cDevAddr; + msgs[1].flags = I2C_FLAG_READ; + msgs[1].len = I2C_MSG_NUM; + msgs[1].buf = msgBuf; + } + AUDIO_DEVICE_LOG_DEBUG("fill msg success.\n"); + return HDF_SUCCESS; +} + +int Tfa9879RegRw(struct Tfa9879RegAttr *regAttr, uint16_t rwFlag) +{ + int ret; + DevHandle i2cHandle; + int16_t transferMsgCount = 1; + uint8_t regs[I2C_REG_LEN]; + struct I2cMsg msgs[I2C_MSG_NUM]; + AUDIO_DEVICE_LOG_DEBUG("entry.\n"); + if (regAttr == NULL || rwFlag < 0 || rwFlag > 1) { + AUDIO_DEVICE_LOG_ERR("invalid parameter."); + return HDF_ERR_INVALID_PARAM; + } + i2cHandle = I2cOpen(I2C_BUS_NUM); + if (i2cHandle == NULL) { + AUDIO_DEVICE_LOG_ERR("open i2cBus:%u fail! i2cHandle:%p", I2C_BUS_NUM, i2cHandle); + return HDF_FAILURE; + } + if (rwFlag == I2C_FLAG_READ) { + transferMsgCount = I2C_MSG_NUM; + } + ret = Tfa9879FillMsg(regAttr, rwFlag, regs, msgs); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("Tfa9879FillMsg failed!"); + I2cClose(i2cHandle); + return HDF_FAILURE; + } + ret = I2cTransfer(i2cHandle, msgs, transferMsgCount); + if (ret != transferMsgCount) { + AUDIO_DEVICE_LOG_ERR("I2cTransfer err:%d", ret); + ReleaseObject(msgs, transferMsgCount, i2cHandle); + return HDF_FAILURE; + } + if (rwFlag == I2C_FLAG_READ) { + regAttr->regValue = (msgs[1].buf[0] << TFA9879_RIGHT_SHIFT) | msgs[1].buf[1]; // result value 16 bit + AUDIO_DEVICE_LOG_DEBUG("[read]: regAttr->regValue=0x%04x.\n", regAttr->regValue); + } + ReleaseObject(msgs, transferMsgCount, i2cHandle); + return HDF_SUCCESS; +} + +static void Tfa9879GetStatus(void) +{ + int ret; + int high; + int low; + struct Tfa9879RegAttr regAttr = { + .regAddr = MISCELLANEOUS_STATUS_REG_ADDR, + .regValue = 0, + }; + ret = Tfa9879RegRw(®Attr, I2C_FLAG_READ); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("Tfa9879RegRw fail."); + return; + } + high = regAttr.regValue >> I2C_8BIT; // High 8 bit + low = regAttr.regValue & 0xFF; // Low 8 bit + AUDIO_DEVICE_LOG_DEBUG("regAttr.regValue=0x%02x%02x. \n", high, low); +} + +// get external codec I2S frequency +static int GetCodecI2sFrequency(struct I2cMsg *msg, uint16_t *fqVal) +{ + int ret; + struct Tfa9879RegAttr regAttr = { + .regAddr = SERIAL_INTERFACE_INPUT1_REG_ADDR, // 0x01 + .regValue = 0, + }; + if (msg == NULL || msg->len < TFA9879_MSG_SIZE || fqVal == NULL) { + AUDIO_DEVICE_LOG_ERR("invalid parameter."); + return HDF_ERR_INVALID_PARAM; + } + if (g_i2cDevAddr == TFA9879_I2C_DEV_ADDR_ADSEL2) { + regAttr.regAddr = SERIAL_INTERFACE_INPUT2_REG_ADDR; // 0x03 + } + ret = Tfa9879RegRw(®Attr, I2C_FLAG_READ); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("Tfa9879RegRw fail."); + return HDF_FAILURE; + } + msg->buf[0] = regAttr.regValue >> I2C_8BIT; // High 8 bit + msg->buf[1] = regAttr.regValue & TFA9879_REG_MASK; // Low 8 bit + *fqVal = (regAttr.regValue >> 6) & TFA9879_REG_MASK_4; // 01h/03h[9-6] + return HDF_SUCCESS; +} + +// set external codec I2S frequency +static int SetCodecI2sFrequency(uint16_t frequencyVal) +{ + int ret; + uint16_t oldVal; + uint16_t mask = 0x3C0; + struct I2cMsg oldMsg; + struct Tfa9879RegAttr regAttr; + // get current value + oldMsg.len = I2C_MSG_BUF_SIZE; + oldMsg.buf = OsalMemAlloc(I2C_MSG_BUF_SIZE); + if (oldMsg.buf == NULL) { + AUDIO_DEVICE_LOG_ERR("oldMsg.buf is null."); + return HDF_ERR_MALLOC_FAIL; + } + ret = GetCodecI2sFrequency(&oldMsg, &oldVal); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("GetCodecI2sFrequency fail."); + ReleaseObject(&oldMsg, 0, NULL); + return HDF_FAILURE; + } + // update current value + oldVal = (oldMsg.buf[0] << TFA9879_RIGHT_SHIFT) | oldMsg.buf[1]; // 16 bit + regAttr.regAddr = SERIAL_INTERFACE_INPUT1_REG_ADDR; + if (g_i2cDevAddr == TFA9879_I2C_DEV_ADDR_ADSEL2) { + regAttr.regAddr = SERIAL_INTERFACE_INPUT2_REG_ADDR; // 0x03 + } + regAttr.regValue = ((frequencyVal << 6) & mask) | (oldVal & ~mask); // 00h[6-9] + ret = Tfa9879RegRw(®Attr, 0); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("Tfa9879RegRw fail."); + ReleaseObject(&oldMsg, 0, NULL); + return HDF_FAILURE; + } + ReleaseObject(&oldMsg, 0, NULL); + AUDIO_DEVICE_LOG_DEBUG("success.\n"); + return HDF_SUCCESS; +} + +// get external codec I2S format +static int GetCodecI2sFormat(struct I2cMsg *msg, uint16_t *fsVal) +{ + int ret; + struct Tfa9879RegAttr regAttr = { + .regAddr = SERIAL_INTERFACE_INPUT1_REG_ADDR, // 0x01 + .regValue = 0, + }; + if (msg == NULL || msg->len < TFA9879_MSG_SIZE || fsVal == NULL) { + AUDIO_DEVICE_LOG_ERR("invalid parameter."); + return HDF_ERR_INVALID_PARAM; + } + if (g_i2cDevAddr == TFA9879_I2C_DEV_ADDR_ADSEL2) { + regAttr.regAddr = SERIAL_INTERFACE_INPUT2_REG_ADDR; // 0x03 + } + ret = Tfa9879RegRw(®Attr, I2C_FLAG_READ); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("Tfa9879RegRw fail."); + return HDF_FAILURE; + } + msg->buf[0] = regAttr.regValue >> I2C_8BIT; // High 8 bit + msg->buf[1] = regAttr.regValue & TFA9879_REG_MASK; // Low 8 bit + *fsVal = (regAttr.regValue >> 3) & TFA9879_REG_MASK_4; // 01h/03h[3-5] + return HDF_SUCCESS; +} + +// set external codec I2S format +static int SetCodecI2sFormat(uint16_t formatVal) +{ + int ret; + uint16_t oldVal; + uint16_t mask = 0x38; + struct I2cMsg oldMsg; + struct Tfa9879RegAttr regAttr; + // get current value + oldMsg.len = I2C_MSG_BUF_SIZE; + oldMsg.buf = OsalMemAlloc(I2C_MSG_BUF_SIZE); + if (oldMsg.buf == NULL) { + AUDIO_DEVICE_LOG_ERR("oldMsg.buf is null."); + return HDF_ERR_MALLOC_FAIL; + } + ret = GetCodecI2sFormat(&oldMsg, &oldVal); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("GetCodecI2sFrequency fail."); + ReleaseObject(&oldMsg, 0, NULL); + return HDF_FAILURE; + } + // update current value + oldVal = (oldMsg.buf[0] << TFA9879_RIGHT_SHIFT) | oldMsg.buf[1]; // 16 bit + regAttr.regAddr = SERIAL_INTERFACE_INPUT1_REG_ADDR; + if (g_i2cDevAddr == TFA9879_I2C_DEV_ADDR_ADSEL2) { + regAttr.regAddr = SERIAL_INTERFACE_INPUT2_REG_ADDR; // 0x03 + } + regAttr.regValue = ((formatVal << 3) & mask) | (oldVal & ~mask); // 00h[3-5] + ret = Tfa9879RegRw(®Attr, 0); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("Tfa9879RegRw fail."); + ReleaseObject(&oldMsg, 0, NULL); + return HDF_FAILURE; + } + ReleaseObject(&oldMsg, 0, NULL); + AUDIO_DEVICE_LOG_DEBUG("success.\n"); + return HDF_SUCCESS; +} + +// Init Function +/* + * gpio0_6 pin init +*/ +static int Gpio06PinInit(void) +{ + int ret; + const uint16_t gpio = 6; + char *regGpioBase = 0; + regGpioBase = (void *)OsalIoRemap(HI35XX_I2S_REG_BASE_ADDR, 0x10000); + if (regGpioBase == NULL) { + AUDIO_DEVICE_LOG_ERR("regGpioBase is null."); + return HDF_FAILURE; + } + SysWritel((uintptr_t)regGpioBase + 0x0034, 0x0400); // GPIO0_6 + if (regGpioBase != NULL) { + OsalIoUnmap(regGpioBase); + } + AUDIO_DEVICE_LOG_DEBUG("SYS_WRITEL success."); + ret = GpioSetDir(gpio, GPIO_DIR_OUT); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("%s: set gpio dir fail! ret:%d", __func__, ret); + return ret; + } + ret = GpioWrite(gpio, GPIO_VAL_HIGH); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("%s: write gpio val fail! ret:%d", __func__, ret); + return ret; + } + return HDF_SUCCESS; +} + +/* + * i2c6 init +*/ +static int I2c6PinInit(void) +{ + char *regI2cBase = 0; + regI2cBase = (void *)OsalIoRemap(HI35XX_I2C_REG_BASE_ADDR, 0x10000); + if (regI2cBase == NULL) { + AUDIO_DEVICE_LOG_ERR("regI2cBase is null."); + return HDF_FAILURE; + } + SysWritel((uintptr_t)regI2cBase + 0x0048, 0x0473); // I2C6_SCL + SysWritel((uintptr_t)regI2cBase + 0x004C, 0x0473); // I2C6_SDA + if (regI2cBase != NULL) { + OsalIoUnmap(regI2cBase); + } + return HDF_SUCCESS; +} + +/* + * i2s0 pin init +*/ +static void I2s0PinMux(char *regI2sBase) +{ + SysWritel((uintptr_t)regI2sBase + 0x0020, 0x673); // I2S_MCLK + SysWritel((uintptr_t)regI2sBase + 0x0024, 0x633); // I2S_BCLK_TX + SysWritel((uintptr_t)regI2sBase + 0x0028, 0x533); // I2S_WS_TX + SysWritel((uintptr_t)regI2sBase + 0x002C, 0x433); // I2S_SD_TX + SysWritel((uintptr_t)regI2sBase + 0x0030, 0x533); // I2S_SD_RX +} + +/* + * i2s init +*/ +static int I2sPinInit(void) +{ + char *regI2sBase = 0; + regI2sBase = (void *)OsalIoRemap(HI35XX_I2S_REG_BASE_ADDR, 0x10000); + if (regI2sBase == NULL) { + AUDIO_DEVICE_LOG_ERR("regI2sBase is null."); + return HDF_FAILURE; + } + I2s0PinMux(regI2sBase); + if (regI2sBase != NULL) { + OsalIoUnmap(regI2sBase); + } + return HDF_SUCCESS; +} + +/* + * init default value + */ +static int Tfa9879RegDefaultInit() +{ + int ret, i; + struct Tfa9879RegAttr regAttr; + // Set current i2c dev addr + g_i2cDevAddr = TFA9879_I2C_DEV_ADDR_ADSEL1; + // Set codec control register(00h-14h) default value + for (i = 0; i < CTRL_REG_NUM; i++) { + regAttr = g_tfa9879RegDefaultAttr[i]; + AUDIO_DEVICE_LOG_DEBUG("REG = [%02d], Addr = [0x%2x]", i, regAttr.regAddr); + ret = Tfa9879RegRw(®Attr, 0); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("Tfa9879RegRw(write) err, regAttr.regAddr: 0x%02x.\n", + regAttr.regAddr); + return HDF_FAILURE; + } + if (i == 0) { + OsalMSleep(TFA9879_MUST_SLEEP); // MUST > 5.6 ms + } + AUDIO_DEVICE_LOG_DEBUG("Tfa9879RegRw success.i=%d", i); + OsalMSleep(I2C_WAIT_TIMES); + } + // WORK + regAttr.regAddr = DEVICE_CONTROL_REG_ADDR; + regAttr.regValue = 0x09; + ret = Tfa9879RegRw(®Attr, 0); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("Tfa9879RegRw(write) err, regAttr.regAddr: 0x%02x.\n", + regAttr.regAddr); + return HDF_FAILURE; + } + Tfa9879GetStatus(); + AUDIO_DEVICE_LOG_DEBUG("success.\n"); + return HDF_SUCCESS; +} + +/* + * codec init +*/ +static int CodecTfa9879DeviceInit(void) +{ + int ret; + AUDIO_DEVICE_LOG_DEBUG("entry."); + ret = Gpio06PinInit(); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("Gpio06PinInit fail."); + return HDF_FAILURE; + } + AUDIO_DEVICE_LOG_DEBUG("Gpio06PinInit success."); + ret = I2c6PinInit(); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("I2c6PinInit fail."); + return HDF_FAILURE; + } + AUDIO_DEVICE_LOG_DEBUG("I2c6PinInit success."); + // Initial tfa9879 register + ret = Tfa9879RegDefaultInit(); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("Tfa9879RegDefaultInit fail."); + return HDF_FAILURE; + } + AUDIO_DEVICE_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +/* Tfa9879 Special Region End */ + +/* ADM Framework Region Begin */ +static const struct AudioMixerControl g_tfa9879AudioRegParams[] = { + { + .reg = VOLUME_CONTROL_REG_ADDR, /* output volume */ + .rreg = VOLUME_CONTROL_REG_ADDR, + .shift = 0, + .rshift = 0, + .min = 0x0, + .max = 0xBC, + .mask = 0xFF, + .invert = 1, + }, { + .reg = DE_EMPHASIS_REG_ADDR, /* output mute */ + .rreg = DE_EMPHASIS_REG_ADDR, // hard mute; + .shift = MUTE_SHIFT, + .rshift = MUTE_SHIFT, + .min = 0x0, + .max = 0x1, + .mask = 0x1, + .invert = 0, + }, { + .reg = SERIAL_INTERFACE_INPUT1_REG_ADDR, /* left or right channel (output) */ + .rreg = SERIAL_INTERFACE_INPUT1_REG_ADDR, + .shift = CHANNEL_SHIFT, + .rshift = CHANNEL_SHIFT, + .min = 0x0, + .max = 0x3, + .mask = 0xC00, + .invert = 0, + }, +}; + +static const struct AudioKcontrol g_tfa9879AudioControls[] = { + { + .iface = AUDIODRV_CTL_ELEM_IFACE_DAC, + .name = "Master Playback Volume", + .Info = AudioInfoCtrlSw, + .Get = AudioGetCtrlSw, + .Put = AudioPutCtrlSw, + .privateValue = (unsigned long) &g_tfa9879AudioRegParams[0], + }, { + .iface = AUDIODRV_CTL_ELEM_IFACE_DAC, + .name = "Playback Mute", + .Info = AudioInfoCtrlSw, + .Get = AudioGetCtrlSw, + .Put = AudioPutCtrlSw, + .privateValue = (unsigned long) &g_tfa9879AudioRegParams[1], + }, { + .iface = AUDIODRV_CTL_ELEM_IFACE_AIAO, + .name = "Render Channel Mode", + .Info = AudioInfoCtrlSw, + .Get = AiaoGetCtrlSw, + .Put = AiaoPutCtrlSw, + .privateValue = (unsigned long) &g_tfa9879AudioRegParams[2], + }, +}; + +int32_t ExternalCodecDeviceInit(struct AudioCard *audioCard, const struct AccessoryDevice *device) +{ + int32_t ret; + AUDIO_DEVICE_LOG_DEBUG(" entry."); + if ((audioCard == NULL) || (device == NULL)) { + AUDIO_DEVICE_LOG_ERR("input para is NULL."); + return HDF_ERR_INVALID_OBJECT; + } + ret = (int32_t)CodecTfa9879DeviceInit(); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("init tfa9979 device fail."); + return HDF_FAILURE; + } + ret = AudioAddControls(audioCard, g_tfa9879AudioControls, ARRAY_SIZE(g_tfa9879AudioControls)); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("add controls fail."); + return HDF_FAILURE; + } + AUDIO_DEVICE_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +static int32_t TransformGetCtrlResult(uint32_t reg, const uint16_t *resVal) +{ + int32_t ret = HDF_SUCCESS; + uint8_t hightByte; + uint8_t lowByte; + if (reg < 0 || resVal == NULL) { + AUDIO_DEVICE_LOG_ERR("input para is NULL."); + return HDF_ERR_INVALID_OBJECT; + } + if (reg == VOLUME_CONTROL_REG_ADDR) { + hightByte = (*resVal) >> I2C_8BIT; // High 8 bit + lowByte = (*resVal) & 0xFF; // Low 8 bit + AUDIO_DEVICE_LOG_DEBUG("hightByte=0x%x, lowByte=0x%x.\n", hightByte, lowByte); + if (lowByte < VOLUME_MIN && lowByte > MUTE__MAX) { + AUDIO_DEVICE_LOG_ERR("fail\n"); + return HDF_FAILURE; + } + AUDIO_DEVICE_LOG_DEBUG("resVal=%d.\n", *resVal); + } + return ret; +} + +int32_t ExternalCodecDeviceReadReg(const struct AccessoryDevice *codec, uint32_t reg, uint32_t *val) +{ + int32_t ret; + struct Tfa9879RegAttr regAttr; + uint16_t tmpVal; + AUDIO_DEVICE_LOG_DEBUG("entry"); + if (val == NULL) { + AUDIO_DEVICE_LOG_ERR("input para is NULL."); + return HDF_ERR_INVALID_OBJECT; + } + (void)codec; + regAttr.regAddr = (uint8_t)reg; + regAttr.regValue = 0; + ret = Tfa9879RegRw(®Attr, I2C_FLAG_READ); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("Tfa9879RegRw fail."); + return HDF_FAILURE; + } + tmpVal = regAttr.regValue; + ret = TransformGetCtrlResult(reg, &tmpVal); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("TransformGetCtrlResult fail, reg=0x%x.", reg); + return HDF_FAILURE; + } + *val = tmpVal; + AUDIO_DEVICE_LOG_DEBUG("success"); + return HDF_SUCCESS; +} + +static int32_t TransformSetCtrlVal(uint32_t reg, uint16_t *val) +{ + int32_t ret = HDF_SUCCESS; + uint8_t hightByte; + uint8_t lowByte; + if (reg < 0 || val == NULL) { + AUDIO_DEVICE_LOG_ERR("input para is NULL."); + return HDF_ERR_INVALID_OBJECT; + } + if (reg == VOLUME_CONTROL_REG_ADDR) { + hightByte = (*val) >> I2C_8BIT; // High 8 bit + lowByte = (*val) & 0xFF; // Low 8 bit + AUDIO_DEVICE_LOG_DEBUG("hightByte=0x%x, lowByte=0x%x.\n", hightByte, lowByte); + *val = (hightByte << TFA9879_RIGHT_SHIFT) | lowByte; + AUDIO_DEVICE_LOG_DEBUG("val=%d.\n", *val); + } + return ret; +} + +int32_t ExternalCodecDeviceWriteReg(const struct AccessoryDevice *codec, uint32_t reg, uint32_t value) +{ + int32_t ret; + struct Tfa9879RegAttr regAttr; + uint16_t tmpVal; + AUDIO_DEVICE_LOG_DEBUG("entry"); + (void)codec; + tmpVal = (uint16_t)value; + ret = TransformSetCtrlVal(reg, &tmpVal); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("TransformSetCtrlVal fail, reg=0x%x.", reg); + return HDF_FAILURE; + } + regAttr.regAddr = (uint8_t)reg; + regAttr.regValue = tmpVal; + ret = Tfa9879RegRw(®Attr, 0); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("Tfa9879RegRw fail."); + return HDF_FAILURE; + } + AUDIO_DEVICE_LOG_DEBUG("success"); + return HDF_SUCCESS; +} + +int32_t ExternalCodecDaiStartup(const struct AudioCard *card, const struct DaiDevice *device) +{ + (void)card; + (void)device; + return HDF_SUCCESS; +} + +static int32_t FormatToBitWidth(enum AudioFormat format, uint16_t *bitWidth) +{ + // 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; + } + return HDF_SUCCESS; +} + +static int32_t RateToFrequency(uint32_t rate, uint16_t *freq) +{ + 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; + } + return HDF_SUCCESS; +} + +int32_t ExternalCodecDaiHwParams(const struct AudioCard *card, const struct AudioPcmHwParams *param, + const struct DaiDevice *device) +{ + int ret; + uint16_t frequency, bitWidth; + (void)card; + (void)device; + AUDIO_DEVICE_LOG_DEBUG("entry."); + if (param == NULL || param->cardServiceName == NULL) { + AUDIO_DEVICE_LOG_ERR("input para is NULL."); + return HDF_ERR_INVALID_PARAM; + } + ret = I2sPinInit(); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("I2sPinInit fail."); + } + ret = RateToFrequency(param->rate, &frequency); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("RateToFrequency fail."); + return HDF_ERR_NOT_SUPPORT; + } + ret = FormatToBitWidth(param->format, &bitWidth); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("FormatToBitWidth fail."); + return HDF_ERR_NOT_SUPPORT; + } + ret = SetCodecI2sFrequency(frequency); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("SetCodecI2sFs fail."); + return HDF_FAILURE; + } + ret = SetCodecI2sFormat(bitWidth); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("SetCodecI2sFormat fail."); + return HDF_FAILURE; + } + AUDIO_DEVICE_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_DEVICE_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +int32_t ExternalCodecDaiDeviceInit(const struct AudioCard *card, const struct DaiDevice *device) +{ + if (device == NULL || device->devDaiName == NULL) { + AUDIO_DEVICE_LOG_ERR("input para is NULL."); + return HDF_FAILURE; + } + AUDIO_DEVICE_LOG_DEBUG("codec dai device name: %s\n", device->devDaiName); + (void)card; + return HDF_SUCCESS; +} + diff --git a/audio/chipsets/codec/hi3516_codec/include/hi3516_aiao.h b/audio/chipsets/codec/hi3516_codec/include/hi3516_aiao.h new file mode 100755 index 0000000000000000000000000000000000000000..7add813541a67e36c7edd126bf2ad24471b90ba2 --- /dev/null +++ b/audio/chipsets/codec/hi3516_codec/include/hi3516_aiao.h @@ -0,0 +1,495 @@ +/* + * 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 __HI3516_AIAO_H__ +#define __HI3516_AIAO_H__ + +#include +#include "hi3516_common.h" +/* AIO base addres */ +#define AIAO_REG_BASE 0x113b0000 +#define AIO_CLK_SEL_SEPARATE 0x0 +#define AIO_CLK_SEL_INSEPARATE 0x1 +#define AIAO_MAX_REG_SIZE (64 * 1024) + +static const int AIP_I2S_REG_CFG0 = 0x0100; +static const int AIP_I2S_REG_CFG1 = 0x0104; +static const int AOP_I2S_REG_CFG0 = 0x0140; +static const int AOP_I2S_REG_CFG1 = 0x0144; +/* aop */ +static const int OFFSET_MULTL = 8; +static const int AOP_BUFF_SADDR_REG = 0x2080; +static const int AOP_BUFF_SIZE_REG = 0x2084; +static const int AOP_BUFF_WPTR_REG = 0x2088; +static const int AOP_BUFF_RPTR_REG = 0x208C; +static const int AOP_TRANS_SIZE_REG = 0x2094; +static const int AOP_INT_ENA_REG = 0x20A0; +static const int AOP_INT_STATUS_REG = 0x20A8; +static const int AOP_INT_CLR_REG = 0x20AC; +static const int AOP_INF_ATTRI_REG = 0x2000; +static const int AOP_CTRL_REG = 0x2004; +static const int AIP_BUFF_SADDR_REG = 0x1080; +static const int AIP_BUFF_SIZE_REG = 0x1084; +static const int AIP_BUFF_WPTR_REG = 0x1088; +static const int AIP_BUFF_RPTR_REG = 0x108C; +static const int AIP_TRANS_SIZE_REG = 0x1094; +static const int AIP_INT_CLR_REG = 0x10AC; +static const int AIP_INF_ATTRI_REG = 0x1000; +static const int AIP_CTRL_REG = 0x1004; + +#define CRG_REG_ADDR 0x12010000 +#define PERI_CRG103 (CRG_REG_ADDR + 0x019c) +#define PERI_CRG105 (CRG_REG_ADDR + 0x01a4) +#define PERI_CRG106 (CRG_REG_ADDR + 0x01a8) +#define PERI_CRG107 (CRG_REG_ADDR + 0x01ac) + +#define AIAO_INT_ENA_REG 0x0 +#define AIAO_INT_STATUS_REG 0x4 +#define AIAO_INT_RAW_REG 0x8 + +#define HI_AIO_MAX_NUM 3 +#define HI_AI_DEV_MAX_NUM 3 +#define HI_AO_DEV_MAX_NUM 3 + +#define AIO_BCLK_TO_FSCLK_RATIO_16 16 +#define AIO_BCLK_TO_FSCLK_RATIO_32 32 +#define AIO_BCLK_TO_FSCLK_RATIO_48 48 +#define AIO_BCLK_TO_FSCLK_RATIO_64 64 +#define AIO_BCLK_TO_FSCLK_RATIO_128 128 +#define AIO_BCLK_TO_FSCLK_RATIO_256 256 +#define AIO_BCLK_TO_FSCLK_RATIO_320 320 +#define AIO_BCLK_TO_FSCLK_RATIO_384 384 + +#define AIO_MCLK_TO_BCLK_RATIO_1 1 +#define AIO_MCLK_TO_BCLK_RATIO_2 2 +#define AIO_MCLK_TO_BCLK_RATIO_3 3 +#define AIO_MCLK_TO_BCLK_RATIO_4 4 +#define AIO_MCLK_TO_BCLK_RATIO_6 6 +#define AIO_MCLK_TO_BCLK_RATIO_8 8 +#define AIO_MCLK_TO_BCLK_RATIO_12 12 +#define AIO_MCLK_TO_BCLK_RATIO_16 16 +#define AIO_MCLK_TO_BCLK_RATIO_24 24 +#define AIO_MCLK_TO_BCLK_RATIO_32 32 +#define AIO_MCLK_TO_BCLK_RATIO_48 48 +#define AIO_MCLK_TO_BCLK_RATIO_64 64 + +#define AIO_CHN_CNT_1 1 +#define AIO_CHN_CNT_2 2 +#define AIO_CHN_CNT_4 4 +#define AIO_CHN_CNT_8 8 +#define AIO_CHN_CNT_16 16 +#define AIO_CHN_CNT_20 20 + +#define AIO_CHN_ID_0 0 +#define AIO_CHN_ID_1 1 +#define AIO_CHN_ID_2 2 + +#define AIO_FIFO_BIT_WIDTH_256 256 +#define AIO_FIFO_BIT_WIDTH_320 320 +#define AIO_FIFO_BIT_WIDTH_384 384 + +#define AI_CHN_CNT_20 20 + +#define AIO_MCLK_48K_256FS_1188M 0x00152EF0 /* 48k * 256 */ +#define AIO_MCLK_441K_256FS_1188M 0x00137653 /* 44.1k * 256 */ +#define AIO_MCLK_32K_256FS_1188M 0x000E1F4B /* 32k * 256 */ + +#define AIO_MCLK_48K_320FS_1188M 0x001A7AAC /* 48k * 320 */ +#define AIO_MCLK_441K_320FS_1188M 0x00185FA0 /* 44.1k * 320 */ +#define AIO_MCLK_32K_320FS_1188M 0x0011A71E /* 32k * 320 */ + +#define W_CHANNEL_ID_MAX 13 +#define R_CHANNEL_ID_MAX 3 +#define TX_BUFF_MULTIPLE 32 + +typedef enum { + HI_FALSE = 0, + HI_TRUE = 1, +} HiBool; + +#define AOP_SUPPORT_MULTI_SLOT HI_FALSE + +#define HI_AI_EXPAND 0x01 +#define HI_AI_CUT 0x02 + +#define AIP_SWITCH_RX_BCLK 0x0028 /* AIAO I2S RX BCLK SWITCH Internal BCLK selection */ +#define AOP_SWITCH_TX_BCLK 0x002c /* AIAO I2S TX BCLK SWITCH Internal BCLK selection */ +#define AIO_SOFT_RESET_STATUS 0x0030 + +#define SYS_AIO_SAMPLE_CLK256 0x05 +#define SYS_AIO_SAMPLE_CLK128 0x04 +#define SYS_AIO_SAMPLE_CLK64 0x03 +#define SYS_AIO_SAMPLE_CLK48 0x02 +#define SYS_AIO_SAMPLE_CLK32 0x01 +#define SYS_AIO_SAMPLE_CLK16 0x00 + +#define SYS_AIO_BS_CLK1 0x00 +#define SYS_AIO_BS_CLK2 0x02 +#define SYS_AIO_BS_CLK3 0x01 +#define SYS_AIO_BS_CLK4 0x03 +#define SYS_AIO_BS_CLK6 0x04 +#define SYS_AIO_BS_CLK8 0x05 +#define SYS_AIO_BS_CLK12 0x06 +#define SYS_AIO_BS_CLK16 0x07 +#define SYS_AIO_BS_CLK24 0x08 +#define SYS_AIO_BS_CLK32 0x09 +#define SYS_AIO_BS_CLK48 0x0a +#define SYS_AIO_BS_CLK64 0x0b + +#define AIAO_CHN_CNT_20 20 + +typedef enum { + TX_SD_SOURCE_SEL0 = 0, + TX_SD_SOURCE_SEL1 = 1, + TX_SD_SOURCE_SEL2 = 2, +} TxSdSourceSel; + +typedef enum { + RX_CH_NUM0 = 0, + RX_CH_NUM1 = 1, + RX_CH_NUM2 = 2, + RX_CH_NUM3 = 3, + RX_CH_NUM4 = 4, +} RxChNum; + +typedef enum { + HI_AUDIO_CLK_SELECT_BASE = 0, /* Audio base clk. */ + HI_AUDIO_CLK_SELECT_SPARE, /* Audio spare clk. */ + + HI_AUDIO_CLK_SELECT_BUTT, +} HiAudioClkSelect; + +typedef struct { + HiAudioClkSelect clkSelect; + /* 256fs */ + unsigned int mclkDiv48k256fs; + unsigned int mclkDiv441k256fs; + unsigned int mclkDiv32k256fs; + /* 320fs */ + unsigned int mclkDiv48k320fs; + unsigned int mclkDiv441k320fs; + unsigned int mclkDiv32k320fs; +} AiaoClkInfo; + +typedef enum { + HI_AIO_MODE_I2S_MASTER = 0, /* AIO I2S master mode */ + HI_AIO_MODE_I2S_SLAVE, /* AIO I2S slave mode */ + HI_AIO_MODE_PCM_SLAVE_STD, /* AIO PCM slave standard mode */ + HI_AIO_MODE_PCM_SLAVE_NON_STD, /* AIO PCM slave non-standard mode */ + HI_AIO_MODE_PCM_MASTER_STD, /* AIO PCM master standard mode */ + HI_AIO_MODE_PCM_MASTER_NON_STD, /* AIO PCM master non-standard mode */ + HI_AIO_MODE_BUTT +} AudioWorkMode; + +typedef enum { + HI_AUDIO_SOUND_MODE_MONO = 0, /* mono */ + HI_AUDIO_SOUND_MODE_STEREO = 1, /* stereo */ + HI_AUDIO_SOUND_MODE_BUTT +} AudioSndMode; + +typedef enum { + HI_AIO_I2STYPE_INNERCODEC = 0, /* AIO I2S connect inner audio CODEC */ + HI_AIO_I2STYPE_INNERHDMI, /* AIO I2S connect Inner HDMI */ + HI_AIO_I2STYPE_EXTERN, /* AIO I2S connect extern hardware */ +} AioI2sType; + +typedef struct { + AudioSampleRate sampleRate; /* sample rate */ + AudioBitWidth bitWidth; /* bit_width */ + AudioWorkMode workMode; /* master or slave mode */ + AudioSndMode soundMode; /* momo or steror */ + int32_t expandFlag; /* expand 8bit to 16bit, use AI_EXPAND(only valid for AI 8bit), + use AI_CUT(only valid for extern codec for 24bit) */ + int32_t frameNum; /* frame num in buf[2,MAX_AUDIO_FRAME_NUM] */ + int32_t pointNumPerFrame; /* point num per frame (80/160/240/320/480/1024/2048) + (ADPCM IMA should add 1 point, AMR only support 160) */ + int32_t channelCnt; /* channle number on FS, valid value:1/2/4/8 */ + int32_t clkShare; /* 0: AI and AO clock is separate + 1: AI and AO clock is inseparate, AI use AO's clock */ + AioI2sType i2sType; /* i2s type */ +} AudioAttr; + +typedef enum { + AIO_TYPE_AI = 0, + AIO_TYPE_AO, + AIO_TYPE_BUTT +} AioType; + +typedef struct { + int32_t initialized; /* initialed flag */ + int32_t aiConfig; + int32_t aoConfig; + AudioAttr aiAttr; + AudioAttr aoAttr; +} AioState; + +// define the union u_i2s_crg_cfg0 +typedef union { + struct { + unsigned int aiaoMclkDiv : 27; // [26..0] + unsigned int reserved0 : 5; // [31..27] + } Bits; + unsigned int u32; +} UI2sCrgCfg0; + +// define the union u_i2s_crg_cfg1 +typedef union { + struct { + unsigned int aiaoBclkDiv : 4; // [3..0] + unsigned int aiaoFsclkDiv : 3; // [6..4] + unsigned int reserved1 : 1; // [7] + unsigned int aiaoCken : 1; // [8] + unsigned int aiaoSrstReq : 1; // [9] + unsigned int aiaoBclkOen : 1; // [10] + unsigned int aiaoBclkSel : 1; // [11] + unsigned int aiaoBclkinPctrl : 1; // [12] + unsigned int aiaoBclkoutPctrl : 1; // [13] + unsigned int aiaoBclkEn : 1; // [14] + unsigned int aiaoWsEn : 1; // [15] + unsigned int reserved0 : 16; // [31..16] + } Bits; + unsigned int u32; +} UI2sCrgCfg1; + +// define the union u_aiao_rxswitch_cfg +typedef union { + struct { + unsigned int innerBclkWsSelRx00 : 4; // [3..0] + unsigned int innerBclkWsSelRx01 : 4; // [7..4] + unsigned int innerBclkWsSelRx02 : 4; // [11..8] + unsigned int innerBclkWsSelRx03 : 4; // [15..12] + unsigned int innerBclkWsSelRx04 : 4; // [19..16] + unsigned int innerBclkWsSelRx05 : 4; // [23..20] + unsigned int innerBclkWsSelRx06 : 4; // [27..24] + unsigned int innerBclkWsSelRx07 : 4; // [31..28] + } Bits; + unsigned int u32; +} UAiaoSwitchRxBclk; + +// define the union u_aiao_txswitch_cfg +typedef union { + struct { + unsigned int innerBclkWsSelTx00 : 4; // [3..0] + unsigned int innerBclkWsSelTx01 : 4; // [7..4] + unsigned int innerBclkWsSelTx02 : 4; // [11..8] + unsigned int innerBclkWsSelTx03 : 4; // [15..12] + unsigned int innerBclkWsSelTx04 : 4; // [19..16] + unsigned int innerBclkWsSelTx05 : 4; // [23..20] + unsigned int innerBclkWsSelTx06 : 4; // [27..24] + unsigned int innerBclkWsSelTx07 : 4; // [31..28] + } Bits; + unsigned int u32; +} UAiaoSwitchTxBclk; + +// define the union u_rx_if_attri +typedef union { + struct { + unsigned int rxMode : 2; // [1..0] + unsigned int rxI2sPrecision : 2; // [3..2] + unsigned int rxChNum : 3; // [6..4] + unsigned int rxMultislotEn : 1; // [7] + unsigned int rxSdOffset : 8; // [15..8] + unsigned int rxTrackMode : 3; // [18..16] + unsigned int reserved0 : 1; // [19] + unsigned int rxSdSourceSel : 4; // [23..20] + unsigned int rxSd0Sel : 2; // [25..24] + unsigned int rxSd1Sel : 2; // [27..26] + unsigned int rxSd2Sel : 2; // [29..28] + unsigned int rxSd3Sel : 2; // [31..30] + } Bits; + unsigned int u32; +} URxIfAttri; + +// define the union u_tx_if_attri +typedef union { + struct { + unsigned int txMode : 2; // [1..0] + unsigned int txI2sPrecision : 2; // [3..2] + unsigned int txChNum : 2; // [5..4] + unsigned int txUnderflowCtrl : 1; // [6] + unsigned int txMultislotEn : 1; // [7] + unsigned int txSdOffset : 8; // [15..8] + unsigned int txTrackmode : 3; // [18..16] + unsigned int reserved0 : 1; // [19] + unsigned int txSdSourceSel : 4; // [23..20] + unsigned int txSd0Sel : 2; // [25..24] + unsigned int txSd1Sel : 2; // [27..26] + unsigned int txSd2Sel : 2; // [29..28] + unsigned int txSd3Sel : 2; // [31..30] + } Bits; + unsigned int u32; +} UTxIfAttri; + +// define the union u_rx_dsp_ctrl +typedef union { + struct { + unsigned int muteEn : 1; // [0] + unsigned int muteFadeEn : 1; // [1] + unsigned int pauseEn : 1; // [2] + unsigned int pauseFadeEn : 1; // [3] + unsigned int reserved3 : 4; // [7..4] + unsigned int volume : 7; // [14..8] + unsigned int reserved2 : 1; // [15] + unsigned int fadeInRate : 4; // [19..16] + unsigned int fadeOutRate : 4; // [23..20] + unsigned int reserved1 : 3; // [26..24] + unsigned int bypassEn : 1; // [27] + unsigned int rxEnable : 1; // [28] + unsigned int rxDisableDone : 1; // [29] + unsigned int reserved0 : 2; // [31..30] + } Bits; + unsigned int u32; +} URxDspCtrl; + +typedef union { + struct { + unsigned int muteEn : 1; // [0] + unsigned int muteFadeEn : 1; // [1] + unsigned int reserved3 : 6; // [7..2] + unsigned int volume : 7; // [14..8] + unsigned int reserved2 : 1; // [15] + unsigned int fadeInRate : 4; // [19..16] + unsigned int fadeOutRate : 4; // [23..20] + unsigned int reserved1 : 3; // [26..24] + unsigned int bypassEn : 1; // [27] + unsigned int txEnable : 1; // [28] + unsigned int txDisableDone : 1; // [29] + unsigned int reserved0 : 2; // [31..30] + } Bits; + unsigned int u32; +} UTxDspCtrl; + +// define the union u_tx_buff_rptr +typedef union { + struct { + unsigned int txBuffRptr : 24; // [23..0] + unsigned int reserved0 : 8; // [31..24] + } Bits; + unsigned int u32; +} UTxBuffRptr; + +typedef union { + struct { + unsigned int txBuffWptr : 24; // [23..0] + unsigned int reserved0 : 8; // [31..24] + } Bits; + unsigned int u32; +} UTxBuffWptr; + +// define the union u_tx_int_ena +typedef union { + struct { + unsigned int txTransIntEna : 1; // [0] + unsigned int txEmptyIntEna : 1; // [1] + unsigned int txAlemptyIntEna : 1; // [2] + unsigned int txBfifoEmptyIntEna : 1; // [3] + unsigned int txIfifoEmptyIntEna : 1; // [4] + unsigned int txStopIntEna : 1; // [5] + unsigned int txMfadeIntEna : 1; // [6] + unsigned int txDatBreakIntEna : 1; // [7] + unsigned int reserved0 : 24; // [31..8] + } Bits; + unsigned int u32; +} UTxIntEna; + +typedef union { + struct { + unsigned int txTransIntClear : 1; // [0] + unsigned int txEmptyIntClear : 1; // [1] + unsigned int txAlemptyIntClear : 1; // [2] + unsigned int txBfifoEmptyIntClear : 1; // [3] + unsigned int txIfifoEmptyIntClear : 1; // [4] + unsigned int txStopIntClear : 1; // [5] + unsigned int txMfadeIntClear : 1; // [6] + unsigned int txDatBreakIntClear : 1; // [7] + unsigned int reserved0 : 24; // [31..8] + } Bits; + unsigned int u32; +} UTxIntClr; + +typedef union { + struct { + unsigned int txBuffSize : 24; // [23..0] + unsigned int reserved0 : 8; // [31..24] + } Bits; + unsigned int u32; +} UTxBuffSize; + +typedef union { + struct { + unsigned int txTransSize : 24; // [23..0] + unsigned int reserved0 : 8; // [31..24] + } Bits; + unsigned int u32; +} UTxTransSize; + +// define the union u_aiao_int_ena +typedef union { + struct { + unsigned int rxCh0IntEna : 1; // [0] + unsigned int rxCh1IntEna : 1; // [1] + unsigned int rxCh2IntEna : 1; // [2] + unsigned int rxCh3IntEna : 1; // [3] + unsigned int rxCh4IntEna : 1; // [4] + unsigned int rxCh5IntEna : 1; // [5] + unsigned int rxCh6IntEna : 1; // [6] + unsigned int rxCh7IntEna : 1; // [7] + unsigned int reserved1 : 8; // [15..8] + unsigned int txCh0IntEna : 1; // [16] + unsigned int txCh1IntEna : 1; // [17] + unsigned int txCh2IntEna : 1; // [18] + unsigned int txCh3IntEna : 1; // [19] + unsigned int txCh4IntEna : 1; // [20] + unsigned int txCh5IntEna : 1; // [21] + unsigned int txCh6IntEna : 1; // [22] + unsigned int txCh7IntEna : 1; // [23] + unsigned int spdiftxCh0IntEna : 1; // [24] + unsigned int spdiftxCh1IntEna : 1; // [25] + unsigned int spdiftxCh2IntEna : 1; // [26] + unsigned int spdiftxCh3IntEna : 1; // [27] + unsigned int reserved0 : 4; // [31..28] + } Bits; + unsigned int u32; +} UAiaoIntEna; + +int32_t AiaoHalSysInit(void); +int32_t AiaoClockReset(void); +unsigned int AiaoHalReadReg(unsigned int offset); +int AopHalSetBuffRptr(unsigned int chnId, unsigned int value); +int AopHalSetBuffWptr(unsigned int chnId, unsigned int value); +int AopHalSetBufferAddr(unsigned int chnId, unsigned long long value); +int AipHalSetBufferAddr(unsigned int chnId, unsigned long long value); +int AipHalSetBufferSize(unsigned int chnId, unsigned int value); +int AipHalSetTransSize(unsigned int chnId, unsigned int value); +int AipHalSetRxStart(unsigned int chnId, bool en); +int AipHalSetBuffWptr(unsigned int chnId, unsigned int value); +int AipHalSetBuffRptr(unsigned int chnId, unsigned int value); +int AopHalSetBufferSize(unsigned int chnId, unsigned int value); +int AopHalSetTransSize(unsigned int chnId, unsigned int value); +int AopHalSetTxStart(unsigned int chnId, bool en); +int32_t AopHalDevEnable(unsigned int chnId); +uint32_t AipBuffRptrReg(uint32_t m); +uint32_t AipBuffWptrReg(uint32_t m); +uint32_t AopBuffRptrReg(uint32_t m); +uint32_t AopBuffWptrReg(uint32_t m); +int32_t AopSetSysCtlReg(int32_t chnId, unsigned int channelCnt, unsigned int bitWidth, unsigned int rate); +int32_t AopSetAttr(unsigned int chnId, unsigned int channelCnt, unsigned int bitWidth); +int32_t AipSetSysCtlReg(int32_t chnId, unsigned int channelCnt, unsigned int bitWidth, unsigned int rate); +int32_t AipSetAttr(unsigned int chnId, unsigned int channelCnt, unsigned int bitWidth); +void ShowAllAiaoRegister(void); +int32_t AiaoDeviceInit(unsigned int chnId); +int32_t I2sCrgCfgInit(unsigned int chnId); + +#endif // __HI3516_ACODEC_H__ diff --git a/audio/chipsets/codec/hi3516_codec/include/hi3516_codec.h b/audio/chipsets/codec/hi3516_codec/include/hi3516_codec.h new file mode 100755 index 0000000000000000000000000000000000000000..46e6d7b037218674c3bedd95c3c7176aafa78e5d --- /dev/null +++ b/audio/chipsets/codec/hi3516_codec/include/hi3516_codec.h @@ -0,0 +1,324 @@ +/* + * 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 __HI3516_CODEC_H__ +#define __HI3516_CODEC_H__ + +#include "osal_mem.h" +#include "osal_time.h" +#include "securec.h" +#include "hi3516_common.h" + +#define HI_NULL 0L +#define HI_SUCCESS 0 +#define HI_FAILURE (-1) + +#define CRG_REG_ADDR 0x12010000 +#define PERI_CRG103 (CRG_REG_ADDR + 0x019c) +#define PERI_CRG105 (CRG_REG_ADDR + 0x01a4) +#define PERI_CRG106 (CRG_REG_ADDR + 0x01a8) +#define PERI_CRG107 (CRG_REG_ADDR + 0x01ac) + +#define ACODEC_REG_BASE 0x113c0000 + +#define AUDIO_CODEC_ANAREG0 0x14 +#define AUDIO_CODEC_MASKREG 0x48 +#define ACODEC_MAX_REG_SIZE (0x1000) +#define AUDIO_ATTR_FRAMENUM 30 +#define AUDIO_ATTR_POINTNUM 320 +#define ACODEC_CRG_OFFSET 0x0108 +#define ACODEC_REGS_OFFSET 0x0 + +#define ACODEC_REGS_BASE 0x113c0000 +#define SYS_CRG_BASE 0x12010000 + +/* acodec analog register */ +#define ACODEC_ANAREG0_ADDR 0x14 +#define ACODEC_ANAREG1_ADDR 0x18 +#define ACODEC_ANAREG2_ADDR 0x1c +#define ACODEC_ANAREG3_ADDR 0x20 +#define ACODEC_ANAREG4_ADDR 0x24 +#define ACODEC_ANAREG5_ADDR 0x28 + +/* acodec dig control register */ +#define ACODEC_DIGCTRL0_ADDR 0x2c +#define ACODEC_DIGCTRL1_ADDR 0x30 +#define ACODEC_DIGCTRL2_ADDR 0x34 +#define ACODEC_DIGCTRL3_ADDR 0x38 +#define ACODEC_DIGCTRL4_ADDR 0x3c +#define ACODEC_DIGCTRL7_ADDR 0x48 + +#define ACODEC_ANAREG0_DEFAULT 0x6400FCFD +#define ACODEC_ANAREG1_DEFAULT 0x00000034 +#define ACODEC_ANAREG2_DEFAULT 0x4018088D +#define ACODEC_ANAREG3_DEFAULT 0x00000000 + +#define UINT_32_MAX 0xffffffff + +typedef enum { + ACODEC_I2S_FS_8000 = 0x18, + ACODEC_I2S_FS_11025 = 0x18, + ACODEC_I2S_FS_12000 = 0x18, + ACODEC_I2S_FS_16000 = 0x19, + ACODEC_I2S_FS_22050 = 0x19, + ACODEC_I2S_FS_24000 = 0x19, + ACODEC_I2S_FS_32000 = 0x1a, + ACODEC_I2S_FS_44100 = 0x1a, + ACODEC_I2S_FS_48000 = 0x1a, + ACODEC_I2S_FS_64000 = 0x1b, + ACODEC_I2S_FS_96000 = 0x1b, + ACODEC_I2S_FS_BUTT = 0x1c, +} AcodecI2sFs; + +typedef enum { + ACODEC_ADC_MODESEL_6144 = 0x0, + ACODEC_ADC_MODESEL_4096 = 0x1, + ACODEC_ADC_MODESEL_BUTT = 0xff, +} AcodecAdcModeSel; + +typedef enum { + AUDIO_CODEC_BIT_WIDTH_16 = 0, /* 16bit width */ + AUDIO_CODEC_BIT_WIDTH_18 = 1, /* 18bit width */ + AUDIO_CODEC_BIT_WIDTH_20 = 2, /* 20bit width */ + AUDIO_CODEC_BIT_WIDTH_24 = 3, /* 24bit width */ + AUDIO_CODEC_BIT_WIDTH_BUTT, +} AudioCodecBitWidth; + +typedef union { + struct { + unsigned int acodecPdVref : 1; // [0] + unsigned int acodecPdbCtcmIbias : 1; // [1] + unsigned int reserved0 : 3; // [2:4] + unsigned int acodecPdMicbias1 : 1; // [5] + unsigned int acodecPdIbias : 1; // [6] + unsigned int acodecPdMicbias2 : 1; // [7] + unsigned int acodecPdDaclDff : 1; // [8] + unsigned int acodecPdDacrDff : 1; // [9] + unsigned int reserved1 : 1; // [10] + unsigned int acodecPdDacl : 1; // [11] + unsigned int acodecPdDacr : 1; // [12] + unsigned int acodecMuteDacl : 1; // [13] + unsigned int acodecMuteDacr : 1; // [14] + unsigned int reserved2 : 1; // [15] + unsigned int acodecDacrPopEn : 1; // [16] + unsigned int reserved3 : 1; // [17] + unsigned int acodecDaclPopEn : 1; // [18] + unsigned int acodecAnaLoop : 1; // [19] + unsigned int acodecBypChopDacVref : 1; // [20] + unsigned int reserved4 : 1; // [21] + unsigned int acodecSelClkChopDacVref : 2; // [23:22] + unsigned int reserved5 : 2; // [24:25] + unsigned int acodecIbadjDac : 2; // [27:26] + unsigned int acodecCtrlClkDacPh : 1; // [28] + unsigned int acodecSelClkChopLineoutD : 2; // [30:29] + unsigned int acodecIbadjCtcm : 1; // [31] + } Bits; + unsigned int ul32; +} AcodecAnaReg0; + +typedef union { + struct { + unsigned int acodecBypChopCtcm : 1; // [0] + unsigned int acodecSelClkChopCtcm : 1; // [1] + unsigned int acodecIbadjAdc : 2; // [3:2] + unsigned int reserved0 : 2; // [4:5] + unsigned int acodecCtrlClkAdcPh : 1; // [6] + unsigned int acodecCtrlMclkPh : 1; // [7] + unsigned int acodecPgaRinManFloat : 6; // [13:8] + unsigned int acodecPgaRinManEn : 1; // [14] + unsigned int reserved1 : 2; // [15:16] + unsigned int acodecRxCtcmPd : 1; // [17] + unsigned int reserved3 : 2; // [19:18] + unsigned int acodecAdcDaIbSel : 2; // [21:20] + unsigned int acodecRpgaBoost : 1; // [22] + unsigned int acodecLpgaBoost : 1; // [23] + unsigned int acodecAdcDacRlMisSelp : 4; // [27:24] + unsigned int acodecAdcDacRlMisSeln : 4; // [31:28] + } Bits; + unsigned int ul32; +} AcodecAnaReg1; + +typedef union { + struct { + unsigned int acodecLdoPd : 1; // [0] + unsigned int acodecLdoBk : 1; // [1] + unsigned int acodecLdoSel : 2; // [3:2] + unsigned int acodecAdcVref : 2; // [5:4] + unsigned int acodecAdcrModeSel : 1; // [6] + unsigned int acodecAdclModeSel : 1; // [7] + unsigned int reserved0 : 5; // [12:8] + unsigned int acodecBypChopCtcmRx : 1; // [13] + unsigned int acodecBypChopperAdc : 2; // [14] + unsigned int acodecBypChopperLinein : 2; // [14] + unsigned int reserved1 : 1; // [16] + unsigned int acodecVrefFs : 1; // [17] + unsigned int acodecVrefSel : 5; // [22:18] + unsigned int acodecRst : 1; // [23] + unsigned int acodecMicbias1Adj : 3; // [26:24] + unsigned int acodecMicbias2Adj : 3; // [29:27] + unsigned int acodecPdCtcm : 1; // [30] + unsigned int reserved2 : 1; // [31] + } Bits; + unsigned int ul32; +} AcodecAnaReg2; + +typedef union { + struct { + unsigned int acodecDacrPopDirect : 1; // [0] + unsigned int reserved0 : 1; // [1] + unsigned int acodecDaclPopDirect : 1; // [2] + unsigned int acodecPopresSel : 2; // [4:3] + unsigned int acodecPoprampclkSel : 2; // [6:5] + unsigned int acodecVrefExmode : 1; // [7] + unsigned int reserved1 : 1; // [8] + unsigned int acodecRpgaMute09 : 1; // [9] + unsigned int acodecLpgaMute09 : 1; // [10] + unsigned int acodecPdAdcTune09 : 1; // [11] + unsigned int acodecRpgaPd09 : 1; // [12] + unsigned int acodecLpgaPd09 : 1; // [13] + unsigned int acodecAdcrPd09 : 1; // [14] + unsigned int acodecAdclPd09 : 1; // [15] + unsigned int acodecLgpaGain09 : 5; // [20:16] + unsigned int acodecLpgaSel09 : 3; // [23:21] + unsigned int acodecRgpaGain09 : 5; // [28:24] + unsigned int acodecRpgaSel09 : 3; // [31:29] + } Bits; + unsigned int ul32; +} AcodecAnaReg3; + +typedef union { + struct { + unsigned int acodecAdcDwaBps09 : 1; // [0] + unsigned int acodecAdcBinClkPhsel09 : 1; // [1] + unsigned int acodecAdcTheClkPhsel09 : 1; // [2] + unsigned int acodecAdcChopClkPhsel09 : 1; // [3] + unsigned int acodecAdcChopClkSel09 : 2; // [5:4] + unsigned int acodecPgaChopClkSel09 : 2; // [7:6] + unsigned int reserved0 : 1; // [8] + unsigned int acodecCtrlClkAdcph09 : 1; // [9] + unsigned int acodecAdcTuneSel09 : 1; // [10] + unsigned int acodecAdcTuneEn09 : 1; // [11] + unsigned int acodecAdcTune09 : 4; // [15:12] + unsigned int reserved1 : 16; // [31:16] + } Bits; + unsigned int ul32; +} AcodecAnaReg4; + +typedef union { + struct { + unsigned int adcr2dacrVol : 7; // [6:0] + unsigned int adcr2dacrEn : 1; // [7] + unsigned int adcl2dacrVol : 7; // [14:8] + unsigned int adcl2dacrEn : 1; // [15] + unsigned int adcr2daclVol : 7; // [22:16] + unsigned int adcr2daclEn : 1; // [23] + unsigned int adcl2daclVol : 7; // [30:24] + unsigned int adcl2daclEn : 1; // [31] + } Bits; + unsigned int ul32; +} AcodecDigCtrl5; + +typedef union { + struct { + unsigned int adcrLrsel : 1; // [0] + unsigned int adcrI2ssel : 1; // [1] + unsigned int adclLrsel : 1; // [2] + unsigned int adclI2ssel : 1; // [3] + unsigned int reserved : 10; // [13:4] + unsigned int adcrHpfEn : 1; // [14] + unsigned int adclHpfEn : 1; // [15] + unsigned int adcrVol : 7; // [22:16] + unsigned int adcrMute : 1; // [23] + unsigned int adclVol : 7; // [30:24] + unsigned int adclMute : 1; // [31] + } Bits; + unsigned int ul32; +} AcodecDigCtrl4; + +typedef union { + struct { + unsigned int dacl2dacrVol : 7; // [6:0] + unsigned int dacl2dacrEn : 1; // [7] + unsigned int dacr2daclVol : 7; // [14:8] + unsigned int dacr2daclEn : 1; // [15] + unsigned int dacrVol : 7; // [22:16] + unsigned int dacrMute : 1; // [23] + unsigned int daclVol : 7; // [30:24] + unsigned int daclMute : 1; // [31] + } Bits; + unsigned int ul32; +} AcodecDigCtrl3; + +typedef union { + struct { + unsigned int dacrLrsel : 1; // [0] + unsigned int dacrI2ssel : 1; // [1] + unsigned int daclLrsel : 1; // [2] + unsigned int daclI2ssel : 1; // [3] + unsigned int reserved : 15; // [18:4] + unsigned int dacrDeemph : 2; // [20:19] + unsigned int daclDeemph : 2; // [22:21] + unsigned int muterRate : 2; // [24:23] + unsigned int mutelRate : 2; // [26:25] + unsigned int dacvu : 1; // [27] + unsigned int sunmuter : 1; // [28] + unsigned int sunmutel : 1; // [29] + unsigned int smuter : 1; // [30] + unsigned int smutel : 1; // [31] + } Bits; + unsigned int ul32; +} AcodecDigCtrl2; + +typedef union { + struct { + unsigned int rst : 1; // [0] + unsigned int adcFlstn : 1; // [1] + unsigned int adcAdatn : 2; // [3:2] + unsigned int ibadjCtcm : 1; // [4] + unsigned int ibadjDac : 1; // [5] + unsigned int ibadjAdc : 2; // [7:6] + unsigned int i2s2FsSel : 5; // [12:8] + unsigned int i2s1FsSel : 5; // [17:13] + unsigned int digLoop : 1; // [18] + unsigned int digBypass : 1; // [19] + unsigned int i2s2DataBits : 2; // [21:20] + unsigned int i2s1DataBits : 2; // [23:22] + unsigned int adcrEn : 1; // [24] + unsigned int adclEn : 1; // [25] + unsigned int dacrEn : 1; // [26] + unsigned int daclEn : 1; // [27] + unsigned int adcrRstN : 1; // [28] + unsigned int adclRstN : 1; // [29] + unsigned int dacrRstN : 1; // [30] + unsigned int daclRstN : 1; // [31] + } Bits; + unsigned int ul32; +} AcodecDigCtrl1; + +typedef struct { + volatile AcodecDigCtrl1 acodecDigctrl1; + volatile AcodecDigCtrl2 acodecDigctrl2; + volatile AcodecDigCtrl3 acodecDigctrl3; +} AcodecRegs; + +int32_t CodecHalSysInit(void); +int AcodecDeviceInit(void); +unsigned int AcodecHalReadReg(unsigned int offset); +void AcodecHalWriteReg(uint32_t offset, uint32_t value); +long IoctlGetOutputVol(void); +int32_t AcodecSetI2s1Fs(const unsigned int rate); +int32_t AcodecSetI2s1DataWidth(const unsigned int bitWidth); +void ShowAllAcodecRegister(void); +#endif // __HI3516_ACODEC_H__ diff --git a/audio/chipsets/codec/hi3516_codec/include/hi3516_common.h b/audio/chipsets/codec/hi3516_codec/include/hi3516_common.h new file mode 100755 index 0000000000000000000000000000000000000000..7b9227c118c54824dce2dcf7a87a8ba2baa53805 --- /dev/null +++ b/audio/chipsets/codec/hi3516_codec/include/hi3516_common.h @@ -0,0 +1,50 @@ +/* + * 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 __HI3516_COMMON_H__ +#define __HI3516_COMMON_H__ + +enum AuidoBitWidth { + BIT_WIDTH8 = 8, /* 8 bit witdth */ + BIT_WIDTH16 = 16, /* 16 bit witdth */ + BIT_WIDTH18 = 18, /* 18 bit witdth */ + BIT_WIDTH20 = 20, /* 20 bit witdth */ + BIT_WIDTH24 = 24, /* 24 bit witdth */ + BIT_WIDTH32 = 32, /* 32 bit witdth */ +}; + +typedef enum { + AUDIO_SAMPLE_RATE_8000 = 8000, /* 8kHz sample_rate */ + AUDIO_SAMPLE_RATE_12000 = 12000, /* 12kHz sample_rate */ + AUDIO_SAMPLE_RATE_11025 = 11025, /* 11.025kHz sample_rate */ + AUDIO_SAMPLE_RATE_16000 = 16000, /* 16kHz sample_rate */ + AUDIO_SAMPLE_RATE_22050 = 22050, /* 22.050kHz sample_rate */ + AUDIO_SAMPLE_RATE_24000 = 24000, /* 24kHz sample_rate */ + AUDIO_SAMPLE_RATE_32000 = 32000, /* 32kHz sample_rate */ + AUDIO_SAMPLE_RATE_44100 = 44100, /* 44.1kHz sample_rate */ + AUDIO_SAMPLE_RATE_48000 = 48000, /* 48kHz sample_rate */ + AUDIO_SAMPLE_RATE_64000 = 64000, /* 64kHz sample_rate */ + AUDIO_SAMPLE_RATE_96000 = 96000, /* 96kHz sample_rate */ + AUDIO_SAMPLE_RATE_BUTT, +} AudioSampleRate; + +typedef enum { + AUDIO_BIT_WIDTH_8 = 0, /* 8bit width */ + AUDIO_BIT_WIDTH_16 = 1, /* 16bit width */ + AUDIO_BIT_WIDTH_24 = 2, /* 24bit width */ + AUDIO_BIT_WIDTH_BUTT, +} AudioBitWidth; + +#endif \ No newline at end of file diff --git a/audio/chipsets/codec/hi3516_codec/src/hi3516_aiao.c b/audio/chipsets/codec/hi3516_codec/src/hi3516_aiao.c new file mode 100755 index 0000000000000000000000000000000000000000..8d4bb3852b5caffd8787acd15604ece37324ba41 --- /dev/null +++ b/audio/chipsets/codec/hi3516_codec/src/hi3516_aiao.c @@ -0,0 +1,879 @@ +/* + * 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 "hi3516_aiao.h" +#include +#include "audio_device_log.h" +#include "hdf_base.h" +#include "hdf_log.h" +#include "osal_io.h" + +void *g_regAiaoBase = NULL; // AIAO Reg Base Addr + +AiaoClkInfo g_aioClkInfo = { + .clkSelect = HI_AUDIO_CLK_SELECT_BASE, + + .mclkDiv48k256fs = AIO_MCLK_48K_256FS_1188M, + .mclkDiv441k256fs = AIO_MCLK_441K_256FS_1188M, + .mclkDiv32k256fs = AIO_MCLK_32K_256FS_1188M, + + .mclkDiv48k320fs = AIO_MCLK_48K_320FS_1188M, + .mclkDiv441k320fs = AIO_MCLK_441K_320FS_1188M, + .mclkDiv32k320fs = AIO_MCLK_32K_320FS_1188M, +}; + +static uint32_t AipI2sRegCfg0(uint32_t n) +{ + return AIP_I2S_REG_CFG0 + OFFSET_MULTL * (n); +} + +static uint32_t AipI2sRegCfg1(uint32_t n) +{ + return AIP_I2S_REG_CFG1 + OFFSET_MULTL * (n); +} + +static uint32_t AopI2sRegCfg0(uint32_t n) +{ + return AOP_I2S_REG_CFG0 + OFFSET_MULTL * (n); +} + +static uint32_t AopI2sRegCfg1(uint32_t n) +{ + return AOP_I2S_REG_CFG1 + OFFSET_MULTL * (n); +} +/* aop */ +static uint32_t AopBuffSaddrReg(uint32_t m) +{ + return AOP_BUFF_SADDR_REG + OFFSET_MULTL * (m); +} + +static uint32_t AopBuffSizeReg(uint32_t m) +{ + return AOP_BUFF_SIZE_REG + OFFSET_MULTL * (m); +} + +uint32_t AopBuffWptrReg(uint32_t m) +{ + return AOP_BUFF_WPTR_REG + OFFSET_MULTL * (m); +} + +uint32_t AopBuffRptrReg(uint32_t m) +{ + return AOP_BUFF_RPTR_REG + OFFSET_MULTL * (m); +} + +static uint32_t AopTransSizeReg(uint32_t m) +{ + return AOP_TRANS_SIZE_REG + OFFSET_MULTL * (m); +} + +static uint32_t AipBuffSaddrReg(uint32_t m) +{ + return AIP_BUFF_SADDR_REG + OFFSET_MULTL * (m); +} + +static uint32_t AipBuffSizeReg(uint32_t m) +{ + return AIP_BUFF_SIZE_REG + OFFSET_MULTL * (m); +} + +uint32_t AipBuffWptrReg(uint32_t m) +{ + return AIP_BUFF_WPTR_REG + OFFSET_MULTL * (m); +} + +uint32_t AipBuffRptrReg(uint32_t m) +{ + return AIP_BUFF_RPTR_REG + OFFSET_MULTL * (m); +} + +static uint32_t AipTransSizeReg(uint32_t m) +{ + return AIP_TRANS_SIZE_REG + OFFSET_MULTL * (m); +} + +/* aip */ +static uint32_t AipInfAttriReg(uint32_t n) +{ + return AIP_INF_ATTRI_REG + OFFSET_MULTL * (n); +} + +static uint32_t AipCtrlReg(uint32_t n) +{ + return AIP_CTRL_REG + OFFSET_MULTL * (n); +} +/* aop */ +static uint32_t AopInfAttriReg(uint32_t m) +{ + return AOP_INF_ATTRI_REG + OFFSET_MULTL * (m); +} + +static uint32_t AopCtrlReg(uint32_t m) +{ + return AOP_CTRL_REG + OFFSET_MULTL * (m); +} + +/* Mapping physical address to virtual address, for acodec and aiao */ +int32_t AiaoHalSysInit(void) +{ + // AIAO REMAP + if (g_regAiaoBase == NULL) { + g_regAiaoBase = OsalIoRemap(AIAO_REG_BASE, AIAO_MAX_REG_SIZE); + if (g_regAiaoBase == NULL) { + return HDF_FAILURE; + } + } + return HDF_SUCCESS; +} + +int32_t AiaoClockReset(void) +{ + volatile char *vAddr = NULL; + volatile const unsigned int crgVal = 0xa; // AIAO CLOCK RESET + volatile unsigned int regval; + + /* RESET AIAO */ + vAddr = OsalIoRemap(PERI_CRG103, sizeof(unsigned int)); + if (vAddr == NULL) { + AUDIO_DEVICE_LOG_ERR("vAddr is null \n"); + return HDF_FAILURE; + } + + regval = OSAL_READL(vAddr); + AUDIO_DEVICE_LOG_DEBUG("[OHOS] AIAO CLOCK PERI_CRG103, Val: 0x%08x", regval); + + OSAL_WRITEL(crgVal, vAddr); + AUDIO_DEVICE_LOG_DEBUG("[OHOS] AIAO CLOCK PERI_CRG103, Val: 0x%08x", crgVal); + return HDF_SUCCESS; +} + +uint32_t AiaoHalReadReg(uint32_t offset) +{ + if (g_regAiaoBase == NULL) { + AUDIO_DEVICE_LOG_ERR("g_regAiaoBase is null.\n"); + return 0x0; + } + + return (*(volatile uint32_t *)((unsigned char *)g_regAiaoBase + (unsigned int)offset)); +} + +static int32_t AiaoGetBclkSel(unsigned int bclkDiv, unsigned int *bclkSel) +{ + switch (bclkDiv) { + case AIO_MCLK_TO_BCLK_RATIO_1: + *bclkSel = SYS_AIO_BS_CLK1; + break; + + case AIO_MCLK_TO_BCLK_RATIO_2: + *bclkSel = SYS_AIO_BS_CLK2; + break; + + case AIO_MCLK_TO_BCLK_RATIO_3: + *bclkSel = SYS_AIO_BS_CLK3; + break; + + case AIO_MCLK_TO_BCLK_RATIO_4: + *bclkSel = SYS_AIO_BS_CLK4; + break; + + case AIO_MCLK_TO_BCLK_RATIO_6: + *bclkSel = SYS_AIO_BS_CLK6; + break; + + case AIO_MCLK_TO_BCLK_RATIO_8: + *bclkSel = SYS_AIO_BS_CLK8; + break; + + case AIO_MCLK_TO_BCLK_RATIO_12: + *bclkSel = SYS_AIO_BS_CLK12; + break; + + case AIO_MCLK_TO_BCLK_RATIO_16: + *bclkSel = SYS_AIO_BS_CLK16; + break; + + case AIO_MCLK_TO_BCLK_RATIO_24: + *bclkSel = SYS_AIO_BS_CLK24; + break; + + case AIO_MCLK_TO_BCLK_RATIO_32: + *bclkSel = SYS_AIO_BS_CLK32; + break; + + case AIO_MCLK_TO_BCLK_RATIO_48: + *bclkSel = SYS_AIO_BS_CLK48; + break; + + case AIO_MCLK_TO_BCLK_RATIO_64: + *bclkSel = SYS_AIO_BS_CLK64; + break; + + default: + AUDIO_DEVICE_LOG_ERR("not support this bclkDivision ratio\n"); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t AiaoGetLrclkSel(unsigned int lrclkDiv, unsigned int *lrclkSel) +{ + switch (lrclkDiv) { + case AIO_BCLK_TO_FSCLK_RATIO_256: { + *lrclkSel = SYS_AIO_SAMPLE_CLK256; + break; + } + + case AIO_BCLK_TO_FSCLK_RATIO_128: { + *lrclkSel = SYS_AIO_SAMPLE_CLK128; + break; + } + + case AIO_BCLK_TO_FSCLK_RATIO_64: { + *lrclkSel = SYS_AIO_SAMPLE_CLK64; + break; + } + + case AIO_BCLK_TO_FSCLK_RATIO_48: { + *lrclkSel = SYS_AIO_SAMPLE_CLK48; + break; + } + + case AIO_BCLK_TO_FSCLK_RATIO_32: { + *lrclkSel = SYS_AIO_SAMPLE_CLK32; + break; + } + + case AIO_BCLK_TO_FSCLK_RATIO_16: { + *lrclkSel = SYS_AIO_SAMPLE_CLK16; + break; + } + + default: { + AUDIO_DEVICE_LOG_ERR("not support this fsclk_division ratio\n"); + return HDF_FAILURE; + } + } + + return HDF_SUCCESS; +} + +void AiaoHalWriteReg(unsigned int offset, unsigned int value) +{ + if (g_regAiaoBase == NULL) { + AUDIO_DEVICE_LOG_ERR("g_aio_base is null.\n"); + return; + } + + *(volatile unsigned int *)((unsigned char *)(g_regAiaoBase) + (unsigned int)(offset)) = value; +} + +static void AopSetCtrlReg(unsigned int chnId) +{ + UTxDspCtrl aopCtrlReg; + aopCtrlReg.u32 = AiaoHalReadReg(AopCtrlReg(chnId)); + + AUDIO_DEVICE_LOG_DEBUG("[OHOS] AopSetCtrlReg AopSetAttrReg read = %08x\n", aopCtrlReg.u32); + + aopCtrlReg.Bits.muteEn = 0; + aopCtrlReg.Bits.muteFadeEn = 0; + aopCtrlReg.Bits.reserved3 = 0; + aopCtrlReg.Bits.volume = 0x79; /* 0db */ + aopCtrlReg.Bits.reserved2 = 0; + aopCtrlReg.Bits.fadeInRate = 0; + aopCtrlReg.Bits.fadeOutRate = 0; + aopCtrlReg.Bits.reserved1 = 0; + aopCtrlReg.Bits.bypassEn = 0; + aopCtrlReg.Bits.txEnable = 0; + aopCtrlReg.Bits.txDisableDone = 0; + aopCtrlReg.Bits.reserved0 = 0; + + AiaoHalWriteReg(AopCtrlReg(chnId), aopCtrlReg.u32); + AUDIO_DEVICE_LOG_DEBUG("[OHOS] AopSetCtrlReg AopSetAttrReg write = %08x\n", aopCtrlReg.u32); +} + +int AopHalSetBufferAddr(unsigned int chnId, unsigned long long value) +{ + unsigned int saddr; + + if (chnId >= W_CHANNEL_ID_MAX) { + AUDIO_DEVICE_LOG_ERR("ao_dev%d is invalid!\n", chnId); + return HDF_FAILURE; + } + + saddr = (unsigned int)(value & 0xffffffff); + AiaoHalWriteReg(AopBuffSaddrReg(chnId), saddr); // buf start + AUDIO_DEVICE_LOG_DEBUG("[OHOS] AopHalSetBufferAddr: write AopHalSetBufferAddr = 0x%08x\n", saddr); + + return HDF_SUCCESS; +} + +int AipHalSetBufferAddr(unsigned int chnId, unsigned long long value) +{ + unsigned int saddr; + + if (chnId >= W_CHANNEL_ID_MAX) { + AUDIO_DEVICE_LOG_ERR("ai_dev%d is invalid!\n", chnId); + return HDF_FAILURE; + } + + saddr = (unsigned int)(value & 0xffffffff); + AiaoHalWriteReg(AipBuffSaddrReg(chnId), saddr); // buf start + AUDIO_DEVICE_LOG_DEBUG("[OHOS] aip_set_ctrl_reg: write aip_hal_set_buffer_addr = 0x%08x\n", saddr); + + return HDF_SUCCESS; +} + +int AipHalSetBuffWptr(unsigned int chnId, unsigned int value) +{ + UTxBuffWptr unTmp; + + if (chnId >= W_CHANNEL_ID_MAX) { + AUDIO_DEVICE_LOG_ERR("ao_dev%d is invalid!\n", chnId); + return HDF_FAILURE; + } + unTmp.u32 = AiaoHalReadReg(AipBuffWptrReg(chnId)); + AUDIO_DEVICE_LOG_DEBUG("@@@ aip_hal_set_buff_wptr: read = 0x%08x, write = 0x%08x.", unTmp.u32, value); + unTmp.Bits.txBuffWptr = value; + AiaoHalWriteReg(AipBuffWptrReg(chnId), unTmp.u32); + + return HDF_SUCCESS; +} + +int AipHalSetBuffRptr(unsigned int chnId, unsigned int value) +{ + UTxBuffRptr unTmp; + + if (chnId >= HI_AI_DEV_MAX_NUM) { + AUDIO_DEVICE_LOG_ERR("ai_dev%d is invalid!\n", chnId); + return HDF_FAILURE; + } + + unTmp.u32 = AiaoHalReadReg(AipBuffRptrReg(chnId)); + AUDIO_DEVICE_LOG_DEBUG("@@@ aip_hal_set_buff_rptr: read = 0x%08x, write = 0x%08x.", unTmp.u32, value); + + unTmp.Bits.txBuffRptr = value; + AiaoHalWriteReg(AipBuffRptrReg(chnId), unTmp.u32); + + return HDF_SUCCESS; +} + +int AipHalSetBufferSize(unsigned int chnId, unsigned int value) +{ + UTxBuffSize unTmp; + + if (chnId >= HI_AO_DEV_MAX_NUM) { + AUDIO_DEVICE_LOG_ERR("ao_dev%d is invalid!\n", chnId); + return HDF_FAILURE; + } + + unTmp.u32 = AiaoHalReadReg(AipBuffSizeReg(chnId)); + AUDIO_DEVICE_LOG_DEBUG("@@@ aip_hal_set_buffer_size: read = 0x%08x, write = 0x%08x.", unTmp.u32, value); + + unTmp.Bits.txBuffSize = value; + AiaoHalWriteReg(AipBuffSizeReg(chnId), unTmp.u32); + + return HDF_SUCCESS; +} + +int AipHalSetTransSize(unsigned int chnId, unsigned int value) +{ + UTxTransSize unTmp; + + if (chnId >= HI_AO_DEV_MAX_NUM) { + AUDIO_DEVICE_LOG_ERR("ai_dev%d is invalid!\n", chnId); + return HDF_FAILURE; + } + + unTmp.u32 = AiaoHalReadReg(AipTransSizeReg(chnId)); + AUDIO_DEVICE_LOG_DEBUG("@@@ aip_hal_set_trans_size: read = 0x%08x, write = 0x%08x.", unTmp.u32, value); + + unTmp.Bits.txTransSize = value; + AiaoHalWriteReg(AipTransSizeReg(chnId), unTmp.u32); + + return HDF_SUCCESS; +} + +int AipHalSetRxStart(unsigned int chnId, bool en) +{ + URxDspCtrl unTmp; + + if (chnId >= HI_AI_DEV_MAX_NUM) { + AUDIO_DEVICE_LOG_ERR("AipHalSetRxStart chnId %d is invalid!\n", chnId); + return -1; + } + + unTmp.u32 = AiaoHalReadReg(AipCtrlReg(chnId)); + AUDIO_DEVICE_LOG_DEBUG("[OHOS] AipHalSetRxStart: AIP_CTRL_REG read %08x \n", unTmp.u32); + + unTmp.Bits.rxDisableDone = 0; + unTmp.Bits.rxEnable = en; + + AiaoHalWriteReg(AipCtrlReg(chnId), unTmp.u32); + AUDIO_DEVICE_LOG_DEBUG("[OHOS] AipHalSetRxStart: AIP_CTRL_REG write %08x \n", unTmp.u32); + + return 0; +} + +int g_debugTick = 0; +int AopHalSetBuffWptr(unsigned int chnId, unsigned int value) +{ + UTxBuffWptr unTmp; + const int tick = 5; + if (chnId >= W_CHANNEL_ID_MAX) { + AUDIO_DEVICE_LOG_ERR("ao_dev%d is invalid!\n", chnId); + return HDF_FAILURE; + } + + unTmp.u32 = AiaoHalReadReg(AopBuffWptrReg(chnId)); + AUDIO_DEVICE_LOG_DEBUG("@@@ AopHalSetBuffWptr: read = 0x%08x, write = 0x%08x.", unTmp.u32, value); + + unTmp.Bits.txBuffWptr = value; + AiaoHalWriteReg(AopBuffWptrReg(chnId), unTmp.u32); + + if (g_debugTick++ > tick) { + g_debugTick = 0; + } + + return HDF_SUCCESS; +} + +int AopHalSetBuffRptr(unsigned int chnId, unsigned int value) +{ + UTxBuffRptr unTmp; + + if (chnId >= R_CHANNEL_ID_MAX) { + AUDIO_DEVICE_LOG_ERR("ao_dev%d is invalid!\n", chnId); + return HDF_FAILURE; + } + + unTmp.u32 = AiaoHalReadReg(AopBuffRptrReg(chnId)); + AUDIO_DEVICE_LOG_DEBUG("@@@ AopHalSetBuffRptr: read = 0x%08x, write = 0x%08x.", unTmp.u32, value); + + unTmp.Bits.txBuffRptr = value; + AiaoHalWriteReg(AopBuffRptrReg(chnId), unTmp.u32); + return HDF_SUCCESS; +} + +int AopHalSetBufferSize(unsigned int chnId, unsigned int value) +{ + UTxBuffSize unTmp; + + if (chnId >= HI_AO_DEV_MAX_NUM) { + AUDIO_DEVICE_LOG_ERR("ao_dev%d is invalid!\n", chnId); + return HDF_FAILURE; + } + + unTmp.u32 = AiaoHalReadReg(AopBuffSizeReg(chnId)); + AUDIO_DEVICE_LOG_DEBUG("@@@ AopHalSetBufferSize: read = 0x%08x, write = 0x%08x.", unTmp.u32, value); + + unTmp.Bits.txBuffSize = value; + AiaoHalWriteReg(AopBuffSizeReg(chnId), unTmp.u32); + + return HDF_SUCCESS; +} + +int AopHalSetTransSize(unsigned int chnId, unsigned int value) +{ + UTxTransSize unTmp; + + if (chnId >= HI_AO_DEV_MAX_NUM) { + AUDIO_DEVICE_LOG_ERR("ao_dev%d is invalid!\n", chnId); + return HDF_FAILURE; + } + + unTmp.u32 = AiaoHalReadReg(AopTransSizeReg(chnId)); + AUDIO_DEVICE_LOG_DEBUG("@@@ AopHalSetTransSize: read = 0x%08x, write = 0x%08x.", unTmp.u32, value); + + unTmp.Bits.txTransSize = value; + AiaoHalWriteReg(AopTransSizeReg(chnId), unTmp.u32); + + return HDF_SUCCESS; +} + +int AopHalSetTxStart(unsigned int chnId, bool en) +{ + UTxDspCtrl unTmp; + AUDIO_DEVICE_LOG_DEBUG("[OHOS] AopHalSetTxStart: entry."); + + if (chnId >= HI_AO_DEV_MAX_NUM) { + AUDIO_DEVICE_LOG_ERR("ao_dev%d is invalid!\n", chnId); + return HDF_FAILURE; + } + + unTmp.u32 = AiaoHalReadReg(AopCtrlReg(chnId)); + AUDIO_DEVICE_LOG_DEBUG("[OHOS] AopHalSetTxStart read chid = %u, val = %08x \n", chnId, unTmp.u32); + + unTmp.Bits.txEnable = en; + AUDIO_DEVICE_LOG_DEBUG("[OHOS] AopHalSetTxStart write chid = %u, val = %08x \n", chnId, unTmp.u32); + AiaoHalWriteReg(AopCtrlReg(chnId), unTmp.u32); + + AUDIO_DEVICE_LOG_DEBUG("[OHOS] AopHalSetTxStart: success !!!"); + + return HDF_SUCCESS; +} + +int32_t InitAiaoGpio(void) +{ + return 0; +} + +void ShowAllAiaoRegister(void) +{ + volatile unsigned int val; + // AIAO REG 00 CLK + val = AiaoHalReadReg(AipI2sRegCfg0(0)); + AUDIO_DEVICE_LOG_DEBUG("[OHOS] AIAO REG: AOP_I2S_REG_CFG0:0x0100 = [%08x]", val); + val = AiaoHalReadReg(AipI2sRegCfg1(0)); + AUDIO_DEVICE_LOG_DEBUG("[OHOS] AIAO REG: AIP_I2S_REG_CFG1:0x0104 = [%08x]", val); + val = AiaoHalReadReg(AipInfAttriReg(0)); + AUDIO_DEVICE_LOG_DEBUG("[OHOS] AIAO REG: AipInfAttriReg:0x1000 = [%08x]", val); + val = AiaoHalReadReg(AipCtrlReg(0)); + AUDIO_DEVICE_LOG_DEBUG("[OHOS] AIAO REG: AipCtrlReg:0x1004 = [%08x]", val); + + // AIAO REG 01 CLK + val = AiaoHalReadReg(AopI2sRegCfg0(0)); + AUDIO_DEVICE_LOG_DEBUG("[OHOS] AIAO REG: AOP_I2S_REG_CFG00 = [%08x]", val); + val = AiaoHalReadReg(AopI2sRegCfg1(0)); + AUDIO_DEVICE_LOG_DEBUG("[OHOS] AIAO REG: AOP_I2S_REG_CFG1 = [%08x]", val); + + // AIAO REG ATTR + val = AiaoHalReadReg(AopInfAttriReg(0)); + AUDIO_DEVICE_LOG_DEBUG("[OHOS] AIAO REG: AOP_INF_ATTRI_REG = [%08x]", val); + + // AIAO REG CTRL + val = AiaoHalReadReg(AopCtrlReg(0)); + AUDIO_DEVICE_LOG_DEBUG("[OHOS] AIAO REG: AOP_CTRL_REG = [%08x]", val); + + // AIAO AIAO_INT_ENA_REG + val = AiaoHalReadReg(AIAO_INT_ENA_REG); + AUDIO_DEVICE_LOG_DEBUG("[OHOS] AIAO REG: AIAO_INT_ENA_REG = [%08x]", val); +} + +int32_t AopHalDevEnable(unsigned int chnId) +{ + int ret = AopHalSetTxStart(chnId, HI_TRUE); + if (ret != HDF_SUCCESS) { + return HDF_FAILURE; + } + + ShowAllAiaoRegister(); + return HDF_SUCCESS; +} + +static int32_t AiaoGetBclkFsclk(unsigned int fsBit, unsigned int rate, + int32_t mclkSel, int32_t *bclkSel, int32_t *lrclkSel) +{ + unsigned int mclkRateNum; + int32_t ret; + + if (g_aioClkInfo.mclkDiv48k256fs == mclkSel) { + mclkRateNum = AUDIO_SAMPLE_RATE_48000 * AIO_FIFO_BIT_WIDTH_256; + } else if (g_aioClkInfo.mclkDiv32k256fs == mclkSel) { + mclkRateNum = AUDIO_SAMPLE_RATE_32000 * AIO_FIFO_BIT_WIDTH_256; + } else if (g_aioClkInfo.mclkDiv441k256fs == mclkSel) { + mclkRateNum = AUDIO_SAMPLE_RATE_44100 * AIO_FIFO_BIT_WIDTH_256; + } else if (g_aioClkInfo.mclkDiv48k320fs == mclkSel) { + mclkRateNum = AUDIO_SAMPLE_RATE_48000 * AIO_FIFO_BIT_WIDTH_320; + } else if (g_aioClkInfo.mclkDiv32k320fs == mclkSel) { + mclkRateNum = AUDIO_SAMPLE_RATE_32000 * AIO_FIFO_BIT_WIDTH_320; + } else if (g_aioClkInfo.mclkDiv441k320fs == mclkSel) { + mclkRateNum = AUDIO_SAMPLE_RATE_44100 * AIO_FIFO_BIT_WIDTH_320; + } else { + AUDIO_DEVICE_LOG_ERR("not support this mclk\n"); + return HDF_FAILURE; + } + + AUDIO_DEVICE_LOG_DEBUG("AiaoGetBclkFsclkDivCfg, mclkSel = %d,mclkRateNum=%d\n", mclkSel, mclkRateNum); + + if ((mclkRateNum % (fsBit * rate)) != 0) { + AUDIO_DEVICE_LOG_ERR("can not get the bclkDivision ratio\n"); + return HDF_FAILURE; + } + + ret = AiaoGetBclkSel(mclkRateNum / (fsBit * rate), bclkSel); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("AiaoGetBclkSel error\n"); + return ret; + } + + AUDIO_DEVICE_LOG_DEBUG("[OHOS] AiaoGetBclkFsclkDivCfg, bclkSel=%u\n", *bclkSel); + + ret = AiaoGetLrclkSel(fsBit, lrclkSel); + AUDIO_DEVICE_LOG_DEBUG("[OHOS] AiaoGetBclkFsclkDivCfg, fsBit = %d,lrclkSel=%u\n", fsBit, *lrclkSel); + + return ret; +} + +static int32_t AiaoGetMclk(unsigned int channelCnt, unsigned int rate, uint32_t *mclkSel) +{ + switch (rate) { + case AUDIO_SAMPLE_RATE_8000: + case AUDIO_SAMPLE_RATE_16000: + case AUDIO_SAMPLE_RATE_32000: + case AUDIO_SAMPLE_RATE_64000: { + *mclkSel = (channelCnt == AIAO_CHN_CNT_20) ? + g_aioClkInfo.mclkDiv32k320fs : g_aioClkInfo.mclkDiv32k256fs; + break; + } + + case AUDIO_SAMPLE_RATE_12000: + case AUDIO_SAMPLE_RATE_24000: + case AUDIO_SAMPLE_RATE_48000: + case AUDIO_SAMPLE_RATE_96000: { + *mclkSel = (channelCnt == AIAO_CHN_CNT_20) ? + g_aioClkInfo.mclkDiv48k320fs : g_aioClkInfo.mclkDiv48k256fs; + break; + } + + case AUDIO_SAMPLE_RATE_11025: + case AUDIO_SAMPLE_RATE_22050: + case AUDIO_SAMPLE_RATE_44100: { + *mclkSel = (channelCnt == AIAO_CHN_CNT_20) ? + g_aioClkInfo.mclkDiv441k320fs : g_aioClkInfo.mclkDiv441k256fs; + break; + } + + default: { + AUDIO_DEVICE_LOG_ERR("not support this sample rate\n"); + return HDF_FAILURE; + } + } + + return HDF_SUCCESS; +} + +static unsigned int AiaoGetBitCnt(unsigned int bitWidth) +{ + if (bitWidth == BIT_WIDTH8) { + return BIT_WIDTH8; /* 8:8bit */ + } else if (bitWidth == BIT_WIDTH16) { + return BIT_WIDTH16; /* 16:16bit */ + } else { + return BIT_WIDTH32; /* 32:32bit */ + } +} + +int32_t AiaoSetSysCtlRegValue(unsigned int mclkSel, unsigned int bitWidth, unsigned int rate, UI2sCrgCfg1 *i2sCrgCfg1) +{ + int32_t ret; + unsigned int fsBit; + unsigned int bclkSel = 0; + unsigned int lrClkSel = 0; + const int dobule = 2; + + if (i2sCrgCfg1 == NULL) { + AUDIO_DEVICE_LOG_ERR("AiaoSetSysCtlRegValue::param i2sCrgCfg1 is nullptr."); + return HDF_ERR_INVALID_PARAM; + } + fsBit = AiaoGetBitCnt(bitWidth) * dobule; + ret = AiaoGetBclkFsclk(fsBit, rate, mclkSel, &bclkSel, &lrClkSel); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("AiaoGetBclkFsclk fail"); + return HDF_FAILURE; + } + + i2sCrgCfg1->Bits.aiaoBclkDiv = bclkSel; + i2sCrgCfg1->Bits.aiaoFsclkDiv = lrClkSel; + i2sCrgCfg1->Bits.aiaoCken = 1; + i2sCrgCfg1->Bits.aiaoSrstReq = 0; + i2sCrgCfg1->Bits.aiaoBclkEn = 1; + i2sCrgCfg1->Bits.aiaoWsEn = 1; + return HDF_SUCCESS; +} + +int32_t AopSetSysCtlReg(int32_t chnId, unsigned int channelCnt, unsigned int bitWidth, unsigned int rate) +{ + unsigned int mclkSel = 0; + int32_t ret; + + UI2sCrgCfg0 i2sCrgCfg0; + UI2sCrgCfg1 i2sCrgCfg1; + + /* READ & PRINT */ + i2sCrgCfg0.u32 = AiaoHalReadReg(AopI2sRegCfg0(chnId)); + i2sCrgCfg1.u32 = AiaoHalReadReg(AopI2sRegCfg1(chnId)); + + /* get clock value */ + ret = AiaoGetMclk(channelCnt, rate, &mclkSel); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("[OHOS] AopSetSysCtl AiaoGetMclkCfg checking"); + return HDF_FAILURE; + } + + i2sCrgCfg0.Bits.aiaoMclkDiv = mclkSel; + i2sCrgCfg0.Bits.reserved0 = 0; + AiaoHalWriteReg(AopI2sRegCfg0(chnId), i2sCrgCfg0.u32); + + ret = AiaoSetSysCtlRegValue(mclkSel, bitWidth, rate, &i2sCrgCfg1); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("AopSetSysCtl:AiaoSetSysCtlRegValue checking failed."); + return HDF_FAILURE; + } + + AiaoHalWriteReg(AopI2sRegCfg1(chnId), i2sCrgCfg1.u32); + + AUDIO_DEVICE_LOG_DEBUG("AopSetSysCtl: AiaoHalWriteReg, i2sCrgCfg0 = 0x%08x i2sCrgCfg1 = 0x%08x", + i2sCrgCfg0.u32, i2sCrgCfg1.u32); + + return HDF_SUCCESS; +} + +int32_t AipSetSysCtlReg(int32_t chnId, unsigned int channelCnt, unsigned int bitWidth, unsigned int rate) +{ + unsigned int mclkSel = 0; + int32_t ret; + + UI2sCrgCfg0 i2sCrgCfg0; + UI2sCrgCfg1 i2sCrgCfg1; + + /* READ & PRINT */ + i2sCrgCfg0.u32 = AiaoHalReadReg(AipI2sRegCfg0(chnId)); + i2sCrgCfg1.u32 = AiaoHalReadReg(AipI2sRegCfg1(chnId)); + + /* get clock value */ + ret = AiaoGetMclk(channelCnt, rate, &mclkSel); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("[OHOS] AopSetSysCtl AiaoGetMclkCfg checking"); + return HDF_FAILURE; + } + + i2sCrgCfg0.Bits.aiaoMclkDiv = mclkSel; + i2sCrgCfg0.Bits.reserved0 = 0; + AiaoHalWriteReg(AipI2sRegCfg0(chnId), i2sCrgCfg0.u32); + + ret = AiaoSetSysCtlRegValue(mclkSel, bitWidth, rate, &i2sCrgCfg1); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_ERR("AipSetSysCtlReg:AiaoSetSysCtlRegValue checking failed."); + return HDF_FAILURE; + } + + AiaoHalWriteReg(AipI2sRegCfg1(chnId), i2sCrgCfg1.u32); + + AUDIO_DEVICE_LOG_DEBUG("AipSetSysCtlReg: AiaoHalWriteReg, i2sCrgCfg0 = 0x%08x i2sCrgCfg1 = 0x%08x", + i2sCrgCfg0.u32, i2sCrgCfg1.u32); + + return HDF_SUCCESS; +} + +int32_t AopSetAttr(unsigned int chnId, unsigned int channelCnt, unsigned int bitWidth) +{ + UTxIfAttri aopAttrReg; + AUDIO_DEVICE_LOG_DEBUG("AopSetAttr entry"); + aopAttrReg.u32 = AiaoHalReadReg(AopInfAttriReg(chnId)); + + if (channelCnt == AIO_CHN_CNT_1) { + aopAttrReg.Bits.txChNum = 0x0; + } else if (channelCnt == AIO_CHN_CNT_2) { + aopAttrReg.Bits.txChNum = 0x1; + } else { + AUDIO_DEVICE_LOG_ERR("[OHOS] AopSetAttrReg: attr->channelCnt error."); + return HDF_FAILURE; + } + + if (bitWidth == BIT_WIDTH16) { + aopAttrReg.Bits.txI2sPrecision = 0x1; + } else if (bitWidth == BIT_WIDTH24) { + aopAttrReg.Bits.txI2sPrecision = 0x2; /* 2: 24bit */ + } else { + AUDIO_DEVICE_LOG_ERR("[OHOS] AopSetAttrReg: attr->channelCnt error bitWidth: %d.", bitWidth); + return HDF_FAILURE; + } + + aopAttrReg.Bits.txTrackmode = 0; + AiaoHalWriteReg(AopInfAttriReg(chnId), aopAttrReg.u32); + AUDIO_DEVICE_LOG_DEBUG("[OHOS] AopSetAttrReg aopAttrReg.u32 write = %08x\n", aopAttrReg.u32); + + return HDF_SUCCESS; +} + +int32_t AipSetAttr(unsigned int chnId, unsigned int channelCnt, unsigned int bitWidth) +{ + URxIfAttri aipAttrReg; + const int sourceSel = 8; + AUDIO_DEVICE_LOG_DEBUG("AopSetAttr entry"); + aipAttrReg.u32 = AiaoHalReadReg(AipInfAttriReg(chnId)); + + if (channelCnt == AIO_CHN_CNT_1) { + aipAttrReg.Bits.rxChNum = 0x0; + } else if (channelCnt == AIO_CHN_CNT_2) { + aipAttrReg.Bits.rxChNum = 0x1; + } else { + AUDIO_DEVICE_LOG_ERR("[OHOS] AipSetAttr: attr->channelCnt error."); + return HDF_FAILURE; + } + + if (bitWidth == BIT_WIDTH16) { + aipAttrReg.Bits.rxI2sPrecision = 0x1; + } else if (bitWidth == BIT_WIDTH24) { + aipAttrReg.Bits.rxI2sPrecision = 0x2; /* 2: 24bit */ + } else { + AUDIO_DEVICE_LOG_ERR("[OHOS] AipSetAttr: attr->channelCnt error bitWidth: %d.", bitWidth); + return HDF_FAILURE; + } + + aipAttrReg.Bits.rxTrackMode = 0; + aipAttrReg.Bits.rxSdSourceSel = sourceSel; + AiaoHalWriteReg(AipInfAttriReg(chnId), aipAttrReg.u32); + AUDIO_DEVICE_LOG_DEBUG("[OHOS] AipSetAttr aopAttrReg.u32 write = %08x\n", aipAttrReg.u32); + + return HDF_SUCCESS; +} + +static void AipSetCtrlReg(unsigned int chnId) +{ + URxDspCtrl aipCtrlReg; + + aipCtrlReg.u32 = AiaoHalReadReg(AipCtrlReg(chnId)); + aipCtrlReg.Bits.muteEn = 0; + aipCtrlReg.Bits.muteFadeEn = 0; + aipCtrlReg.Bits.pauseEn = 0; + aipCtrlReg.Bits.pauseFadeEn = 0; + aipCtrlReg.Bits.reserved3 = 0; + aipCtrlReg.Bits.volume = 0; + aipCtrlReg.Bits.reserved2 = 0; + aipCtrlReg.Bits.fadeInRate = 0; + aipCtrlReg.Bits.fadeOutRate = 0; + aipCtrlReg.Bits.reserved1 = 0; + aipCtrlReg.Bits.bypassEn = 0; + aipCtrlReg.Bits.rxEnable = 0; + aipCtrlReg.Bits.rxDisableDone = 0; + aipCtrlReg.Bits.reserved0 = 0; + AiaoHalWriteReg(AipCtrlReg(chnId), aipCtrlReg.u32); +} + +int32_t I2sCrgCfgInit(unsigned int chnId) +{ + const unsigned int i2sCrgCfg0 = 0x152ef0; + const unsigned int i2sCrgCfg1 = 0x0000c115; + + AiaoHalWriteReg(AopI2sRegCfg0(chnId), i2sCrgCfg0); + AiaoHalWriteReg(AopI2sRegCfg1(chnId), i2sCrgCfg1); + AiaoHalWriteReg(AipI2sRegCfg0(chnId), i2sCrgCfg0); + AiaoHalWriteReg(AipI2sRegCfg1(chnId), i2sCrgCfg1); + return HDF_SUCCESS; +} + +int32_t AiaoDeviceInit(unsigned int chnId) +{ + const unsigned int aipAttrVal = 0xe4880014; + const unsigned int aopAttrVal = 0xe4000054; + + AiaoHalWriteReg(AipInfAttriReg(chnId), aipAttrVal); + AiaoHalWriteReg(AopInfAttriReg(chnId), aopAttrVal); + AopSetCtrlReg(chnId); + AipSetCtrlReg(chnId); + return HDF_SUCCESS; +} diff --git a/audio/chipsets/codec/hi3516_codec/src/hi3516_codec.c b/audio/chipsets/codec/hi3516_codec/src/hi3516_codec.c new file mode 100755 index 0000000000000000000000000000000000000000..8d5d360c30bfc981757807aae807aa5b77d76d25 --- /dev/null +++ b/audio/chipsets/codec/hi3516_codec/src/hi3516_codec.c @@ -0,0 +1,297 @@ +/* + * 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 "hi3516_codec.h" +#include +#include "audio_device_log.h" +#include "hdf_base.h" +#include "hdf_log.h" +#include "osal_io.h" + +static void *g_regAcodecBase = NULL; // CODEC Reg Base Addr +const int HALF_MINUTE = 30; +const int VOLUME_DB_MAX = 6; +const int VOLUME_DB_MIN = -121; + +int32_t CodecHalSysInit(void) +{ + // ACODEC REMAP + if (g_regAcodecBase == NULL) { + g_regAcodecBase = OsalIoRemap(ACODEC_REG_BASE, ACODEC_MAX_REG_SIZE); // ACODEC_MAX_REG_SIZE + if (g_regAcodecBase == NULL) { + return HDF_FAILURE; + } + } + return HDF_SUCCESS; +} + +void AcodecHalWriteReg(unsigned int offset, unsigned int value) +{ + *(volatile unsigned int *)((unsigned char *)(g_regAcodecBase) + (unsigned int)(offset)) = value; +} + +unsigned int AcodecHalReadReg(unsigned int offset) +{ + return (*(volatile unsigned int *)((unsigned char *)g_regAcodecBase + (unsigned int)offset)); +} + +static int AcodecSoftReset(void) +{ + AcodecDigCtrl1 acodecDigctrl1; + AcodecDigCtrl2 acodecDigctrl2; + AcodecDigCtrl3 acodecDigctrl3; + AcodecDigCtrl4 acodecDigctrl4; + + AcodecAnaReg0 acodecAnareg0; + AcodecAnaReg1 acodecAnareg1; + AcodecAnaReg2 acodecAnareg2; + AcodecAnaReg3 acodecAnareg3; + AcodecAnaReg4 acodecAnareg4; + + if (g_regAcodecBase == NULL) { + AUDIO_DEVICE_LOG_ERR("haven't ioremap acodec regs."); + return HDF_FAILURE; + } + + acodecAnareg0.ul32 = 0x04000002; + AcodecHalWriteReg(ACODEC_ANAREG0_ADDR, acodecAnareg0.ul32); + acodecAnareg1.ul32 = 0xFD200004; + AcodecHalWriteReg(ACODEC_ANAREG1_ADDR, acodecAnareg1.ul32); + acodecAnareg2.ul32 = 0x00180018; + AcodecHalWriteReg(ACODEC_ANAREG2_ADDR, acodecAnareg2.ul32); + acodecAnareg3.ul32 = 0x83830028; + AcodecHalWriteReg(ACODEC_ANAREG3_ADDR, acodecAnareg3.ul32); + acodecAnareg4.ul32 = 0x00005C5C; + AcodecHalWriteReg(ACODEC_ANAREG4_ADDR, acodecAnareg4.ul32); + // offset 0x28 + AcodecHalWriteReg(ACODEC_ANAREG5_ADDR, 0x130000); + + acodecDigctrl1.ul32 = 0xff035a00; + AcodecHalWriteReg(ACODEC_DIGCTRL1_ADDR, acodecDigctrl1.ul32); + acodecDigctrl2.ul32 = 0x08000001; + AcodecHalWriteReg(ACODEC_DIGCTRL2_ADDR, acodecDigctrl2.ul32); + acodecDigctrl3.ul32 = 0x06062424; + AcodecHalWriteReg(ACODEC_DIGCTRL3_ADDR, acodecDigctrl3.ul32); + acodecDigctrl4.ul32 = 0x1e1ec001; + AcodecHalWriteReg(ACODEC_DIGCTRL4_ADDR, acodecDigctrl4.ul32); + + return HDF_SUCCESS; +} + +/* 0x14, 0x18, 0x1c, 0x20 */ +static void AcodecInitInner(AcodecAnaReg0 *acodecAnareg0, AcodecAnaReg1 *acodecAnareg1, + AcodecAnaReg2 *acodecAnareg2, AcodecAnaReg3 *acodecAnareg3) +{ + acodecAnareg2->Bits.acodecRst = 0x0; + AcodecHalWriteReg(ACODEC_ANAREG2_ADDR, acodecAnareg2->ul32); + + acodecAnareg3->Bits.acodecPopresSel = 0x1; + acodecAnareg3->Bits.acodecPoprampclkSel = 0x1; + AcodecHalWriteReg(ACODEC_ANAREG3_ADDR, acodecAnareg3->ul32); + acodecAnareg2->Bits.acodecVrefSel = 0x0; + AcodecHalWriteReg(ACODEC_ANAREG2_ADDR, acodecAnareg2->ul32); + + acodecAnareg0->Bits.acodecPdbCtcmIbias = 0x1; + acodecAnareg0->Bits.acodecPdIbias = 0x1; + AcodecHalWriteReg(ACODEC_ANAREG0_ADDR, acodecAnareg0->ul32); + + acodecAnareg1->Bits.acodecRxCtcmPd = 0x0; + AcodecHalWriteReg(ACODEC_ANAREG1_ADDR, acodecAnareg1->ul32); + + acodecAnareg2->Bits.acodecLdoPd = 0x0; + AcodecHalWriteReg(ACODEC_ANAREG2_ADDR, acodecAnareg2->ul32); + + acodecAnareg0->Bits.acodecPdVref = 0x0; + AcodecHalWriteReg(ACODEC_ANAREG0_ADDR, acodecAnareg0->ul32); + + acodecAnareg3->Bits.acodecDacrPopDirect = 0x1; + acodecAnareg3->Bits.acodecDaclPopDirect = 0x1; + AcodecHalWriteReg(ACODEC_ANAREG3_ADDR, acodecAnareg3->ul32); + + OsalMSleep(HALF_MINUTE); + + acodecAnareg0->Bits.acodecPdDacr = 0x0; + acodecAnareg0->Bits.acodecPdDacl = 0x0; + acodecAnareg0->Bits.acodecMuteDacr = 0x0; + acodecAnareg0->Bits.acodecMuteDacl = 0x0; + AcodecHalWriteReg(ACODEC_ANAREG0_ADDR, acodecAnareg0->ul32); + + acodecAnareg0->Bits.acodecDacrPopEn = 0x0; + acodecAnareg0->Bits.acodecDaclPopEn = 0x0; + AcodecHalWriteReg(ACODEC_ANAREG0_ADDR, acodecAnareg0->ul32); +} + +int AcodecDeviceInit(void) +{ + int ret; + const int tenSeconds = 10; + AcodecAnaReg0 acodecAnareg0; + AcodecAnaReg1 acodecAnareg1; + AcodecAnaReg2 acodecAnareg2; + AcodecAnaReg3 acodecAnareg3; + AcodecAnaReg4 acodecAnareg4; + OsalMSleep(tenSeconds); /* sleep 10 ms */ + /* 0x14, 0x18, 0x1c, 0x20, 0x24 */ + acodecAnareg0.ul32 = 0x040578E1; + AcodecHalWriteReg(ACODEC_ANAREG0_ADDR, acodecAnareg0.ul32); + acodecAnareg1.ul32 = 0xFD220004; + AcodecHalWriteReg(ACODEC_ANAREG1_ADDR, acodecAnareg1.ul32); + acodecAnareg2.ul32 = 0x4098001B; + AcodecHalWriteReg(ACODEC_ANAREG2_ADDR, acodecAnareg2.ul32); + acodecAnareg3.ul32 = 0x8383FE00; + AcodecHalWriteReg(ACODEC_ANAREG3_ADDR, acodecAnareg3.ul32); + acodecAnareg4.ul32 = 0x0000505C; + AcodecHalWriteReg(ACODEC_ANAREG4_ADDR, acodecAnareg4.ul32); + AcodecHalWriteReg(ACODEC_ANAREG5_ADDR, 0x0); + AcodecInitInner(&acodecAnareg0, &acodecAnareg1, &acodecAnareg2, &acodecAnareg3); + acodecAnareg2.Bits.acodecLdoBk = 0x0; + AcodecHalWriteReg(ACODEC_ANAREG2_ADDR, acodecAnareg2.ul32); + acodecAnareg3.Bits.acodecPdAdcTune09 = 0x0; + AcodecHalWriteReg(ACODEC_ANAREG3_ADDR, acodecAnareg3.ul32); + acodecAnareg4.Bits.acodecAdcTuneSel09 = 0x1; + AcodecHalWriteReg(ACODEC_ANAREG4_ADDR, acodecAnareg4.ul32); + acodecAnareg4.Bits.acodecAdcTuneEn09 = 0x1; + AcodecHalWriteReg(ACODEC_ANAREG4_ADDR, acodecAnareg4.ul32); + + ret = AcodecSoftReset(); + if (ret != HDF_SUCCESS) { + AUDIO_DEVICE_LOG_DEBUG("AcodecSoftReset fail"); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +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); + // ACODEC REG 0030 + val = AcodecHalReadReg(ACODEC_DIGCTRL1_ADDR); + AUDIO_DEVICE_LOG_DEBUG("ACODEC REG: ACODEC_DIGCTRL1_ADDR = [%08x]", val); + + val = AcodecHalReadReg(ACODEC_DIGCTRL3_ADDR); + AUDIO_DEVICE_LOG_DEBUG("ACODEC REG: ACODEC_DIGCTRL3_ADDR = [%08x]", val); +} + +static unsigned int AcodecGetI2sFs(const unsigned int rate) +{ + switch (rate) { + case AUDIO_SAMPLE_RATE_8000: + case AUDIO_SAMPLE_RATE_11025: + case AUDIO_SAMPLE_RATE_12000: + return ACODEC_I2S_FS_8000; + case AUDIO_SAMPLE_RATE_16000: + case AUDIO_SAMPLE_RATE_22050: + case AUDIO_SAMPLE_RATE_24000: + return ACODEC_I2S_FS_16000; + case AUDIO_SAMPLE_RATE_32000: + case AUDIO_SAMPLE_RATE_44100: + case AUDIO_SAMPLE_RATE_48000: + return ACODEC_I2S_FS_32000; + case AUDIO_SAMPLE_RATE_64000: + case AUDIO_SAMPLE_RATE_96000: + return ACODEC_I2S_FS_64000; + default: + AUDIO_DEVICE_LOG_DEBUG("unsupport samplerate %d\n", rate); + return ACODEC_I2S_FS_BUTT; + } +} + +static unsigned int AcodecGetAdcModeSel(const unsigned int rate) +{ + switch (rate) { + case AUDIO_SAMPLE_RATE_8000: + case AUDIO_SAMPLE_RATE_16000: + case AUDIO_SAMPLE_RATE_32000: + case AUDIO_SAMPLE_RATE_64000: + return ACODEC_ADC_MODESEL_4096; + case AUDIO_SAMPLE_RATE_11025: + case AUDIO_SAMPLE_RATE_12000: + case AUDIO_SAMPLE_RATE_22050: + case AUDIO_SAMPLE_RATE_24000: + case AUDIO_SAMPLE_RATE_44100: + case AUDIO_SAMPLE_RATE_48000: + case AUDIO_SAMPLE_RATE_96000: + return ACODEC_ADC_MODESEL_6144; + default: + AUDIO_DEVICE_LOG_DEBUG("unsupport samplerate %d.\n", rate); + return ACODEC_I2S_FS_BUTT; + } +} + +int32_t AcodecSetI2s1Fs(const unsigned int rate) +{ + AcodecDigCtrl1 acodecDigctrl1; + AcodecAnaReg2 acodecAnaReg2; + AcodecAnaReg4 acodecAnaReg4; + + if (rate >= AUDIO_SAMPLE_RATE_BUTT) { + AUDIO_DEVICE_LOG_ERR("bad value, please use acodec_fs define\n"); + return HDF_FAILURE; + } + + acodecDigctrl1.ul32 = AcodecHalReadReg(ACODEC_DIGCTRL1_ADDR); + acodecDigctrl1.Bits.i2s1FsSel = AcodecGetI2sFs(rate); + AcodecHalWriteReg(ACODEC_DIGCTRL1_ADDR, acodecDigctrl1.ul32); + + acodecAnaReg2.ul32 = AcodecHalReadReg(ACODEC_ANAREG2_ADDR); + acodecAnaReg2.Bits.acodecAdcrModeSel = AcodecGetAdcModeSel(rate); + acodecAnaReg2.Bits.acodecAdclModeSel = AcodecGetAdcModeSel(rate); + AcodecHalWriteReg(ACODEC_ANAREG2_ADDR, acodecAnaReg2.ul32); + + /* rctune */ + acodecAnaReg4.ul32 = AcodecHalReadReg(ACODEC_ANAREG4_ADDR); + acodecAnaReg4.Bits.acodecAdcTuneEn09 = 0; + AcodecHalWriteReg(ACODEC_ANAREG4_ADDR, acodecAnaReg4.ul32); + + OsalUDelay(HALF_MINUTE); /* wait 30 us. */ + acodecAnaReg4.ul32 = AcodecHalReadReg(ACODEC_ANAREG4_ADDR); + acodecAnaReg4.Bits.acodecAdcTuneEn09 = 1; + AcodecHalWriteReg(ACODEC_ANAREG4_ADDR, acodecAnaReg4.ul32); + + return HDF_SUCCESS; +} + +int32_t AcodecSetI2s1DataWidth(const unsigned int bitWidth) +{ + AcodecDigCtrl1 acodecDigctrl1; + AudioCodecBitWidth codecBitWidth; + codecBitWidth = AUDIO_CODEC_BIT_WIDTH_16; + switch (bitWidth) { + case BIT_WIDTH16: + codecBitWidth = AUDIO_CODEC_BIT_WIDTH_16; + break; + case BIT_WIDTH18: + codecBitWidth = AUDIO_CODEC_BIT_WIDTH_18; + break; + case BIT_WIDTH20: + codecBitWidth = AUDIO_CODEC_BIT_WIDTH_20; + break; + case BIT_WIDTH24: + codecBitWidth = AUDIO_CODEC_BIT_WIDTH_24; + break; + default: + return HDF_FAILURE; + break; + } + + acodecDigctrl1.ul32 = AcodecHalReadReg(ACODEC_DIGCTRL1_ADDR); + acodecDigctrl1.Bits.i2s1DataBits = codecBitWidth; + AcodecHalWriteReg(ACODEC_DIGCTRL1_ADDR, acodecDigctrl1.ul32); + return HDF_SUCCESS; +} diff --git a/audio/chipsets/dsp/hi3516_dsp/hi3516_dsp.c b/audio/chipsets/dsp/hi3516_dsp/hi3516_dsp.c new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/audio/chipsets/include/audio_device_log.h b/audio/chipsets/include/audio_device_log.h new file mode 100755 index 0000000000000000000000000000000000000000..ced20ec7b916e6087c873a72b9d7a83b0c6f5074 --- /dev/null +++ b/audio/chipsets/include/audio_device_log.h @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2020-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 AUDIO_DEVICE_LOG_H +#define AUDIO_DEVICE_LOG_H +#include "hdf_log.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +#define AUDIO_DEVICE_LOG_ERR(fmt, arg...) do { \ + HDF_LOGE("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) + +#define AUDIO_DEVICE_LOG_INFO(fmt, arg...) do { \ + HDF_LOGI("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) + +#define AUDIO_DEVICE_LOG_WARNING(fmt, arg...) do { \ + HDF_LOGW("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) + +#define AUDIO_DEVICE_LOG_DEBUG(fmt, arg...) do { \ + HDF_LOGD("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* AUDIO_DEVICE_LOG_H */ diff --git a/audio/hal/hdi_binder/proxy/include/audio_proxy_common.h b/audio/hal/hdi_binder/proxy/include/audio_proxy_common.h new file mode 100755 index 0000000000000000000000000000000000000000..554d663eaab4f298646e45fd24df2a5347f180fc --- /dev/null +++ b/audio/hal/hdi_binder/proxy/include/audio_proxy_common.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef AUDIO_PROXY_COMMON_H +#define AUDIO_PROXY_COMMON_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 + +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 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); + +#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 new file mode 100755 index 0000000000000000000000000000000000000000..44b224e506e77d88cc7bb50423e67a2a3dc0455e --- /dev/null +++ b/audio/hal/hdi_binder/proxy/include/audio_proxy_internal.h @@ -0,0 +1,108 @@ +/* + * 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_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, + const struct AudioDeviceDescriptor *desc, + const struct AudioSampleAttributes *attrs, + struct AudioRender **render); +int32_t AudioProxyAdapterDestroyRender(struct AudioAdapter *adapter, + struct AudioRender *render); +int32_t AudioProxyAdapterCreateCapture(struct AudioAdapter *adapter, + const struct AudioDeviceDescriptor *desc, + const struct AudioSampleAttributes *attrs, + struct AudioCapture **capture); +int32_t AudioProxyAdapterDestroyCapture(struct AudioAdapter *adapter, + struct AudioCapture *capture); +int32_t AudioProxyAdapterGetPortCapability(struct AudioAdapter *adapter, + const struct AudioPort *port, struct AudioPortCapability *capability); +int32_t AudioProxyAdapterSetPassthroughMode(struct AudioAdapter *adapter, + const struct AudioPort *port, enum AudioPortPassthroughMode mode); +int32_t AudioProxyAdapterGetPassthroughMode(struct AudioAdapter *adapter, + const struct AudioPort *port, enum AudioPortPassthroughMode *mode); +int32_t AudioProxyRenderStart(AudioHandle handle); +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, + const struct AudioSampleAttributes *attrs); +int32_t AudioProxyRenderGetSampleAttributes(AudioHandle handle, + struct AudioSampleAttributes *attrs); +int32_t AudioProxyRenderGetCurrentChannelId(AudioHandle handle, uint32_t *channelId); +int32_t AudioProxyRenderCheckSceneCapability(AudioHandle handle, + const struct AudioSceneDescriptor *scene, bool *supported); +int32_t AudioProxyRenderSelectScene(AudioHandle handle, + const struct AudioSceneDescriptor *scene); +int32_t AudioProxyRenderSetMute(AudioHandle handle, bool mute); +int32_t AudioProxyRenderGetMute(AudioHandle handle, bool *mute); +int32_t AudioProxyRenderSetVolume(AudioHandle handle, float volume); +int32_t AudioProxyRenderGetVolume(AudioHandle handle, float *volume); +int32_t AudioProxyRenderGetGainThreshold(AudioHandle handle, float *min, float *max); +int32_t AudioProxyRenderGetGain(AudioHandle handle, float *gain); +int32_t AudioProxyRenderSetGain(AudioHandle handle, float gain); +int32_t AudioProxyRenderGetLatency(struct AudioRender *render, uint32_t *ms); +int32_t AudioProxyRenderRenderFrame(struct AudioRender *render, const void *frame, + uint64_t requestBytes, uint64_t *replyBytes); +int32_t AudioProxyRenderGetRenderPosition(struct AudioRender *render, + uint64_t *frames, struct AudioTimeStamp *time); +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 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, + struct AudioSampleAttributes *attrs); +int32_t AudioProxyCaptureGetCurrentChannelId(AudioHandle handle, uint32_t *channelId); +int32_t AudioProxyCaptureCheckSceneCapability(AudioHandle handle, + const struct AudioSceneDescriptor *scene, bool *supported); +int32_t AudioProxyCaptureSelectScene(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 AudioProxyCaptureCaptureFrame(struct AudioCapture *capture, + void *frame, uint64_t requestBytes, uint64_t *replyBytes); +int32_t AudioProxyCaptureGetCapturePosition(struct AudioCapture *capture, + uint64_t *frames, struct AudioTimeStamp *time); + +#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 new file mode 100755 index 0000000000000000000000000000000000000000..553e67a4b55195be9a56aa40a26bc1bcaae925db --- /dev/null +++ b/audio/hal/hdi_binder/proxy/include/audio_proxy_manager.h @@ -0,0 +1,65 @@ +/* + * 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 Defines audio-related APIs, including custom data types and functions for loading drivers, + * accessing a driver adapter, and rendering and capturing audios. + * + * @since 1.0 + * @version 1.0 + */ + +/** + * @file audio_manager.h + * + * @brief Declares APIs for audio adapter management and loading. + * + * @since 1.0 + * @version 1.0 + */ + +#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 HdfRemoteService *remote; + struct AudioManager proxyAudioManager; +}; +int32_t AudioProxyManagerGetAllAdapters(struct AudioManager *manager, + struct AudioAdapterDescriptor **descs, + int *size); +int32_t AudioProxyManagerLoadAdapter(struct AudioManager *manager, const struct AudioAdapterDescriptor *desc, + struct AudioAdapter **adapter); +void AudioProxyManagerUnloadAdapter(struct AudioManager *manager, struct AudioAdapter *adapter); + +struct AudioManager *GetAudioProxyManagerFuncs(void); + +#ifdef __cplusplus +} +#endif + +#endif /* AUDIO_MANAGER_H */ +/** @} */ diff --git a/audio/hal/hdi_binder/proxy/src/BUILD.gn b/audio/hal/hdi_binder/proxy/src/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..d13c349cbdaa5d6f99fd65b788ca0a10617ed583 --- /dev/null +++ b/audio/hal/hdi_binder/proxy/src/BUILD.gn @@ -0,0 +1,112 @@ +# 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 new file mode 100755 index 0000000000000000000000000000000000000000..0babc5900e0d5d7a12ed4b39f1bca1d80d0f749f --- /dev/null +++ b/audio/hal/hdi_binder/proxy/src/audio_proxy_adapter.c @@ -0,0 +1,654 @@ +/* + * 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_proxy_common.h" +#include "audio_proxy_internal.h" + +int32_t AudioProxyCommonInitAttrs(struct HdfSBuf *data, const struct AudioSampleAttributes *attrs) +{ + if (data == NULL || attrs == NULL) { + LOG_FUN_ERR("data == NULL || attrs == NULL"); + return HDF_FAILURE; + } + uint32_t tempAtrr; + tempAtrr = (uint32_t)attrs->interleaved; + if (!HdfSbufWriteUint32(data, tempAtrr)) { + return HDF_FAILURE; + } + tempAtrr = (uint32_t)attrs->type; + if (!HdfSbufWriteUint32(data, tempAtrr)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, attrs->period)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, attrs->frameSize)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, attrs->startThreshold)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, attrs->stopThreshold)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, attrs->silenceThreshold)) { + return HDF_FAILURE; + } + tempAtrr = (uint32_t)attrs->isBigEndian; + if (!HdfSbufWriteUint32(data, tempAtrr)) { + return HDF_FAILURE; + } + tempAtrr = (uint32_t)attrs->isSignedData; + if (!HdfSbufWriteUint32(data, tempAtrr)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioProxyCommonInitCreateData(struct HdfSBuf *data, struct AudioAdapter *adapter, + const struct AudioDeviceDescriptor *desc, const struct AudioSampleAttributes *attrs) +{ + LOG_FUN_INFO(); + if (data == NULL || adapter == NULL || desc == NULL || attrs == NULL) { + LOG_FUN_ERR("data == NULL || adapter == NULL || desc == NULL || attrs == NULL"); + return HDF_FAILURE; + } + uint32_t tempDesc; + uint32_t tempAtrr; + uint32_t pid = getpid(); + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + const char *adapterName = hwAdapter->adapterDescriptor.adapterName; + if (adapterName == NULL) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(data, adapterName)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, pid)) { + return HDF_FAILURE; + } + tempAtrr = (uint32_t)attrs->format; + if (!HdfSbufWriteUint32(data, tempAtrr)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, attrs->channelCount)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, attrs->sampleRate)) { + return HDF_FAILURE; + } + if (AudioProxyCommonInitAttrs(data, attrs) < 0) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, desc->portId)) { + return HDF_FAILURE; + } + tempDesc = (uint32_t)desc->pins; + if (!HdfSbufWriteUint32(data, tempDesc)) { + return HDF_FAILURE; + } + LOG_FUN_INFO(); + return HDF_SUCCESS; +} + +int32_t GetAudioProxyRenderFunc(struct AudioHwRender *hwRender) +{ + if (hwRender == NULL) { + return HDF_FAILURE; + } + hwRender->common.control.Start = AudioProxyRenderStart; + hwRender->common.control.Stop = AudioProxyRenderStop; + hwRender->common.control.Pause = AudioProxyRenderPause; + hwRender->common.control.Resume = AudioProxyRenderResume; + hwRender->common.control.Flush = AudioProxyRenderFlush; + 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.scene.CheckSceneCapability = AudioProxyRenderCheckSceneCapability; + hwRender->common.scene.SelectScene = AudioProxyRenderSelectScene; + hwRender->common.volume.SetMute = AudioProxyRenderSetMute; + hwRender->common.volume.GetMute = AudioProxyRenderGetMute; + hwRender->common.volume.SetVolume = AudioProxyRenderSetVolume; + hwRender->common.volume.GetVolume = AudioProxyRenderGetVolume; + hwRender->common.volume.GetGainThreshold = AudioProxyRenderGetGainThreshold; + hwRender->common.volume.GetGain = AudioProxyRenderGetGain; + hwRender->common.volume.SetGain = AudioProxyRenderSetGain; + hwRender->common.GetLatency = AudioProxyRenderGetLatency; + hwRender->common.RenderFrame = AudioProxyRenderRenderFrame; + hwRender->common.GetRenderPosition = AudioProxyRenderGetRenderPosition; + hwRender->common.SetRenderSpeed = AudioProxyRenderSetRenderSpeed; + hwRender->common.GetRenderSpeed = AudioProxyRenderGetRenderSpeed; + hwRender->common.SetChannelMode = AudioProxyRenderSetChannelMode; + hwRender->common.GetChannelMode = AudioProxyRenderGetChannelMode; + return HDF_SUCCESS; +} + +int32_t InitHwRenderParam(struct AudioHwRender *hwRender, const struct AudioDeviceDescriptor *desc, + const struct AudioSampleAttributes *attrs) +{ + if (hwRender == NULL || desc == NULL || attrs == NULL) { + LOG_FUN_ERR("InitHwRenderParam param Is NULL"); + return HDF_FAILURE; + } + hwRender->renderParam.renderMode.hwInfo.deviceDescript = *desc; + hwRender->renderParam.frameRenderMode.attrs = *attrs; + return HDF_SUCCESS; +} + +enum AudioFormat g_formatIdZero = AUDIO_FORMAT_PCM_16_BIT; +int32_t InitForGetPortCapability(struct AudioPort portIndex, struct AudioPortCapability *capabilityIndex) +{ + if (capabilityIndex == NULL) { + LOG_FUN_ERR("capabilityIndex Is NULL"); + return HDF_FAILURE; + } + /* get capabilityIndex from driver or default */ + if (portIndex.dir != PORT_OUT) { + capabilityIndex->hardwareMode = true; + capabilityIndex->channelMasks = AUDIO_CHANNEL_STEREO; + capabilityIndex->channelCount = CONFIG_CHANNEL_COUNT; + return HDF_SUCCESS; + } + if (portIndex.portId == 0) { + capabilityIndex->hardwareMode = true; + capabilityIndex->channelMasks = AUDIO_CHANNEL_STEREO; + capabilityIndex->channelCount = CONFIG_CHANNEL_COUNT; + capabilityIndex->deviceType = portIndex.dir; + capabilityIndex->deviceId = PIN_OUT_SPEAKER; + capabilityIndex->formatNum = 1; + capabilityIndex->formats = &g_formatIdZero; + capabilityIndex->sampleRateMasks = AUDIO_SAMPLE_RATE_MASK_16000; + capabilityIndex->subPortsNum = 1; + capabilityIndex->subPorts = (struct AudioSubPortCapability *)calloc(capabilityIndex->subPortsNum, + sizeof(struct AudioSubPortCapability)); + if (capabilityIndex->subPorts == NULL) { + LOG_FUN_ERR("capabilityIndex->subPorts is NULL!"); + return HDF_FAILURE; + } + capabilityIndex->subPorts->portId = portIndex.portId; + capabilityIndex->subPorts->desc = portIndex.portName; + capabilityIndex->subPorts->mask = PORT_PASSTHROUGH_LPCM; + return HDF_SUCCESS; + } + if (portIndex.portId == 1) { + capabilityIndex->hardwareMode = true; + capabilityIndex->channelMasks = AUDIO_CHANNEL_STEREO; + capabilityIndex->channelCount = CONFIG_CHANNEL_COUNT; + capabilityIndex->deviceType = portIndex.dir; + capabilityIndex->deviceId = PIN_OUT_HEADSET; + capabilityIndex->formatNum = 1; + capabilityIndex->formats = &g_formatIdZero; + capabilityIndex->sampleRateMasks = AUDIO_SAMPLE_RATE_MASK_16000 | AUDIO_SAMPLE_RATE_MASK_8000; + return HDF_SUCCESS; + } + if (portIndex.portId == HDMI_PORT_ID) { + return HdmiPortInit(portIndex, capabilityIndex); + } + return HDF_FAILURE; +} + +void AudioAdapterReleaseCapSubPorts(struct AudioPortAndCapability *portCapabilitys, const int32_t num) +{ + int32_t i = 0; + if (portCapabilitys == NULL) { + return; + } + while (i < num) { + if (&portCapabilitys[i] == NULL) { + break; + } + AudioMemFree((void **)(&portCapabilitys[i].capability.subPorts)); + i++; + } + return; +} + +int32_t AudioProxyAdapterInitAllPorts(struct AudioAdapter *adapter) +{ + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + const char *adapterName = NULL; + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + if (hwAdapter == NULL) { + LOG_FUN_ERR("hwAdapter Is NULL"); + return HDF_FAILURE; + } + /* Fake data */ + int32_t portNum = hwAdapter->adapterDescriptor.portNum; + struct AudioPort *ports = hwAdapter->adapterDescriptor.ports; + if (ports == NULL) { + LOG_FUN_ERR("ports is NULL!"); + return HDF_FAILURE; + } + struct AudioPortAndCapability *portCapability = (struct AudioPortAndCapability *)calloc(portNum, + sizeof(struct AudioPortAndCapability)); + if (portCapability == NULL) { + LOG_FUN_ERR("portCapability is NULL!"); + return HDF_FAILURE; + } + 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!"); + AudioAdapterReleaseCapSubPorts(portCapability, portNum); + AudioMemFree((void **)&portCapability); + return HDF_FAILURE; + } + } + hwAdapter->portCapabilitys = portCapability; + hwAdapter->portCapabilitys->mode = PORT_PASSTHROUGH_LPCM; + if (AudioProxyPreprocessSBuf(&data, &reply) < 0) { + return HDF_FAILURE; + } + adapterName = hwAdapter->adapterDescriptor.adapterName; + if (!HdfSbufWriteString(data, adapterName)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_ADT_INIT_PORTS, data, reply); + if (ret < 0) { + LOG_FUN_ERR("Get Failed AudioAdapter!"); + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + AudioProxyBufReplyRecycle(data, reply); + 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) { + return HDF_FAILURE; + } + struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); + if (hwRender == NULL) { + LOG_FUN_ERR("hwRender is NULL!"); + return HDF_FAILURE; + } + if (GetAudioProxyRenderFunc(hwRender) < 0) { + AudioMemFree((void **)&hwRender); + return HDF_FAILURE; + } + /* Fill hwRender para */ + if (InitHwRenderParam(hwRender, desc, attrs) < 0) { + AudioMemFree((void **)&hwRender); + return HDF_FAILURE; + } + if (AudioProxyPreprocessSBuf(&data, &reply) < 0) { + AudioMemFree((void **)&hwRender); + return HDF_FAILURE; + } + if (AudioProxyCommonInitCreateData(data, adapter, 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); + if (ret < 0) { + LOG_FUN_ERR("Send Server fail!"); + AudioProxyBufReplyRecycle(data, reply); + AudioMemFree((void **)&hwRender); + 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) { + AudioMemFree((void **)&hwRender); + return HDF_FAILURE; + } + *render = &hwRender->common; + return HDF_SUCCESS; +} + +int32_t AudioProxyAdapterDestroyRender(struct AudioAdapter *adapter, struct AudioRender *render) +{ + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + if (adapter == NULL || render == NULL) { + return HDF_FAILURE; + } + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + if (hwRender == NULL) { + return HDF_FAILURE; + } + if (AudioProxyPreprocessRender((AudioHandle)render, &data, &reply) < 0) { + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_RENDER_DESTROY, data, reply); + if (ret < 0) { + if (ret != HDF_ERR_INVALID_OBJECT) { + LOG_FUN_ERR("AudioRenderRenderFrame FAIL"); + } + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + AudioMemFree((void **)&hwRender->renderParam.frameRenderMode.buffer); + AudioMemFree((void **)&render); + AudioProxyBufReplyRecycle(data, reply); + return HDF_SUCCESS; +} + +int32_t GetAudioProxyCaptureFunc(struct AudioHwCapture *hwCapture) +{ + if (hwCapture == NULL) { + return HDF_FAILURE; + } + hwCapture->common.control.Start = AudioProxyCaptureStart; + hwCapture->common.control.Stop = AudioProxyCaptureStop; + hwCapture->common.control.Pause = AudioProxyCapturePause; + hwCapture->common.control.Resume = AudioProxyCaptureResume; + hwCapture->common.control.Flush = AudioProxyCaptureFlush; + 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.scene.CheckSceneCapability = AudioProxyCaptureCheckSceneCapability; + hwCapture->common.scene.SelectScene = AudioProxyCaptureSelectScene; + hwCapture->common.volume.SetMute = AudioProxyCaptureSetMute; + hwCapture->common.volume.GetMute = AudioProxyCaptureGetMute; + hwCapture->common.volume.SetVolume = AudioProxyCaptureSetVolume; + hwCapture->common.volume.GetVolume = AudioProxyCaptureGetVolume; + hwCapture->common.volume.GetGainThreshold = AudioProxyCaptureGetGainThreshold; + hwCapture->common.volume.GetGain = AudioProxyCaptureGetGain; + hwCapture->common.volume.SetGain = AudioProxyCaptureSetGain; + hwCapture->common.CaptureFrame = AudioProxyCaptureCaptureFrame; + hwCapture->common.GetCapturePosition = AudioProxyCaptureGetCapturePosition; + return HDF_SUCCESS; +} + +int32_t InitProxyHwCaptureParam(struct AudioHwCapture *hwCapture, const struct AudioDeviceDescriptor *desc, + const struct AudioSampleAttributes *attrs) +{ + if (NULL == hwCapture || NULL == desc || NULL == attrs) { + LOG_FUN_ERR("InitHwCaptureParam param Is NULL"); + return HDF_FAILURE; + } + hwCapture->captureParam.captureMode.hwInfo.deviceDescript = *desc; + hwCapture->captureParam.frameCaptureMode.attrs = *attrs; + 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) { + return HDF_FAILURE; + } + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)calloc(1, sizeof(struct AudioHwCapture)); + if (hwCapture == NULL) { + LOG_FUN_ERR("hwCapture is NULL!"); + return HDF_FAILURE; + } + if (GetAudioProxyCaptureFunc(hwCapture) < 0) { + AudioMemFree((void **)&hwCapture); + return HDF_FAILURE; + } + /* Fill hwRender para */ + if (InitProxyHwCaptureParam(hwCapture, desc, attrs) < 0) { + AudioMemFree((void **)&hwCapture); + return HDF_FAILURE; + } + if (AudioProxyPreprocessSBuf(&data, &reply) < 0) { + AudioMemFree((void **)&hwCapture); + return HDF_FAILURE; + } + if (AudioProxyCommonInitCreateData(data, adapter, 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); + if (ret < 0) { + LOG_FUN_ERR("Send Server fail!"); + AudioProxyBufReplyRecycle(data, reply); + AudioMemFree((void **)&hwCapture); + 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) { + AudioMemFree((void **)&hwCapture); + return HDF_FAILURE; + } + *capture = &hwCapture->common; + return HDF_SUCCESS; +} + +int32_t AudioProxyAdapterDestroyCapture(struct AudioAdapter *adapter, struct AudioCapture *capture) +{ + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + if (adapter == NULL || capture == NULL) { + return HDF_FAILURE; + } + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + if (hwCapture == NULL) { + return HDF_FAILURE; + } + if (AudioProxyPreprocessCapture((AudioHandle)capture, &data, &reply) < 0) { + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_CAPTURE_DESTROY, data, reply); + if (ret < 0) { + LOG_FUN_ERR("Send Server fail!"); + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + AudioMemFree((void **)&hwCapture->captureParam.frameCaptureMode.buffer); + AudioMemFree((void **)&capture); + AudioProxyBufReplyRecycle(data, reply); + return HDF_SUCCESS; +} +int32_t AudioProxyAdapterWritePortCapability(struct AudioHwAdapter *hwAdapter, + const struct AudioPort *port, struct HdfSBuf *data) +{ + if (hwAdapter == NULL || port == NULL || data == NULL) { + return HDF_FAILURE; + } + const char *adapterName = hwAdapter->adapterDescriptor.adapterName; + if (!HdfSbufWriteString(data, adapterName)) { + return HDF_FAILURE; + } + uint32_t tempDir = (uint32_t)port->dir; + if (!HdfSbufWriteUint32(data, tempDir)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, port->portId)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(data, port->portName)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioProxyAdapterGetPortCapability(struct AudioAdapter *adapter, + const struct AudioPort *port, struct AudioPortCapability *capability) +{ + LOG_FUN_INFO(); + if (adapter == NULL || port == NULL || port->portName == NULL || capability == NULL) { + return HDF_FAILURE; + } + if (port->portId < 0) { + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + if (AudioProxyPreprocessSBuf(&data, &reply) < 0) { + return HDF_FAILURE; + } + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + if (hwAdapter == NULL) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + if (AudioProxyAdapterWritePortCapability(hwAdapter, port, data)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_ADT_GET_PORT_CAPABILITY, data, reply); + if (ret < 0) { + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + LOG_FUN_INFO(); + AudioProxyBufReplyRecycle(data, reply); + /* proxy must init local capability ,this capability the same of Server's */ + struct AudioPortAndCapability *hwAdapterPortCapabilitys = hwAdapter->portCapabilitys; + if (hwAdapterPortCapabilitys == NULL) { + LOG_FUN_ERR("hwAdapter portCapabilitys is NULL!"); + return HDF_FAILURE; + } + int32_t portNum = hwAdapter->adapterDescriptor.portNum; + while (hwAdapterPortCapabilitys != NULL && portNum) { + if (hwAdapterPortCapabilitys->port.portId == port->portId) { + *capability = hwAdapterPortCapabilitys->capability; + return HDF_SUCCESS; + } + hwAdapterPortCapabilitys++; + portNum--; + } + return HDF_FAILURE; +} + +int32_t AudioProxyAdapterSetAndGetPassthroughModeSBuf(struct HdfSBuf *data, + struct HdfSBuf *reply, const struct AudioPort *port) +{ + if (data == NULL || port == NULL) { + return HDF_FAILURE; + } + uint32_t tempDir = port->dir; + if (!HdfSbufWriteUint32(data, tempDir)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, port->portId)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(data, port->portName)) { + LOG_FUN_ERR("HdfSbufWriteString error"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioProxyAdapterSetPassthroughMode(struct AudioAdapter *adapter, + const struct AudioPort *port, enum AudioPortPassthroughMode mode) +{ + LOG_FUN_INFO(); + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + if (adapter == NULL || port == NULL || port->portName == NULL) { + return HDF_FAILURE; + } + if (port->dir != PORT_OUT || port->portId < 0 || strcmp(port->portName, "AOP") != 0) { + return HDF_FAILURE; + } + if (AudioProxyPreprocessSBuf(&data, &reply) < 0) { + return HDF_FAILURE; + } + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + if (hwAdapter == NULL) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + const char *adapterName = hwAdapter->adapterDescriptor.adapterName; + if (!HdfSbufWriteString(data, adapterName)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + if (AudioProxyAdapterSetAndGetPassthroughModeSBuf(data, reply, port) < 0) { + LOG_FUN_ERR("Failed to obtain data"); + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + uint32_t tempMode = (uint32_t)mode; + if (!HdfSbufWriteUint32(data, tempMode)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_ADT_SET_PASS_MODE, data, reply); + if (ret < 0) { + AudioProxyBufReplyRecycle(data, reply); + LOG_FUN_ERR("Failed to send server"); + return ret; + } + AudioProxyBufReplyRecycle(data, reply); + return HDF_SUCCESS; +} + +int32_t AudioProxyAdapterGetPassthroughMode(struct AudioAdapter *adapter, + const struct AudioPort *port, enum AudioPortPassthroughMode *mode) +{ + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + if (adapter == NULL || port == NULL || port->portName == NULL || mode == NULL) { + return HDF_FAILURE; + } + if (port->dir != PORT_OUT || port->portId < 0 || strcmp(port->portName, "AOP") != 0) { + return HDF_FAILURE; + } + if (AudioProxyPreprocessSBuf(&data, &reply) < 0) { + return HDF_FAILURE; + } + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + if (hwAdapter == NULL) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + const char *adapterName = hwAdapter->adapterDescriptor.adapterName; + if (!HdfSbufWriteString(data, adapterName)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + if (AudioProxyAdapterSetAndGetPassthroughModeSBuf(data, reply, port) < 0) { + LOG_FUN_ERR("Failed to obtain data"); + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_ADT_GET_PASS_MODE, data, reply); + if (ret < 0) { + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + uint32_t tempMode = 0; + if (!HdfSbufReadUint32(reply, &tempMode)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + *mode = (enum AudioPortPassthroughMode)tempMode; + AudioProxyBufReplyRecycle(data, reply); + return HDF_SUCCESS; +} + diff --git a/audio/hal/hdi_binder/proxy/src/audio_proxy_capture.c b/audio/hal/hdi_binder/proxy/src/audio_proxy_capture.c new file mode 100755 index 0000000000000000000000000000000000000000..0072230a3e113480897ff4c98854edb714d7da97 --- /dev/null +++ b/audio/hal/hdi_binder/proxy/src/audio_proxy_capture.c @@ -0,0 +1,393 @@ +/* + * 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_proxy_common.h" + +static int32_t AudioProxyCaptureCtrl(int cmId, AudioHandle handle) +{ + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + if (AudioProxyPreprocessCapture(handle, &data, &reply) < 0) { + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(cmId, data, reply); + AudioProxyBufReplyRecycle(data, reply); + return ret; +} + +int32_t AudioProxyCaptureStart(AudioHandle handle) +{ + LOG_FUN_INFO(); + return AudioProxyCaptureCtrl(AUDIO_HDI_CAPTURE_START, handle); +} + +int32_t AudioProxyCaptureStop(AudioHandle handle) +{ + LOG_FUN_INFO(); + return AudioProxyCaptureCtrl(AUDIO_HDI_CAPTURE_STOP, handle); +} + +int32_t AudioProxyCapturePause(AudioHandle handle) +{ + LOG_FUN_INFO(); + return AudioProxyCaptureCtrl(AUDIO_HDI_CAPTURE_PAUSE, handle); +} + +int32_t AudioProxyCaptureResume(AudioHandle handle) +{ + LOG_FUN_INFO(); + return AudioProxyCaptureCtrl(AUDIO_HDI_CAPTURE_RESUME, handle); +} + +int32_t AudioProxyCaptureFlush(AudioHandle handle) +{ + LOG_FUN_INFO(); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL) { + return HDF_FAILURE; + } + return HDF_ERR_NOT_SUPPORT; +} + +int32_t AudioProxyCaptureGetFrameParameter(int cmId, AudioHandle handle, uint64_t *param) +{ + if (param == NULL) { + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + if (AudioProxyPreprocessCapture(handle, &data, &reply) < 0) { + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(cmId, data, reply); + if (ret < 0) { + LOG_FUN_ERR("AudioCaptureGetFrameSize FAIL"); + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + if (!HdfSbufReadUint64(reply, param)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + AudioProxyBufReplyRecycle(data, reply); + return ret; +} + +int32_t AudioProxyCaptureGetFrameSize(AudioHandle handle, uint64_t *size) +{ + return AudioProxyCaptureGetFrameParameter(AUDIO_HDI_CAPTURE_GET_FRAME_SIZE, handle, size); +} + +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) +{ + if (handle == NULL || attrs == NULL) { + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + if (AudioProxyPreprocessCapture(handle, &data, &reply) < 0) { + 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); + AudioProxyBufReplyRecycle(data, reply); + return ret; +} + +int32_t AudioProxyCaptureGetSampleAttributes(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) { + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_CAPTURE_GET_SAMPLE_ATTR, data, reply); + if (ret < 0) { + LOG_FUN_ERR("AudioCaptureGetSampleAttributes FAIL"); + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + if (AudioProxyReadSapmleAttrbutes(reply, attrs)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + AudioProxyBufReplyRecycle(data, reply); + return HDF_SUCCESS; +} + +int32_t AudioProxyCaptureGetCurrentChannelId(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) { + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_CAPTURE_GET_CUR_CHANNEL_ID, data, reply); + if (ret < 0) { + LOG_FUN_ERR("AudioCaptureGetFrameSize FAIL"); + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + if (!HdfSbufReadUint32(reply, channelId)) { + LOG_FUN_ERR("Read reply FAIL"); + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + AudioProxyBufReplyRecycle(data, reply); + return HDF_SUCCESS; +} + +int32_t AudioProxyCaptureCheckSceneCapability(AudioHandle handle, + const struct AudioSceneDescriptor *scene, bool *supported) +{ + if (scene == NULL || supported == NULL) { + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + if (AudioProxyPreprocessCapture(handle, &data, &reply) < 0) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, scene->scene.id)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + uint32_t tempPins = scene->desc.pins; + if (!HdfSbufWriteUint32(data, tempPins)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_CAPTURE_CHECK_SCENE_CAPABILITY, data, reply); + if (ret < 0) { + LOG_FUN_ERR("AudioProxyCaptureCheckSceneCapability FAIL"); + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + uint32_t tempSupported = 0; + if (!HdfSbufReadUint32(reply, &tempSupported)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + *supported = (bool)tempSupported; + AudioProxyBufReplyRecycle(data, reply); + return HDF_SUCCESS; +} + +int32_t AudioProxyCaptureSelectScene(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) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, (enum AudioCategory)scene->scene.id)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + uint32_t tempPins = scene->desc.pins; + if (!HdfSbufWriteUint32(data, tempPins)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_CAPTURE_SELECT_SCENE, data, reply); + AudioProxyBufReplyRecycle(data, reply); + return ret; +} + +int32_t AudioProxyCaptureSetMute(AudioHandle handle, bool mute) +{ + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + if (AudioProxyPreprocessCapture(handle, &data, &reply) < 0) { + return HDF_FAILURE; + } + uint32_t tempMute = (uint32_t)mute; + if (!HdfSbufWriteUint32(data, tempMute)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_CAPTURE_SET_MUTE, data, reply); + AudioProxyBufReplyRecycle(data, reply); + return ret; +} + +int32_t AudioProxyCaptureGetMute(AudioHandle handle, bool *mute) +{ + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + if (mute == NULL) { + return HDF_FAILURE; + } + if (AudioProxyPreprocessCapture(handle, &data, &reply) < 0) { + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_CAPTURE_GET_MUTE, data, reply); + if (ret < 0) { + LOG_FUN_ERR("AudioCaptureGetMute FAIL"); + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + uint32_t tempMute = 0; + if (!HdfSbufReadUint32(reply, &tempMute)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + *mute = (bool)tempMute; + AudioProxyBufReplyRecycle(data, reply); + return HDF_SUCCESS; +} + +int32_t AudioProxyCaptureSetVolume(AudioHandle handle, float volume) +{ + return AudioProxyCommonSetCtrlParam(AUDIO_HDI_CAPTURE_SET_VOLUME, handle, volume); +} + +int32_t AudioProxyCaptureGetVolume(AudioHandle handle, float *volume) +{ + return AudioProxyCommonGetCtrlParam(AUDIO_HDI_CAPTURE_GET_VOLUME, handle, volume); +} + +int32_t AudioProxyCaptureGetGainThreshold(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) { + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_CAPTURE_GET_GAIN_THRESHOLD, data, reply); + if (ret < 0) { + LOG_FUN_ERR("AudioCaptureGetGainThreshold FAIL"); + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + uint32_t temp; + if (!HdfSbufReadUint32(reply, &temp)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + *min = temp; + if (!HdfSbufReadUint32(reply, &temp)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + *max = temp; + AudioProxyBufReplyRecycle(data, reply); + return HDF_SUCCESS; +} + +int32_t AudioProxyCaptureGetGain(AudioHandle handle, float *gain) +{ + return AudioProxyCommonGetCtrlParam(AUDIO_HDI_CAPTURE_GET_GAIN, handle, gain); +} + +int32_t AudioProxyCaptureSetGain(AudioHandle handle, float gain) +{ + return AudioProxyCommonSetCtrlParam(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; + 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) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint64(data, requestBytes)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_CAPTURE_CAPTURE_FRAME, data, reply); + if (ret < 0) { + if (ret != HDF_ERR_INVALID_OBJECT) { + LOG_FUN_ERR("AudioCaptureCaptureFrame FAIL"); + } + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + if (!HdfSbufReadBuffer(reply, (const void **)&buffer, &length)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + if ((uint64_t)length > requestBytes) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + memcpy_s(frame, requestBytes, buffer, length); + if (!HdfSbufReadUint64(reply, replyBytes)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + AudioProxyBufReplyRecycle(data, reply); + return HDF_SUCCESS; +} + +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) { + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(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)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + if (!HdfSbufReadInt64(reply, &time->tvSec)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + if (!HdfSbufReadInt64(reply, &time->tvNSec)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + AudioProxyBufReplyRecycle(data, reply); + return HDF_SUCCESS; +} diff --git a/audio/hal/hdi_binder/proxy/src/audio_proxy_common.c b/audio/hal/hdi_binder/proxy/src/audio_proxy_common.c new file mode 100755 index 0000000000000000000000000000000000000000..f3fb9bfb01b902bb0486570e98f983e6f7a98702 --- /dev/null +++ b/audio/hal/hdi_binder/proxy/src/audio_proxy_common.c @@ -0,0 +1,334 @@ +/* + * 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_proxy_common.h" +#include "audio_proxy_manager.h" + +#define AUDIO_HDF_SBUF_IPC 1 +#define PROXY_VOLUME_CHANGE 100 + +struct HDIAudioManager *g_serviceObj; + + +struct HdfSBuf *AudioProxyObtainHdfSBuf() +{ + enum HdfSbufType bufType; +#ifdef AUDIO_HDF_SBUF_IPC + bufType = SBUF_IPC; +#else + bufType = SBUF_RAW; +#endif + 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) { + 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) +{ + if (data == NULL || reply == NULL || g_serviceObj == NULL) { + return HDF_FAILURE; + } + if (g_serviceObj->remote == NULL || g_serviceObj->remote->dispatcher == NULL || + g_serviceObj->remote->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); +} + +void AudioProxyBufReplyRecycle(struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (data != NULL) { + HdfSBufRecycle(data); + } + if (reply != NULL) { + HdfSBufRecycle(reply); + } + return; +} + +int32_t AudioProxyPreprocessSBuf(struct HdfSBuf **data, struct HdfSBuf **reply) +{ + if (data == NULL || reply == NULL) { + return HDF_FAILURE; + } + *data = AudioProxyObtainHdfSBuf(); + if (*data == NULL) { + LOG_FUN_ERR("Failed to obtain data"); + return HDF_FAILURE; + } + *reply = AudioProxyObtainHdfSBuf(); + if (*reply == NULL) { + LOG_FUN_ERR("Failed to obtain reply"); + HdfSBufRecycle(*data); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioProxyPreprocessRender(AudioHandle render, struct HdfSBuf **data, struct HdfSBuf **reply) +{ + if (data == NULL || reply == NULL) { + return HDF_FAILURE; + } + const char *adapterName; + uint32_t renderPid = getpid(); + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + if (hwRender == NULL) { + return HDF_FAILURE; + } + adapterName = hwRender->renderParam.renderMode.hwInfo.adapterName; + if (AudioProxyPreprocessSBuf(data, reply) < 0) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(*data, adapterName)) { + AudioProxyBufReplyRecycle(*data, *reply); + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(*data, renderPid)) { + AudioProxyBufReplyRecycle(*data, *reply); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioProxyPreprocessCapture(AudioHandle capture, struct HdfSBuf **data, struct HdfSBuf **reply) +{ + if (data == NULL || reply == NULL) { + return HDF_FAILURE; + } + const char *adapterName; + uint32_t capturePid = getpid(); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + if (hwCapture == NULL) { + return HDF_FAILURE; + } + adapterName = hwCapture->captureParam.captureMode.hwInfo.adapterName; + if (AudioProxyPreprocessSBuf(data, reply) < 0) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(*data, adapterName)) { + AudioProxyBufReplyRecycle(*data, *reply); + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(*data, capturePid)) { + AudioProxyBufReplyRecycle(*data, *reply); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioProxyWriteSampleAttributes(struct HdfSBuf *data, const struct AudioSampleAttributes *attrs) +{ + if (data == NULL || attrs == NULL) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, (uint32_t)attrs->type)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, (uint32_t)attrs->interleaved)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, (uint32_t)attrs->format)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, attrs->sampleRate)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, attrs->channelCount)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, attrs->period)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, attrs->frameSize)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, (uint32_t)(attrs->isBigEndian))) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, (uint32_t)(attrs->isSignedData))) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, attrs->startThreshold)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, attrs->stopThreshold)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, attrs->silenceThreshold)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioProxyReadSapmleAttrbutes(struct HdfSBuf *reply, struct AudioSampleAttributes *attrs) +{ + if (reply == NULL || attrs == NULL) { + return HDF_FAILURE; + } + uint32_t tempType = 0; + if (!HdfSbufReadUint32(reply, &tempType)) { + return HDF_FAILURE; + } + attrs->type = (enum AudioCategory)tempType; + uint32_t tempInterleaved = 0; + if (!HdfSbufReadUint32(reply, &tempInterleaved)) { + return HDF_FAILURE; + } + attrs->interleaved = (bool)tempInterleaved; + uint32_t tempFormat = 0; + if (!HdfSbufReadUint32(reply, &tempFormat)) { + return HDF_FAILURE; + } + attrs->format = (enum AudioFormat)tempFormat; + if (!HdfSbufReadUint32(reply, &attrs->sampleRate)) { + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(reply, &attrs->channelCount)) { + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(reply, &attrs->period)) { + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(reply, &attrs->frameSize)) { + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(reply, &tempInterleaved)) { + return HDF_FAILURE; + } + attrs->isBigEndian = (bool)tempInterleaved; + if (!HdfSbufReadUint32(reply, &tempInterleaved)) { + return HDF_FAILURE; + } + attrs->isSignedData = (bool)tempInterleaved; + if (!HdfSbufReadUint32(reply, &attrs->startThreshold)) { + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(reply, &attrs->stopThreshold)) { + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(reply, &attrs->silenceThreshold)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioProxyCommonSetCtrlParam(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) { + 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 (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; + } + } + uint32_t tempParam = (uint32_t)param; + if (!HdfSbufWriteUint32(data, tempParam)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(cmId, data, reply); + AudioProxyBufReplyRecycle(data, reply); + return ret; +} + +int32_t AudioProxyCommonGetCtrlParam(int cmId, AudioHandle handle, float *param) +{ + LOG_FUN_INFO(); + if (param == NULL) { + return HDF_FAILURE; + } + 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; + } + } + int32_t ret = AudioProxyDispatchCall(cmId, data, reply); + if (ret < 0) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + uint32_t tempParam; + if (!HdfSbufReadUint32(reply, &tempParam)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + if (cmId == AUDIO_HDI_RENDER_GET_VOLUME || cmId == AUDIO_HDI_CAPTURE_GET_VOLUME) { + *param = (float)tempParam / PROXY_VOLUME_CHANGE; + } else { + *param = (float)tempParam; + } + AudioProxyBufReplyRecycle(data, reply); + 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 new file mode 100755 index 0000000000000000000000000000000000000000..5c498b561b0f36761bb73701a59391c949cabe23 --- /dev/null +++ b/audio/hal/hdi_binder/proxy/src/audio_proxy_manager.c @@ -0,0 +1,151 @@ +/* + * 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_proxy_manager.h" +#include "audio_adapter_info_common.h" +#include "audio_proxy_common.h" +#include "audio_proxy_internal.h" + +#define HDI_SERVER_NAME "audio_hdi_service" +#define CONFIG_FRAME_SIZE (1024 * 2 * 1) +#define FRAME_SIZE 1024 +#define CONFIG_FRAME_COUNT ((8000 * 2 * 1 + (CONFIG_FRAME_SIZE - 1)) / CONFIG_FRAME_SIZE) + +int32_t AudioProxyManagerGetAllAdapters(struct AudioManager *manager, + struct AudioAdapterDescriptor **descs, + int *size) +{ + LOG_FUN_INFO(); + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + int32_t ret; + if (manager == NULL || descs == NULL || size == NULL) { + return HDF_FAILURE; + } + if (AudioProxyPreprocessSBuf(&data, &reply) < 0) { + return HDF_FAILURE; + } + ret = AudioAdaptersForUser(descs, size); + if (ret < 0) { + AudioProxyBufReplyRecycle(data, reply); + LOG_FUN_ERR("AudioAdaptersForUser FAIL!"); + return ret; + } + ret = AudioProxyDispatchCall(AUDIO_HDI_MGR_GET_ALL_ADAPTER, data, reply); + if (ret != HDF_SUCCESS) { + AudioProxyBufReplyRecycle(data, reply); + LOG_FUN_ERR("Failed to send service call!"); + return ret; + } + AudioProxyBufReplyRecycle(data, reply); + return HDF_SUCCESS; +} + +int32_t AudioProxyManagerLoadAdapter(struct AudioManager *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) { + return HDF_FAILURE; + } + if (AudioAdapterExist(desc->adapterName)) { + return HDF_FAILURE; + } + if (AudioProxyPreprocessSBuf(&data, &reply) < 0) { + return HDF_FAILURE; + } + // adapterName + if (!HdfSbufWriteString(data, desc->adapterName)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + // dir + uint32_t tempDir = (uint32_t)desc->ports->dir; + if (!HdfSbufWriteUint32(data, tempDir)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)calloc(1, sizeof(struct AudioHwAdapter)); + if (hwAdapter == NULL) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + int32_t ret; + ret = AudioProxyDispatchCall(AUDIO_HDI_MGR_LOAD_ADAPTER, data, reply); + if (ret < 0) { + LOG_FUN_ERR("Failed to send service call!!"); + AudioProxyBufReplyRecycle(data, reply); + AudioMemFree((void **)&hwAdapter); + return ret; + } + /* check return result from server first */ + hwAdapter->common.InitAllPorts = AudioProxyAdapterInitAllPorts; + hwAdapter->common.CreateRender = AudioProxyAdapterCreateRender; + hwAdapter->common.DestroyRender = AudioProxyAdapterDestroyRender; + hwAdapter->common.CreateCapture = AudioProxyAdapterCreateCapture; + hwAdapter->common.DestroyCapture = AudioProxyAdapterDestroyCapture; + hwAdapter->common.GetPortCapability = AudioProxyAdapterGetPortCapability; + hwAdapter->common.SetPassthroughMode = AudioProxyAdapterSetPassthroughMode; + hwAdapter->common.GetPassthroughMode = AudioProxyAdapterGetPassthroughMode; + hwAdapter->adapterDescriptor = *desc; + *adapter = &hwAdapter->common; + AudioProxyBufReplyRecycle(data, reply); + LOG_FUN_INFO(); + return HDF_SUCCESS; +} + +void AudioProxyManagerUnloadAdapter(struct AudioManager *manager, struct AudioAdapter *adapter) +{ + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + const char *adapterName = NULL; + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + if (manager == NULL || adapter == NULL) { + return; + } + if (hwAdapter->portCapabilitys != NULL) { + int32_t portNum = hwAdapter->adapterDescriptor.portNum; + int32_t i = 0; + while (i < portNum) { + if (&hwAdapter->portCapabilitys[i] != NULL) { + AudioMemFree((void **)&hwAdapter->portCapabilitys[i].capability.subPorts); + } + i++; + } + AudioMemFree((void **)&hwAdapter->portCapabilitys); + } + 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); + if (ret < 0) { + LOG_FUN_ERR("Send Server fail!"); + } + } + AudioProxyBufReplyRecycle(data, reply); + } + AudioMemFree((void **)&adapter); + return; +} + +struct AudioManager *GetAudioProxyManagerFuncs(void) +{ + LOG_FUN_INFO(); + return HdfProxyIoBindServiceName(HDI_SERVER_NAME); +} + diff --git a/audio/hal/hdi_binder/proxy/src/audio_proxy_render.c b/audio/hal/hdi_binder/proxy/src/audio_proxy_render.c new file mode 100755 index 0000000000000000000000000000000000000000..1ef0a3032ffe43066bfdc3474fdae22871565283 --- /dev/null +++ b/audio/hal/hdi_binder/proxy/src/audio_proxy_render.c @@ -0,0 +1,462 @@ +/* + * 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_proxy_common.h" + +int32_t AudioProxyRenderCtrl(int cmId, AudioHandle handle) +{ + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + if (AudioProxyPreprocessRender(handle, &data, &reply) < 0) { + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(cmId, data, reply); + AudioProxyBufReplyRecycle(data, reply); + return ret; +} + +int32_t AudioProxyRenderStart(AudioHandle handle) +{ + LOG_FUN_INFO(); + return AudioProxyRenderCtrl(AUDIO_HDI_RENDER_START, handle); +} + +int32_t AudioProxyRenderStop(AudioHandle handle) +{ + LOG_FUN_INFO(); + return AudioProxyRenderCtrl(AUDIO_HDI_RENDER_STOP, handle); +} + +int32_t AudioProxyRenderPause(AudioHandle handle) +{ + LOG_FUN_INFO(); + return AudioProxyRenderCtrl(AUDIO_HDI_RENDER_PAUSE, handle); +} + +int32_t AudioProxyRenderResume(AudioHandle handle) +{ + LOG_FUN_INFO(); + return AudioProxyRenderCtrl(AUDIO_HDI_RENDER_RESUME, handle); +} + +int32_t AudioProxyRenderFlush(AudioHandle handle) +{ + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL) { + return HDF_FAILURE; + } + return HDF_ERR_NOT_SUPPORT; +} + +int32_t AudioProxyRenderGetFrameParameter(int cmId, AudioHandle handle, uint64_t *param) +{ + if (param == NULL) { + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + if (AudioProxyPreprocessRender(handle, &data, &reply) < 0) { + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(cmId, data, reply); + if (ret < 0) { + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + if (!HdfSbufReadUint64(reply, param)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + AudioProxyBufReplyRecycle(data, reply); + return HDF_SUCCESS; +} + +int32_t AudioProxyRenderGetFrameSize(AudioHandle handle, uint64_t *size) +{ + return AudioProxyRenderGetFrameParameter(AUDIO_HDI_RENDER_GET_FRAME_SIZE, handle, size); +} + +int32_t AudioProxyRenderGetFrameCount(AudioHandle handle, uint64_t *count) +{ + return AudioProxyRenderGetFrameParameter(AUDIO_HDI_RENDER_GET_FRAME_COUNT, handle, count); +} + +int32_t AudioProxyRenderSetSampleAttributes(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) { + 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); + AudioProxyBufReplyRecycle(data, reply); + return ret; +} + +int32_t AudioProxyRenderGetSampleAttributes(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) { + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_RENDER_GET_SAMPLE_ATTR, data, reply); + if (ret < 0) { + LOG_FUN_ERR("AudioRenderGetSampleAttributes FAIL"); + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + if (AudioProxyReadSapmleAttrbutes(reply, attrs)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + AudioProxyBufReplyRecycle(data, reply); + return HDF_SUCCESS; +} + +int32_t AudioProxyRenderGetCurrentChannelId(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) { + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_RENDER_GET_CUR_CHANNEL_ID, data, reply); + if (ret < 0) { + LOG_FUN_ERR("AudioRenderGetCurrentChannelId FAIL"); + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + if (!HdfSbufReadUint32(reply, channelId)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + AudioProxyBufReplyRecycle(data, reply); + return HDF_SUCCESS; +} + +int32_t AudioProxyRenderCheckSceneCapability(AudioHandle handle, + const struct AudioSceneDescriptor *scene, bool *supported) +{ + if (scene == NULL || supported == NULL) { + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + if (AudioProxyPreprocessRender(handle, &data, &reply) < 0) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, scene->scene.id)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + uint32_t tempPins = scene->desc.pins; + if (!HdfSbufWriteUint32(data, tempPins)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_RENDER_CHECK_SCENE_CAPABILITY, data, reply); + if (ret < 0) { + LOG_FUN_ERR("AudioRenderCheckSceneCapability FAIL"); + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + uint32_t tempSupported = 0; + if (!HdfSbufReadUint32(reply, &tempSupported)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + *supported = (bool)tempSupported; + AudioProxyBufReplyRecycle(data, reply); + return HDF_SUCCESS; +} + +int32_t AudioProxyRenderSelectScene(AudioHandle handle, const struct AudioSceneDescriptor *scene) +{ + if (scene == NULL) { + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + if (AudioProxyPreprocessRender(handle, &data, &reply) < 0) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(data, scene->scene.id)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + uint32_t tempPins = scene->desc.pins; + if (!HdfSbufWriteUint32(data, tempPins)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_RENDER_SELECT_SCENE, data, reply); + AudioProxyBufReplyRecycle(data, reply); + return ret; +} + +int32_t AudioProxyRenderSetMute(AudioHandle handle, bool mute) +{ + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + if (AudioProxyPreprocessRender(handle, &data, &reply) < 0) { + return HDF_FAILURE; + } + uint32_t tempMute = (uint32_t)mute; + if (!HdfSbufWriteUint32(data, tempMute)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_RENDER_SET_MUTE, data, reply); + AudioProxyBufReplyRecycle(data, reply); + return ret; +} + +int32_t AudioProxyRenderGetMute(AudioHandle handle, bool *mute) +{ + if (mute == NULL) { + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + if (AudioProxyPreprocessRender(handle, &data, &reply) < 0) { + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_RENDER_GET_MUTE, data, reply); + uint32_t tempMute; + if (!HdfSbufReadUint32(reply, &tempMute)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + *mute = (bool)tempMute; + AudioProxyBufReplyRecycle(data, reply); + LOG_PARA_INFO("GetMute SUCCESS!"); + return ret; +} + + +int32_t AudioProxyRenderSetVolume(AudioHandle handle, float volume) +{ + LOG_FUN_INFO(); + return AudioProxyCommonSetCtrlParam(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); +} + +int32_t AudioProxyRenderGetGainThreshold(AudioHandle handle, float *min, float *max) +{ + if (NULL == min || NULL == max) { + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + if (AudioProxyPreprocessRender(handle, &data, &reply) < 0) { + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(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; + if (!HdfSbufReadUint32(reply, &tempMin)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(reply, &tempMax)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + *min = (float)tempMin; + *max = (float)tempMax; + AudioProxyBufReplyRecycle(data, reply); + return HDF_SUCCESS; +} + +int32_t AudioProxyRenderGetGain(AudioHandle handle, float *gain) +{ + return AudioProxyCommonGetCtrlParam(AUDIO_HDI_RENDER_GET_GAIN, handle, gain); +} + +int32_t AudioProxyRenderSetGain(AudioHandle handle, float gain) +{ + return AudioProxyCommonSetCtrlParam(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) { + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_RENDER_GET_LATENCY, data, reply); + if (ret < 0) { + LOG_FUN_ERR("AudioRenderGetLatency FAIL"); + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + if (!HdfSbufReadUint32(reply, ms)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + AudioProxyBufReplyRecycle(data, reply); + return HDF_SUCCESS; +} + +int32_t AudioProxyRenderRenderFrame(struct AudioRender *render, const void *frame, + uint64_t requestBytes, uint64_t *replyBytes) +{ + if (frame == NULL || replyBytes == NULL) { + LOG_FUN_ERR("Render Frame Paras is NULL!"); + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + if (AudioProxyPreprocessRender((AudioHandle)render, &data, &reply) < 0) { + LOG_FUN_ERR("AudioProxyPreprocessRender FAIL"); + return HDF_FAILURE; + } + if (!HdfSbufWriteBuffer(data, frame, (uint32_t)requestBytes)) { + AudioProxyBufReplyRecycle(data, reply); + LOG_FUN_ERR("HdfSbufWriteBuffer FAIL"); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_RENDER_RENDER_FRAME, data, reply); + if (ret < 0) { + if (ret != HDF_ERR_INVALID_OBJECT) { + LOG_FUN_ERR("AudioRenderRenderFrame FAIL"); + } + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + *replyBytes = requestBytes; + AudioProxyBufReplyRecycle(data, reply); + return HDF_SUCCESS; +} + +int32_t AudioProxyRenderGetRenderPosition(struct AudioRender *render, uint64_t *frames, struct AudioTimeStamp *time) +{ + if (frames == NULL || time == NULL) { + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + if (AudioProxyPreprocessRender((AudioHandle)render, &data, &reply) < 0) { + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(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)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + AudioProxyBufReplyRecycle(data, reply); + return HDF_SUCCESS; +} + +int32_t AudioProxyRenderSetRenderSpeed(struct AudioRender *render, float speed) +{ + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + if (hwRender == NULL) { + return HDF_FAILURE; + } + return HDF_ERR_NOT_SUPPORT; +} + +int32_t AudioProxyRenderGetRenderSpeed(struct AudioRender *render, float *speed) +{ + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + if (hwRender == NULL || speed == NULL) { + return HDF_FAILURE; + } + return HDF_ERR_NOT_SUPPORT; +} + +int32_t AudioProxyRenderSetChannelMode(struct AudioRender *render, enum AudioChannelMode mode) +{ + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + if (AudioProxyPreprocessRender((AudioHandle)render, &data, &reply) < 0) { + return HDF_FAILURE; + } + uint32_t tempMode = (uint32_t)mode; + if (!HdfSbufWriteUint32(data, tempMode)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_RENDER_SET_CHANNEL_MODE, data, reply); + AudioProxyBufReplyRecycle(data, reply); + return ret; +} + +int32_t AudioProxyRenderGetChannelMode(struct AudioRender *render, enum AudioChannelMode *mode) +{ + if (mode == NULL || render == NULL) { + return HDF_FAILURE; + } + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + if (AudioProxyPreprocessRender((AudioHandle)render, &data, &reply) < 0) { + LOG_FUN_ERR("AudioProxyRenderGetChannelMode FAIL"); + return HDF_FAILURE; + } + int32_t ret = AudioProxyDispatchCall(AUDIO_HDI_RENDER_GET_CHANNEL_MODE, data, reply); + if (ret < 0) { + LOG_FUN_ERR("AudioRenderGetChannelMode FAIL"); + AudioProxyBufReplyRecycle(data, reply); + return ret; + } + uint32_t tempMode = 0; + if (!HdfSbufReadUint32(reply, &tempMode)) { + AudioProxyBufReplyRecycle(data, reply); + return HDF_FAILURE; + } + *mode = (enum AudioChannelMode)tempMode; + AudioProxyBufReplyRecycle(data, reply); + return HDF_SUCCESS; +} + diff --git a/audio/hal/hdi_binder/server/include/hdf_audio_server.h b/audio/hal/hdi_binder/server/include/hdf_audio_server.h new file mode 100755 index 0000000000000000000000000000000000000000..277acf62f1605dc105ede7705d853f53704c6ddd --- /dev/null +++ b/audio/hal/hdi_binder/server/include/hdf_audio_server.h @@ -0,0 +1,102 @@ +/* + * 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 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*************/ + AUDIO_HDI_MGR_GET_FUNCS = 0, + AUDIO_HDI_MGR_GET_ALL_ADAPTER, + AUDIO_HDI_MGR_LOAD_ADAPTER, + AUDIO_HDI_MGR_UNLOAD_ADAPTER, + + AUDIO_HDI_ADT_INIT_PORTS, + AUDIO_HDI_ADT_GET_PORT_CAPABILITY, + AUDIO_HDI_ADT_SET_PASS_MODE, + AUDIO_HDI_ADT_GET_PASS_MODE, + /***********render***************/ + AUDIO_HDI_RENDER_CREATE_RENDER, + AUDIO_HDI_RENDER_DESTROY, + AUDIO_HDI_RENDER_START, + AUDIO_HDI_RENDER_STOP, + AUDIO_HDI_RENDER_PAUSE, + AUDIO_HDI_RENDER_RESUME, + AUDIO_HDI_RENDER_FLUSH, + AUDIO_HDI_RENDER_GET_FRAME_SIZE, + AUDIO_HDI_RENDER_GET_FRAME_COUNT, + AUDIO_HDI_RENDER_SET_SAMPLE_ATTR, + AUDIO_HDI_RENDER_GET_SAMPLE_ATTR, + AUDIO_HDI_RENDER_GET_CUR_CHANNEL_ID, + AUDIO_HDI_RENDER_CHECK_SCENE_CAPABILITY, + AUDIO_HDI_RENDER_SELECT_SCENE, + AUDIO_HDI_RENDER_GET_MUTE, + AUDIO_HDI_RENDER_SET_MUTE, + AUDIO_HDI_RENDER_SET_VOLUME, + AUDIO_HDI_RENDER_GET_VOLUME, + AUDIO_HDI_RENDER_GET_GAIN_THRESHOLD, + AUDIO_HDI_RENDER_GET_GAIN, + AUDIO_HDI_RENDER_SET_GAIN, + AUDIO_HDI_RENDER_GET_LATENCY, + AUDIO_HDI_RENDER_RENDER_FRAME, + AUDIO_HDI_RENDER_GET_RENDER_POSITION, + AUDIO_HDI_RENDER_GET_SPEED, + AUDIO_HDI_RENDER_SET_SPEED, + AUDIO_HDI_RENDER_SET_CHANNEL_MODE, + AUDIO_HDI_RENDER_GET_CHANNEL_MODE, + /***********capture*************/ + AUDIO_HDI_CAPTURE_CREATE_CAPTURE, + AUDIO_HDI_CAPTURE_DESTROY, + AUDIO_HDI_CAPTURE_START, + AUDIO_HDI_CAPTURE_STOP, + AUDIO_HDI_CAPTURE_PAUSE, + AUDIO_HDI_CAPTURE_RESUME, + AUDIO_HDI_CAPTURE_FLUSH, + AUDIO_HDI_CAPTURE_GET_FRAME_SIZE, + AUDIO_HDI_CAPTURE_GET_FRAME_COUNT, + AUDIO_HDI_CAPTURE_SET_SAMPLE_ATTR, + AUDIO_HDI_CAPTURE_GET_SAMPLE_ATTR, + AUDIO_HDI_CAPTURE_GET_CUR_CHANNEL_ID, + AUDIO_HDI_CAPTURE_CHECK_SCENE_CAPABILITY, + AUDIO_HDI_CAPTURE_SELECT_SCENE, + AUDIO_HDI_CAPTURE_GET_MUTE, + AUDIO_HDI_CAPTURE_SET_MUTE, + AUDIO_HDI_CAPTURE_SET_VOLUME, + AUDIO_HDI_CAPTURE_GET_VOLUME, + AUDIO_HDI_CAPTURE_GET_GAIN_THRESHOLD, + AUDIO_HDI_CAPTURE_GET_GAIN, + AUDIO_HDI_CAPTURE_SET_GAIN, + AUDIO_HDI_CAPTURE_CAPTURE_FRAME, + AUDIO_HDI_CAPTURE_GET_CAPTURE_POSITION +}; + +typedef int32_t (*AudioAllfunc)(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply); +struct HdiServiceDispatchCmdHandleList { + enum AudioHdiServerCmdId cmd; + AudioAllfunc func; +}; + +#endif + 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 new file mode 100755 index 0000000000000000000000000000000000000000..ffc650d8ccbc1532f38e72bd2c78014363428f8f --- /dev/null +++ b/audio/hal/hdi_binder/server/include/hdf_audio_server_capture.h @@ -0,0 +1,74 @@ +/* + * 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 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); +int32_t HdiServiceCaptureDestory(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCaptureStart(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCaptureStop(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCapturePause(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCaptureResume(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCaptureFlush(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCaptureGetFrameSize(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCaptureGetFrameCount(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCaptureSetSampleAttr(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCaptureGetSampleAttr(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCaptureGetCurChannelId(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCaptureCheckSceneCapability(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCaptureSelectScene(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCaptureGetMute(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCaptureSetMute(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCaptureSetVolume(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCaptureGetVolume(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCaptureGetGainThreshold(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCaptureGetGain(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCaptureSetGain(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCaptureCaptureFrame(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceCaptureGetCapturePosition(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 new file mode 100755 index 0000000000000000000000000000000000000000..ec25f556f01bafeed024b498811e5fe0003e1b1a --- /dev/null +++ b/audio/hal/hdi_binder/server/include/hdf_audio_server_common.h @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef HDF_AUDIO_SERVER_COMMON_H +#define HDF_AUDIO_SERVER_COMMON_H + +#include "audio_manager.h" +#include "audio_types.h" +#include "audio_internal.h" +#include "hdf_audio_server.h" + +#define MAX_AUDIO_ADAPTER_NUM_SERVER 3 + +/* RenderManage Info */ +struct AudioInfoInAdapter { + const char *adapterName; + struct AudioAdapter *adapter; + int adapterUserNum; + int renderStatus; + int renderPriority; + struct AudioRender *render; + bool renderBusy; + bool renderDestory; + uint32_t renderPid; + int captureStatus; + int capturePriority; + struct AudioCapture *capture; + bool captureBusy; + bool captureDestory; + uint32_t capturePid; +}; + +int32_t AudioAdapterListGetAdapterCapture(const char *adapterName, + struct AudioAdapter **adapter, struct AudioCapture **capture); +int32_t AudioDestroyCaptureInfoInAdapter(const char *adapterName); +int32_t AudioCreatCaptureCheck(const char *adapterName, const int32_t priority); +int32_t AudioAddCaptureInfoInAdapter(const char *adapterName, + struct AudioCapture *capture, + struct AudioAdapter *adapter, + const int32_t priority, + uint32_t capturePid); +int32_t AudioAdapterListGetAdapter(const char *adapterName, struct AudioAdapter **adapter); +int32_t AudioCreatRenderCheck(const char *adapterName, const int32_t priority); +int32_t AudioAddRenderInfoInAdapter(const char *adapterName, + struct AudioRender *render, + struct AudioAdapter *adapter, + const int32_t priority, + uint32_t renderPid); +int32_t AudioDestroyRenderInfoInAdapter(const char *adapterName); +int32_t AudioAdapterListGetAdapterRender(const char *adapterName, + struct AudioAdapter **adapter, struct AudioRender **render); +int32_t AudioAdapterCheckListExist(const char *adapterName); +int32_t AudioAdapterListDestory(const char *adapterName, struct AudioAdapter **adapter); +int32_t AudioAdapterListAdd(const char *adapterName, struct AudioAdapter *adapter); +int32_t HdiServiceRenderCaptureReadData(struct HdfSBuf *data, + const char **adapterName, uint32_t *pid); +int32_t AudioAdapterListGetRender(const char *adapterName, + struct AudioRender **render, uint32_t pid); +int32_t AudioAdapterListGetPid(const char *adapterName, uint32_t *pid); +void AudioSetRenderStatus(const char *adapterName, bool renderStatus); +int32_t AudioGetRenderStatus(const char *adapterName); +int32_t AudioAdapterListCheckAndGetRender(struct AudioRender **render, struct HdfSBuf *data); +int32_t AudioAdapterListGetCapture(const char *adapterName, + struct AudioCapture **capture, uint32_t pid); +int32_t AudioAdapterListCheckAndGetCapture(struct AudioCapture **capture, struct HdfSBuf *data); +int32_t ReadAudioSapmleAttrbutes(struct HdfSBuf *data, struct AudioSampleAttributes *attrs); +int32_t WriteAudioSampleAttributes(struct HdfSBuf *reply, const struct AudioSampleAttributes *attrs); +void AudioSetCaptureStatus(const char *adapterName, bool captureStatus); +int32_t AudioGetCaptureStatus(const char *adapterName); + +#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 new file mode 100755 index 0000000000000000000000000000000000000000..4f83e5600ba9b60ec4b1dac283a652abde8c3597 --- /dev/null +++ b/audio/hal/hdi_binder/server/include/hdf_audio_server_render.h @@ -0,0 +1,86 @@ +/* + * 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 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); +int32_t HdiServiceRenderDestory(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderStart(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderStop(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderPause(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderResume(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderFlush(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderGetFrameSize(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderGetFrameCount(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderSetSampleAttr(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderGetSampleAttr(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderGetCurChannelId(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderCheckSceneCapability(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderSelectScene(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderGetMute(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderSetMute(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderSetVolume(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderGetVolume(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderGetGainThreshold(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderGetGain(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderSetGain(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderGetLatency(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderRenderFrame(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderGetRenderPosition(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderGetSpeed(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderSetSpeed(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderSetChannelMode(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); +int32_t HdiServiceRenderGetChannelMode(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply); + +#endif + diff --git a/audio/hal/hdi_binder/server/src/BUILD.gn b/audio/hal/hdi_binder/server/src/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..e412aeb88f4e0567c3fdf35dd0d332b7419b5cd9 --- /dev/null +++ b/audio/hal/hdi_binder/server/src/BUILD.gn @@ -0,0 +1,95 @@ +# 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_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_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 (is_standard_system) { + external_deps = [ "hiviewdfx_hilog_native:libhilog" ] + } else { + external_deps = [ "hilog:libhilog" ] + } + + public_configs = [ ":hdi_service_config" ] + + subsystem_name = "hdf" +} \ No newline at end of file diff --git a/audio/hal/hdi_binder/server/src/hdf_audio_server.c b/audio/hal/hdi_binder/server/src/hdf_audio_server.c new file mode 100755 index 0000000000000000000000000000000000000000..b6455d044d58eb15c447ab896676e7f4a0008412 --- /dev/null +++ b/audio/hal/hdi_binder/server/src/hdf_audio_server.c @@ -0,0 +1,461 @@ +/* + * 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 "hdf_audio_server.h" +#include "hdf_audio_server_common.h" + +#define HDF_LOG_TAG hdf_audio_server +struct AudioAdapterDescriptor *g_descs = NULL; +struct AudioManager *g_serverManager = NULL; + +/**************************public************************/ +int32_t HdiServiceGetFuncs() +{ + HDF_LOGE("%{public}s", "enter to HdiServiceGetFuncs "); + if (g_serverManager != NULL) { + return HDF_SUCCESS; + } + g_serverManager = GetAudioManagerFuncs(); + if (g_serverManager == NULL) { + HDF_LOGE("%{public}s", "GetAudioManagerFuncs FAIL!\n"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +static int32_t HdiServiceGetAllAdapter(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + HDF_LOGE("%{public}s", "enter to HdiServiceGetAllAdapter "); + struct AudioAdapterDescriptor *descs = NULL; + struct AudioManager *manager = g_serverManager; + int32_t size = 0; + if (manager == NULL) { + HDF_LOGE("%{public}s", "Manager is NULL"); + return HDF_FAILURE; + } + int32_t ret = manager->GetAllAdapters(manager, &descs, &size); + if (ret < 0) { + HDF_LOGE("%{public}s", "g_manager->GetAllAdapters error"); + 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"); + return HDF_ERR_NOT_SUPPORT; + } + g_descs = descs; + HDF_LOGE("%{public}s", "GetAllAdapters out"); + return HDF_SUCCESS; +} + +int SwitchAdapter(struct AudioAdapterDescriptor *descs, const char *adapterNameCase, enum AudioPortDirection portFlag, + struct AudioPort *renderPort, const int size) +{ + for (int index = 0; index < size; index++) { + struct AudioAdapterDescriptor *desc = &descs[index]; + if (strcmp(desc->adapterName, adapterNameCase)) { + continue; + } + for (uint32_t port = 0; ((desc != NULL) && (port < desc->portNum)); port++) { + if (desc->ports[port].dir == portFlag) { + *renderPort = desc->ports[port]; + HDF_LOGE("%{public}s,%{public}d", "SwitchAdapter success!", portFlag); + return index; + } + } + } + HDF_LOGE("%{public}s", "SwitchAdapter out!"); + return HDF_FAILURE; +} + +/* Adapter Check */ + +static int32_t HdiServiceLoadAdapter(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + HDF_LOGE("%{public}s", "HdiServiceLoadAdapter entry!"); + int ret; + struct AudioManager *manager = NULL; + struct AudioAdapter *adapter = NULL; + struct AudioPort renderPort; + const char *adapterName = NULL; + uint32_t tempDir; + if ((adapterName = HdfSbufReadString(data)) == NULL) { + HDF_LOGE("%{public}s", "adapterNameCase Is NULL"); + return HDF_FAILURE; + } + ret = AudioAdapterCheckListExist(adapterName); + if (ret == HDF_ERR_INVALID_PARAM) { + return HDF_FAILURE; + } + if (ret == HDF_SUCCESS) { + HDF_LOGE("%{public}s", "HdiServiceLoadAdapter: adapte already exist !"); + return HDF_SUCCESS; + } + if (!HdfSbufReadUint32(data, &tempDir)) { + HDF_LOGE("%{public}s", "HdiServiceLoadAdapter: adapter need Load!"); + return HDF_FAILURE; + } + enum AudioPortDirection port = (enum AudioPortDirection)tempDir; + manager = g_serverManager; + if (adapterName == NULL || manager == NULL || g_descs == NULL) { + HDF_LOGE("%{public}s", "Point is NULL!"); + return HDF_FAILURE; + } + int index = SwitchAdapter(g_descs, adapterName, port, &renderPort, MAX_AUDIO_ADAPTER_NUM_SERVER); + if (index < 0) { + return HDF_ERR_NOT_SUPPORT; + } + struct AudioAdapterDescriptor *desc = &g_descs[index]; + ret = manager->LoadAdapter(manager, desc, &adapter); + if (ret < 0) { + return HDF_ERR_NOT_SUPPORT; + } + if (adapter == NULL) { + HDF_LOGE("%{public}s", "load audio device failed"); + return HDF_FAILURE; + } + if (AudioAdapterListAdd(adapterName, adapter)) { + HDF_LOGE("%{public}s", "AudioAdapterListAdd error!"); + manager->UnloadAdapter(manager, adapter); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +static int32_t HdiServiceInitAllPorts(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + HDF_LOGE("%{public}s", "HdiServiceInitAllPorts"); + const char *adapterName = NULL; + struct AudioAdapter *adapter = NULL; + if ((adapterName = HdfSbufReadString(data)) == NULL) { + HDF_LOGE("%{public}s", "adapterNameCase Is NULL"); + return HDF_FAILURE; + } + if (AudioAdapterListGetAdapter(adapterName, &adapter)) { + HDF_LOGE("%{public}s", "AudioAdapterListGetAdapter fail"); + return HDF_FAILURE; + } + if (adapter->InitAllPorts(adapter)) { + HDF_LOGE("%{public}s", "InitAllPorts fail"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +static int32_t HdiServiceUnloadAdapter(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + struct AudioAdapter *adapter = NULL; + const char *adapterName = NULL; + int ret; + struct AudioManager *manager = g_serverManager; + if (manager == NULL) { + HDF_LOGE("%{public}s", "Point is NULL!"); + return HDF_FAILURE; + } + if ((adapterName = HdfSbufReadString(data)) == NULL) { + HDF_LOGE("%{public}s", "adapterNameCase Is NULL"); + return HDF_FAILURE; + } + ret = AudioAdapterListDestory(adapterName, &adapter); + if (ret == HDF_FAILURE) { + HDF_LOGE("%{public}s", "Other dev Use the adapter"); + return HDF_SUCCESS; + } else if (ret == HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%{public}s", "HdiServiceUnloadAdapter: param invalid!"); + return HDF_FAILURE; + } else { + HDF_LOGE("%{public}s", "HdiServiceUnloadAdapter: Unload the adapter!"); + } + if (adapter == NULL) { + return HDF_FAILURE; + } + manager->UnloadAdapter(manager, adapter); + return HDF_SUCCESS; +} + +static int32_t HdiServiceGetPortCapability(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + HDF_LOGE("%{public}s", "HdiServiceGetPortCapability in!"); + struct AudioPort port; + struct AudioPortCapability capability; + struct AudioAdapter *adapter = NULL; + const char *adapterName = NULL; + uint32_t tempDir; + if ((adapterName = HdfSbufReadString(data)) == NULL) { + HDF_LOGE("%{public}s", "adapterNameCase Is NULL"); + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &tempDir)) { + return HDF_FAILURE; + } + port.dir = (enum AudioPortDirection)tempDir; + if (!HdfSbufReadUint32(data, &port.portId)) { + return HDF_FAILURE; + } + if ((port.portName = HdfSbufReadString(data)) == NULL) { + return HDF_FAILURE; + } + HDF_LOGE("port.portName = %{public}s", port.portName); + if (AudioAdapterListGetAdapter(adapterName, &adapter)) { + HDF_LOGE("%{public}s", "AudioAdapterListGetAdapter fail"); + return HDF_FAILURE; + } + if (adapter == NULL) { + HDF_LOGE("%{public}s", "HdiServiceCreatRender adapter is NULL!"); + return HDF_FAILURE; + } + int32_t ret = adapter->GetPortCapability(adapter, &port, &capability); + if (ret < 0) { + HDF_LOGE("%{public}s", "HdiServiceGetPortCapability ret failed"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +static int32_t HdiServiceSetPassthroughMode(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + HDF_LOGE("%{public}s", "HdiServiceSetPassthroughMode in"); + struct AudioPort port; + enum AudioPortPassthroughMode mode; + struct AudioAdapter *adapter = NULL; + const char *adapterName = NULL; + if ((adapterName = HdfSbufReadString(data)) == NULL) { + HDF_LOGE("%{public}s", "adapterNameCase Is NULL"); + return HDF_FAILURE; + } + uint32_t tempDir; + if (!HdfSbufReadUint32(data, &tempDir)) { + return HDF_FAILURE; + } + port.dir = (enum AudioPortDirection)tempDir; + HDF_LOGE("port.dir = %{public}d", port.dir); + if (!HdfSbufReadUint32(data, &port.portId)) { + return HDF_FAILURE; + } + if ((port.portName = HdfSbufReadString(data)) == NULL) { + HDF_LOGE("port.portName = %{public}s", port.portName); + return HDF_FAILURE; + } + HDF_LOGE("port.portName = %{public}s", port.portName); + uint32_t tempMode = 0; + if (!HdfSbufReadUint32(data, &tempMode)) { + return HDF_FAILURE; + } + mode = (enum AudioPortPassthroughMode)tempMode; + HDF_LOGE("%{public}s mode = %{public}d", "SetPassthroughMode ready in", mode); + if (AudioAdapterListGetAdapter(adapterName, &adapter)) { + HDF_LOGE("%{public}s", "AudioAdapterListGetAdapter fail"); + return HDF_FAILURE; + } + if (adapter == NULL) { + HDF_LOGE("%{public}s", "HdiServiceCreatRender adapter is NULL!"); + return HDF_FAILURE; + } + int ret = adapter->SetPassthroughMode(adapter, &port, mode); + return ret; +} +static int32_t HdiServiceGetPassthroughMode(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + struct AudioPort port; + enum AudioPortPassthroughMode mode; + struct AudioAdapter *adapter = NULL; + const char *adapterName = NULL; + if ((adapterName = HdfSbufReadString(data)) == NULL) { + HDF_LOGE("%{public}s", "adapterNameCase Is NULL"); + return HDF_FAILURE; + } + uint32_t tempDir = port.dir; + if (!HdfSbufReadUint32(data, &tempDir)) { + return HDF_FAILURE; + } + port.dir = (enum AudioPortDirection)tempDir; + if (!HdfSbufReadUint32(data, &port.portId)) { + return HDF_FAILURE; + } + if ((port.portName = HdfSbufReadString(data)) == NULL) { + HDF_LOGE("port.portName = %{public}s", port.portName); + return HDF_FAILURE; + } + if (AudioAdapterListGetAdapter(adapterName, &adapter)) { + HDF_LOGE("%{public}s", "AudioAdapterListGetAdapter fail"); + return HDF_FAILURE; + } + if (adapter == NULL) { + HDF_LOGE("%{public}s", "HdiServiceCreatRender adapter is NULL!"); + return HDF_FAILURE; + } + int ret = adapter->GetPassthroughMode(adapter, &port, &mode); + if (ret < 0) { + HDF_LOGE("%{public}s", "GetPassthroughMode ret failed"); + return HDF_FAILURE; + } + uint32_t tempMode = (uint32_t)mode; + if (!HdfSbufWriteUint32(reply, tempMode)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/*****************************end*************************/ +struct HdiServiceDispatchCmdHandleList g_hdiServiceDispatchCmdHandleList[] = { + {AUDIO_HDI_MGR_GET_FUNCS, HdiServiceGetFuncs}, + {AUDIO_HDI_MGR_GET_ALL_ADAPTER, HdiServiceGetAllAdapter}, + {AUDIO_HDI_MGR_LOAD_ADAPTER, HdiServiceLoadAdapter}, + {AUDIO_HDI_MGR_UNLOAD_ADAPTER, HdiServiceUnloadAdapter}, + {AUDIO_HDI_ADT_INIT_PORTS, HdiServiceInitAllPorts}, + {AUDIO_HDI_ADT_GET_PORT_CAPABILITY, HdiServiceGetPortCapability}, + {AUDIO_HDI_ADT_SET_PASS_MODE, HdiServiceSetPassthroughMode}, + {AUDIO_HDI_ADT_GET_PASS_MODE, HdiServiceGetPassthroughMode}, + {AUDIO_HDI_RENDER_CREATE_RENDER, HdiServiceCreatRender}, + {AUDIO_HDI_RENDER_DESTROY, HdiServiceRenderDestory}, + {AUDIO_HDI_RENDER_START, HdiServiceRenderStart}, + {AUDIO_HDI_RENDER_STOP, HdiServiceRenderStop}, + {AUDIO_HDI_RENDER_PAUSE, HdiServiceRenderPause}, + {AUDIO_HDI_RENDER_RESUME, HdiServiceRenderResume}, + {AUDIO_HDI_RENDER_FLUSH, HdiServiceRenderFlush}, + {AUDIO_HDI_RENDER_GET_FRAME_SIZE, HdiServiceRenderGetFrameSize}, + {AUDIO_HDI_RENDER_GET_FRAME_COUNT, HdiServiceRenderGetFrameCount}, + {AUDIO_HDI_RENDER_SET_SAMPLE_ATTR, HdiServiceRenderSetSampleAttr}, + {AUDIO_HDI_RENDER_GET_SAMPLE_ATTR, HdiServiceRenderGetSampleAttr}, + {AUDIO_HDI_RENDER_GET_CUR_CHANNEL_ID, HdiServiceRenderGetCurChannelId}, + {AUDIO_HDI_RENDER_CHECK_SCENE_CAPABILITY, HdiServiceRenderCheckSceneCapability}, + {AUDIO_HDI_RENDER_SELECT_SCENE, HdiServiceRenderSelectScene}, + {AUDIO_HDI_RENDER_GET_MUTE, HdiServiceRenderGetMute}, + {AUDIO_HDI_RENDER_SET_MUTE, HdiServiceRenderSetMute}, + {AUDIO_HDI_RENDER_SET_VOLUME, HdiServiceRenderSetVolume}, + {AUDIO_HDI_RENDER_GET_VOLUME, HdiServiceRenderGetVolume}, + {AUDIO_HDI_RENDER_GET_GAIN_THRESHOLD, HdiServiceRenderGetGainThreshold}, + {AUDIO_HDI_RENDER_GET_GAIN, HdiServiceRenderGetGain}, + {AUDIO_HDI_RENDER_SET_GAIN, HdiServiceRenderSetGain}, + {AUDIO_HDI_RENDER_GET_LATENCY, HdiServiceRenderGetLatency}, + {AUDIO_HDI_RENDER_RENDER_FRAME, HdiServiceRenderRenderFrame}, + {AUDIO_HDI_RENDER_GET_RENDER_POSITION, HdiServiceRenderGetRenderPosition}, + {AUDIO_HDI_RENDER_GET_SPEED, HdiServiceRenderGetSpeed}, + {AUDIO_HDI_RENDER_SET_SPEED, HdiServiceRenderSetSpeed}, + {AUDIO_HDI_RENDER_SET_CHANNEL_MODE, HdiServiceRenderSetChannelMode}, + {AUDIO_HDI_RENDER_GET_CHANNEL_MODE, HdiServiceRenderGetChannelMode}, +}; + +static struct HdiServiceDispatchCmdHandleList g_hdiServiceDispatchCmdHandleCapList[] = { + {AUDIO_HDI_CAPTURE_CREATE_CAPTURE, HdiServiceCreatCapture}, + {AUDIO_HDI_CAPTURE_DESTROY, HdiServiceCaptureDestory}, + {AUDIO_HDI_CAPTURE_START, HdiServiceCaptureStart}, + {AUDIO_HDI_CAPTURE_STOP, HdiServiceCaptureStop}, + {AUDIO_HDI_CAPTURE_PAUSE, HdiServiceCapturePause}, + {AUDIO_HDI_CAPTURE_RESUME, HdiServiceCaptureResume}, + {AUDIO_HDI_CAPTURE_FLUSH, HdiServiceCaptureFlush}, + {AUDIO_HDI_CAPTURE_GET_FRAME_SIZE, HdiServiceCaptureGetFrameSize}, + {AUDIO_HDI_CAPTURE_GET_FRAME_COUNT, HdiServiceCaptureGetFrameCount}, + {AUDIO_HDI_CAPTURE_SET_SAMPLE_ATTR, HdiServiceCaptureSetSampleAttr}, + {AUDIO_HDI_CAPTURE_GET_SAMPLE_ATTR, HdiServiceCaptureGetSampleAttr}, + {AUDIO_HDI_CAPTURE_GET_CUR_CHANNEL_ID, HdiServiceCaptureGetCurChannelId}, + {AUDIO_HDI_CAPTURE_CHECK_SCENE_CAPABILITY, HdiServiceCaptureCheckSceneCapability}, + {AUDIO_HDI_CAPTURE_SELECT_SCENE, HdiServiceCaptureSelectScene}, + {AUDIO_HDI_CAPTURE_GET_MUTE, HdiServiceCaptureGetMute}, + {AUDIO_HDI_CAPTURE_SET_MUTE, HdiServiceCaptureSetMute}, + {AUDIO_HDI_CAPTURE_SET_VOLUME, HdiServiceCaptureSetVolume}, + {AUDIO_HDI_CAPTURE_GET_VOLUME, HdiServiceCaptureGetVolume}, + {AUDIO_HDI_CAPTURE_GET_GAIN_THRESHOLD, HdiServiceCaptureGetGainThreshold}, + {AUDIO_HDI_CAPTURE_GET_GAIN, HdiServiceCaptureGetGain}, + {AUDIO_HDI_CAPTURE_SET_GAIN, HdiServiceCaptureSetGain}, + {AUDIO_HDI_CAPTURE_CAPTURE_FRAME, HdiServiceCaptureCaptureFrame}, + {AUDIO_HDI_CAPTURE_GET_CAPTURE_POSITION, HdiServiceCaptureGetCapturePosition}, +}; + +static int32_t HdiServiceDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, + struct HdfSBuf *reply) +{ + unsigned int i; + if ((client == NULL) || (data == NULL)) { + HDF_LOGE("%{public}s", "ControlDispatch: input para is NULL."); + return HDF_FAILURE; + } + HDF_LOGE("ControlDispatch: valid cmdId = %{public}d", cmdId); + + if (cmdId > AUDIO_HDI_CAPTURE_GET_CAPTURE_POSITION || cmdId < 0) { + HDF_LOGE("ControlDispatch: invalid cmdId = %{public}d", cmdId); + return HDF_FAILURE; + } else if (cmdId <= AUDIO_HDI_RENDER_GET_CHANNEL_MODE) { + for (i = 0; i < sizeof(g_hdiServiceDispatchCmdHandleList) / + sizeof(g_hdiServiceDispatchCmdHandleList[0]); ++i) { + if ((cmdId == (int)(g_hdiServiceDispatchCmdHandleList[i].cmd)) && + (g_hdiServiceDispatchCmdHandleList[i].func != NULL)) { + return g_hdiServiceDispatchCmdHandleList[i].func(client, data, reply); + } + } + } else { + for (i = 0; i < sizeof(g_hdiServiceDispatchCmdHandleCapList) / + sizeof(g_hdiServiceDispatchCmdHandleCapList[0]); ++i) { + if ((cmdId == (int)(g_hdiServiceDispatchCmdHandleCapList[i].cmd)) && + (g_hdiServiceDispatchCmdHandleCapList[i].func != NULL)) { + return g_hdiServiceDispatchCmdHandleCapList[i].func(client, data, reply); + } + } + } + return HDF_FAILURE; +} + +void AudioHdiServerRelease(struct HdfDeviceObject *deviceObject) +{ + LOG_FUN_INFO(); + if (deviceObject == NULL) { + HDF_LOGE("deviceObject is null!"); + return; + } + deviceObject->service = NULL; + return; +} + +int AudioHdiServerBind(struct HdfDeviceObject *deviceObject) +{ + LOG_FUN_INFO(); + if (deviceObject == NULL) { + HDF_LOGE("deviceObject is null!"); + return HDF_FAILURE; + } + static struct IDeviceIoService hdiService = { + .Dispatch = HdiServiceDispatch, + .Open = NULL, + .Release = NULL, + }; + if (HdiServiceGetFuncs()) { + return HDF_FAILURE; + } + deviceObject->service = &hdiService; + return HDF_SUCCESS; +} + +int AudioHdiServerInit(struct HdfDeviceObject *deviceObject) +{ + LOG_FUN_INFO(); + if (deviceObject == NULL) { + HDF_LOGE("deviceObject is null!"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +struct HdfDriverEntry g_hdiServerEntry = { + .moduleVersion = 1, + .moduleName = "audio_hdi_adapter_server", + .Bind = AudioHdiServerBind, + .Init = AudioHdiServerInit, + .Release = AudioHdiServerRelease, +}; + +HDF_INIT(g_hdiServerEntry); + 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 new file mode 100755 index 0000000000000000000000000000000000000000..4100551710bd7603e4334e0a7e2405be387f2324 --- /dev/null +++ b/audio/hal/hdi_binder/server/src/hdf_audio_server_capture.c @@ -0,0 +1,644 @@ +/* + * 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 "hdf_audio_server_capture.h" + +int32_t GetInitCaptureParaAttrs(struct HdfSBuf *data, struct AudioSampleAttributes *attrs) +{ + if (data == NULL || attrs == NULL) { + return HDF_FAILURE; + } + uint32_t tempCapturePara = 0; + if (!HdfSbufReadUint32(data, &tempCapturePara)) { + HDF_LOGE("%{public}s", " read buf fail"); + return HDF_FAILURE; + } + attrs->type = (enum AudioCategory)tempCapturePara; + if (!HdfSbufReadUint32(data, &attrs->period)) { + HDF_LOGE("%{public}s", " read buf fail"); + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &attrs->frameSize)) { + HDF_LOGE("%{public}s", " read buf fail"); + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &attrs->startThreshold)) { + HDF_LOGE("%{public}s", " read buf fail"); + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &attrs->stopThreshold)) { + HDF_LOGE("%{public}s", " read buf fail"); + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &attrs->silenceThreshold)) { + HDF_LOGE("%{public}s", " read buf fail"); + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &tempCapturePara)) { + LOG_FUN_ERR("Failed to Get Speed sBuf!"); + return HDF_FAILURE; + } + attrs->isBigEndian = (bool)tempCapturePara; + if (!HdfSbufReadUint32(data, &tempCapturePara)) { + LOG_FUN_ERR("Failed to Get Speed sBuf!"); + return HDF_FAILURE; + } + attrs->isSignedData = (bool)tempCapturePara; + return HDF_SUCCESS; +} + +int32_t GetInitCapturePara(struct HdfSBuf *data, struct AudioDeviceDescriptor *devDesc, + struct AudioSampleAttributes *attrs) +{ + if (data == NULL || devDesc == NULL || attrs == NULL) { + return HDF_FAILURE; + } + uint32_t tempCapturePara = 0; + if (!HdfSbufReadUint32(data, &tempCapturePara)) { + LOG_FUN_ERR("Failed to Get Speed sBuf!"); + return HDF_FAILURE; + } + attrs->format = (enum AudioFormat)tempCapturePara; + if (!HdfSbufReadUint32(data, &attrs->channelCount)) { + HDF_LOGE("%{public}s", " read buf fail"); + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &attrs->sampleRate)) { + HDF_LOGE("%{public}s", " read buf fail"); + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &tempCapturePara)) { + LOG_FUN_ERR("Failed to Get Speed sBuf!"); + return HDF_FAILURE; + } + attrs->interleaved = (bool)tempCapturePara; + if (GetInitCaptureParaAttrs(data, attrs) < 0) { + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &devDesc->portId)) { + HDF_LOGE("%{public}s", " read buf fail"); + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &tempCapturePara)) { + HDF_LOGE("%{public}s", " read buf fail"); + return HDF_FAILURE; + } + devDesc->pins = (enum AudioPortPin)tempCapturePara; + devDesc->desc = NULL; + return HDF_SUCCESS; +} + +int32_t HdiServiceCreatCapture(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + struct AudioAdapter *adapter = NULL; + struct AudioDeviceDescriptor devDesc; + struct AudioSampleAttributes attrs; + struct AudioCapture *capture = NULL; + const char *adapterName = NULL; + uint32_t capturePid; + if ((adapterName = HdfSbufReadString(data)) == NULL) { + HDF_LOGE("%{public}s", "adapterNameCase Is NULL"); + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &capturePid)) { + HDF_LOGE("%{public}s", " read buf fail"); + return HDF_FAILURE; + } + HDF_LOGE("%{public}s, capturePid = %{public}u", "HdiServiceCreatCapture:", capturePid); + int32_t ret = GetInitCapturePara(data, &devDesc, &attrs); + if (ret < 0) { + LOG_FUN_ERR("read Render param failure!"); + return HDF_FAILURE; + } + if (AudioAdapterListGetAdapter(adapterName, &adapter)) { + HDF_LOGE("%{public}s", "AudioAdapterListGetAdapter fail"); + return HDF_FAILURE; + } + if (adapter == NULL) { + HDF_LOGE("%{public}s", "HdiServiceCreatCapture adapter is NULL!"); + 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!"); + return ret; + } + ret = adapter->CreateCapture(adapter, &devDesc, &attrs, &capture); + if (capture == NULL || ret < 0) { + HDF_LOGE("%{public}s", "Failed to CreateCapture "); + return HDF_FAILURE; + } + if (AudioAddCaptureInfoInAdapter(adapterName, capture, adapter, priority, capturePid)) { + HDF_LOGE("%{public}s", "AudioAddRenderInfoInAdapter"); + adapter->DestroyCapture(adapter, capture); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t HdiServiceCaptureDestory(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + struct AudioAdapter *adapter = NULL; + struct AudioCapture *capture = NULL; + const char *adapterName = NULL; + uint32_t pid; + 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"); + return ret; + } + ret = AudioAdapterListGetAdapterCapture(adapterName, &adapter, &capture); + if (ret < 0) { + HDF_LOGE("%{public}s", "AudioAdapterListGetAdapter fail"); + return ret; + } + ret = adapter->DestroyCapture(adapter, capture); + if (ret < 0) { + HDF_LOGE("%{public}s", "DestroyCapture failed!"); + return ret; + } + if (AudioDestroyCaptureInfoInAdapter(adapterName)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t HdiServiceCaptureStart(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + struct AudioCapture *capture = NULL; + int ret = AudioAdapterListCheckAndGetCapture(&capture, data); + if (ret < 0) { + return ret; + } + return capture->control.Start((AudioHandle)capture); +} + +int32_t HdiServiceCaptureStop(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + 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 HdiServiceCapturePause(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + struct AudioCapture *capture = NULL; + int ret = AudioAdapterListCheckAndGetCapture(&capture, data); + if (ret < 0) { + return ret; + } + return capture->control.Pause((AudioHandle)capture); +} + +int32_t HdiServiceCaptureResume(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + struct AudioCapture *capture = NULL; + int ret = AudioAdapterListCheckAndGetCapture(&capture, data); + if (ret < 0) { + return ret; + } + return capture->control.Resume((AudioHandle)capture); +} + +int32_t HdiServiceCaptureFlush(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + struct AudioCapture *capture = NULL; + int ret = AudioAdapterListCheckAndGetCapture(&capture, data); + if (ret < 0) { + return ret; + } + return capture->control.Flush((AudioHandle)capture); +} + +int32_t HdiServiceCaptureGetFrameSize(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + uint64_t size; + struct AudioCapture *capture = NULL; + int ret = AudioAdapterListCheckAndGetCapture(&capture, data); + if (ret < 0) { + return ret; + } + if (capture->attr.GetFrameSize((AudioHandle)capture, &size)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint64(reply, size)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t HdiServiceCaptureGetFrameCount(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + uint64_t count; + struct AudioCapture *capture = NULL; + int ret = AudioAdapterListCheckAndGetCapture(&capture, data); + if (ret < 0) { + return ret; + } + if (capture->attr.GetFrameCount((AudioHandle)capture, &count)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint64(reply, count)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t HdiServiceCaptureSetSampleAttr(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + struct AudioSampleAttributes attrs; + struct AudioCapture *capture = NULL; + int ret = AudioAdapterListCheckAndGetCapture(&capture, data); + if (ret < 0) { + return ret; + } + if (ReadAudioSapmleAttrbutes(data, &attrs) < 0) { + return HDF_FAILURE; + } + return capture->attr.SetSampleAttributes((AudioHandle)capture, &attrs); +} + +int32_t HdiServiceCaptureGetSampleAttr(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + struct AudioSampleAttributes attrs; + struct AudioCapture *capture = NULL; + int ret = AudioAdapterListCheckAndGetCapture(&capture, data); + if (ret < 0) { + return ret; + } + ret = capture->attr.GetSampleAttributes((AudioHandle)capture, &attrs); + if (ret < 0) { + return ret; + } + if (WriteAudioSampleAttributes(reply, &attrs) < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t HdiServiceCaptureGetCurChannelId(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + uint32_t channelId; + struct AudioCapture *capture = NULL; + int ret = AudioAdapterListCheckAndGetCapture(&capture, data); + if (ret < 0) { + return ret; + } + ret = capture->attr.GetCurrentChannelId((AudioHandle)capture, &channelId); + if (ret < 0) { + return ret; + } + if (!HdfSbufWriteUint32(reply, channelId)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t HdiServiceCaptureCheckSceneCapability(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + struct AudioSceneDescriptor scene; + bool supported = false; + struct AudioCapture *capture = NULL; + int ret = AudioAdapterListCheckAndGetCapture(&capture, data); + if (ret < 0) { + return ret; + } + if (!HdfSbufReadUint32(data, &scene.scene.id)) { + return HDF_FAILURE; + } + uint32_t tempPins = 0; + if (!HdfSbufReadUint32(data, &tempPins)) { + return HDF_FAILURE; + } + scene.desc.pins = (enum AudioPortPin) tempPins; + ret = capture->scene.CheckSceneCapability((AudioHandle)capture, &scene, &supported); + if (ret < 0) { + return ret; + } + uint32_t tempSupported = (uint32_t)supported; + if (!HdfSbufWriteUint32(reply, tempSupported)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t HdiServiceCaptureSelectScene(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + struct AudioSceneDescriptor scene; + struct AudioCapture *capture = NULL; + int ret = AudioAdapterListCheckAndGetCapture(&capture, data); + if (ret < 0) { + return ret; + } + if (!HdfSbufReadUint32(data, &scene.scene.id)) { + return HDF_FAILURE; + } + uint32_t tempPins = 0; + if (!HdfSbufReadUint32(data, &tempPins)) { + return HDF_FAILURE; + } + scene.desc.pins = (enum AudioPortPin) tempPins; + return capture->scene.SelectScene((AudioHandle)capture, &scene); +} + +int32_t HdiServiceCaptureGetMute(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + bool mute = false; + struct AudioCapture *capture = NULL; + int ret = AudioAdapterListCheckAndGetCapture(&capture, data); + if (ret < 0) { + return ret; + } + ret = capture->volume.GetMute((AudioHandle)capture, &mute); + if (ret < 0) { + return ret; + } + uint32_t tempMute = (uint32_t)mute; + if (!HdfSbufWriteUint32(reply, tempMute)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t HdiServiceCaptureSetMute(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + bool mute = false; + struct AudioCapture *capture = NULL; + int ret = AudioAdapterListCheckAndGetCapture(&capture, data); + if (ret < 0) { + return ret; + } + uint32_t tempMute = 0; + if (!HdfSbufReadUint32(data, &tempMute)) { + return HDF_FAILURE; + } + mute = (bool)tempMute; + return capture->volume.SetMute((AudioHandle)capture, mute); +} + +int32_t HdiServiceCaptureSetVolume(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + uint32_t volume; + struct AudioCapture *capture = NULL; + int ret = AudioAdapterListCheckAndGetCapture(&capture, data); + if (ret < 0) { + return ret; + } + if (!HdfSbufReadUint32(data, &volume)) { + return HDF_FAILURE; + } + float setVolume = (float)volume / VOLUME_CHANGE; + return capture->volume.SetVolume((AudioHandle)capture, setVolume); +} + +int32_t HdiServiceCaptureGetVolume(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + float volume; + struct AudioCapture *capture = NULL; + int ret = AudioAdapterListCheckAndGetCapture(&capture, data); + if (ret < 0) { + return ret; + } + ret = capture->volume.GetVolume((AudioHandle)capture, &volume); + if (ret < 0) { + return ret; + } + uint32_t tempVolume = (uint32_t)(volume * VOLUME_CHANGE); + if (!HdfSbufWriteUint32(reply, tempVolume)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t HdiServiceCaptureGetGainThreshold(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + float min, max; + struct AudioCapture *capture = NULL; + int ret = AudioAdapterListCheckAndGetCapture(&capture, data); + if (ret < 0) { + return ret; + } + ret = capture->volume.GetGainThreshold((AudioHandle)capture, &min, &max); + if (ret < 0) { + return ret; + } + uint32_t tempMin = (uint32_t)min; + if (!HdfSbufWriteUint32(reply, tempMin)) { + return HDF_FAILURE; + } + uint32_t tempMax = (uint32_t)max; + if (!HdfSbufWriteUint32(reply, tempMax)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t HdiServiceCaptureGetGain(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + float gain; + struct AudioCapture *capture = NULL; + int ret = AudioAdapterListCheckAndGetCapture(&capture, data); + if (ret < 0) { + return ret; + } + ret = capture->volume.GetGain((AudioHandle)capture, &gain); + if (ret < 0) { + return ret; + } + uint32_t tempGain = (uint32_t)gain; + if (!HdfSbufWriteUint32(reply, tempGain)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t HdiServiceCaptureSetGain(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + uint32_t gain; + struct AudioCapture *capture = NULL; + int ret = AudioAdapterListCheckAndGetCapture(&capture, data); + if (ret < 0) { + return ret; + } + if (!HdfSbufReadUint32(data, &gain)) { + return HDF_FAILURE; + } + return capture->volume.SetGain((AudioHandle)capture, (float)gain); +} + +int32_t HdiServiceCaptureCaptureFrame(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + HDF_LOGI("%{public}s", "HdiServiceCaptureCaptureFrame entry!"); + 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!"); + return HDF_FAILURE; + } + int32_t ret = AudioAdapterListGetCapture(adapterName, &capture, pid); + if (ret < 0) { + HDF_LOGE("%{public}s", "HdiServiceCaptureCaptureFrame:AudioAdapterListGetRender fail"); + return ret; + } + ret = AudioGetCaptureStatus(adapterName); + if (ret < 0) { + HDF_LOGE("%{public}s", "HdiServiceCaptureCaptureFrame:AudioGetCaptureStatus fail"); + return ret; + } + if (!HdfSbufReadUint64(data, &requestBytes)) { + return HDF_FAILURE; + } + frame = (char *)calloc(1, FRAME_DATA); + if (frame == NULL) { + return HDF_FAILURE; + } + AudioSetCaptureStatus(adapterName, true); + ret = capture->CaptureFrame((AudioHandle)capture, (void *)frame, requestBytes, &replyBytes); + AudioSetCaptureStatus(adapterName, false); + if (ret < 0) { + AudioMemFree((void **)&frame); + return ret; + } + if (!HdfSbufWriteBuffer(reply, (const void *)frame, (uint32_t)requestBytes)) { + AudioMemFree((void **)&frame); + return HDF_FAILURE; + } + if (!HdfSbufWriteUint64(reply, replyBytes)) { + AudioMemFree((void **)&frame); + return HDF_FAILURE; + } + AudioMemFree((void **)&frame); + return HDF_SUCCESS; +} + +int32_t HdiServiceCaptureGetCapturePosition(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + uint64_t frames; + struct AudioTimeStamp time; + struct AudioCapture *capture = NULL; + int ret = AudioAdapterListCheckAndGetCapture(&capture, data); + if (ret < 0) { + return ret; + } + ret = capture->GetCapturePosition((AudioHandle)capture, &frames, &time); + if (ret < 0) { + return ret; + } + if (!HdfSbufWriteUint64(reply, frames)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint64(reply, time.tvSec)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint64(reply, time.tvNSec)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} 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 new file mode 100755 index 0000000000000000000000000000000000000000..105157508c70333137b3d6198e0be6e9d8bb14a9 --- /dev/null +++ b/audio/hal/hdi_binder/server/src/hdf_audio_server_common.c @@ -0,0 +1,715 @@ +/* + * 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 "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 + } +}; + +int32_t HdiServiceRenderCaptureReadData(struct HdfSBuf *data, const char **adapterName, uint32_t *pid) +{ + if (adapterName == NULL || data == NULL || pid == NULL) { + return HDF_FAILURE; + } + if ((*adapterName = HdfSbufReadString(data)) == NULL) { + HDF_LOGE("%{public}s", "adapterName Is NULL"); + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, pid)) { + HDF_LOGE("%{public}s", " read buf fail"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioAdapterListGetAdapterCapture(const char *adapterName, + struct AudioAdapter **adapter, struct AudioCapture **capture) +{ + LOG_FUN_INFO(); + if (adapterName == NULL || adapter == NULL || capture == NULL) { + HDF_LOGE("%{public}s", "The pointer is null"); + return HDF_ERR_INVALID_PARAM; + } + int i; + for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { + *adapter = g_renderAndCaptureManage[i].adapter; + *capture = g_renderAndCaptureManage[i].capture; + return HDF_SUCCESS; + } + } + return HDF_ERR_INVALID_PARAM; +} + +int32_t AudioDestroyCaptureInfoInAdapter(const char *adapterName) +{ + LOG_FUN_INFO(); + if (adapterName == NULL) { + return HDF_FAILURE; + } + int i; + for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { + g_renderAndCaptureManage[i].captureStatus = 0; + g_renderAndCaptureManage[i].capturePriority = -1; + g_renderAndCaptureManage[i].capture = NULL; + g_renderAndCaptureManage[i].capturePid = 0; + return HDF_SUCCESS; + } + } + HDF_LOGE("%{public}s", "AudioDestroycaptureInfoInAdapter: Can not find Adapter!"); + return HDF_FAILURE; +} + +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."); + 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); + captureManage->captureDestory = false; + return HDF_ERR_DEVICE_BUSY; + } + usleep(500); // sleep 500us + count++; + } + captureManage->capturePid = 0; + if (captureManage->adapter->DestroyCapture(captureManage->adapter, captureManage->capture)) { + captureManage->captureDestory = false; + return HDF_FAILURE; + } + captureManage->capture = NULL; + captureManage->captureStatus = 0; + captureManage->captureBusy = false; + captureManage->captureDestory = false; + captureManage->renderPriority = -1; + return HDF_SUCCESS; +} + +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!"); + return HDF_FAILURE; + } + if (!(g_renderAndCaptureManage[which].captureStatus)) { + return HDF_SUCCESS; + } else { + if (g_renderAndCaptureManage[which].capturePriority <= priority) { + return AudioDestroyFormerCapture(&g_renderAndCaptureManage[which]); + } else { + return HDF_ERR_DEVICE_BUSY; + } + } + return HDF_FAILURE; +} + +int32_t AudioCreatCaptureCheck(const char *adapterName, const int32_t priority) +{ + LOG_FUN_INFO(); + if (adapterName == NULL) { + return HDF_FAILURE; + } + int i; + for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { + return AudioJudgeCapturePriority(priority, i); + } + } + HDF_LOGE("%{public}s", "AudioCreatCaptureCheck:Can not find Adapter!"); + return HDF_FAILURE; +} + +int32_t AudioAddCaptureInfoInAdapter(const char *adapterName, + struct AudioCapture *capture, + struct AudioAdapter *adapter, + const int32_t priority, + uint32_t capturePid) +{ + if (adapterName == NULL || adapter == NULL || capture == NULL) { + HDF_LOGE("%{public}s", "AudioAddcaptureInfoInAdapter: input para is NULL."); + return HDF_FAILURE; + } + int i; + for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + 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); + return HDF_SUCCESS; + } + } + HDF_LOGE("%{public}s", "AudioAddcaptureInfoInAdapter: Can not find Adapter!"); + return HDF_FAILURE; +} + +int32_t WriteAudioSampleAttributes(struct HdfSBuf *reply, const struct AudioSampleAttributes *attrs) +{ + if (reply == NULL || attrs == NULL) { + return HDF_FAILURE; + } + uint32_t tempAttrParam = (uint32_t)attrs->type; + if (!HdfSbufWriteUint32(reply, tempAttrParam)) { + return HDF_FAILURE; + } + tempAttrParam = (uint32_t)attrs->interleaved; + if (!HdfSbufWriteUint32(reply, tempAttrParam)) { + return HDF_FAILURE; + } + tempAttrParam = (uint32_t)attrs->format; + if (!HdfSbufWriteUint32(reply, tempAttrParam)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(reply, attrs->sampleRate)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(reply, attrs->channelCount)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(reply, attrs->period)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(reply, attrs->frameSize)) { + return HDF_FAILURE; + } + tempAttrParam = (uint32_t)(attrs->isBigEndian); + if (!HdfSbufWriteUint32(reply, tempAttrParam)) { + return HDF_FAILURE; + } + tempAttrParam = (uint32_t)(attrs->isSignedData); + if (!HdfSbufWriteUint32(reply, tempAttrParam)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(reply, attrs->startThreshold)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(reply, attrs->stopThreshold)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(reply, attrs->silenceThreshold)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t ReadAudioSapmleAttrbutes(struct HdfSBuf *data, struct AudioSampleAttributes *attrs) +{ + if (data == NULL || attrs == NULL) { + return HDF_FAILURE; + } + uint32_t tempAttrParam; + if (!HdfSbufReadUint32(data, &tempAttrParam)) { + return HDF_FAILURE; + } + attrs->type = (enum AudioCategory)tempAttrParam; + if (!HdfSbufReadUint32(data, &tempAttrParam)) { + return HDF_FAILURE; + } + attrs->interleaved = (bool)tempAttrParam; + if (!HdfSbufReadUint32(data, &tempAttrParam)) { + return HDF_FAILURE; + } + attrs->format = (enum AudioFormat)tempAttrParam; + if (!HdfSbufReadUint32(data, &(attrs->sampleRate))) { + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &(attrs->channelCount))) { + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &(attrs->period))) { + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &(attrs->frameSize))) { + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &tempAttrParam)) { + return HDF_FAILURE; + } + attrs->isBigEndian = (bool)tempAttrParam; + if (!HdfSbufReadUint32(data, &tempAttrParam)) { + return HDF_FAILURE; + } + attrs->isSignedData = (bool)tempAttrParam; + if (!HdfSbufReadUint32(data, &(attrs->startThreshold))) { + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &(attrs->stopThreshold))) { + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &(attrs->silenceThreshold))) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioAdapterListGetAdapter(const char *adapterName, struct AudioAdapter **adapter) +{ + LOG_FUN_INFO(); + if (adapterName == NULL || adapter == NULL) { + HDF_LOGE("%{public}s", "The pointer is null"); + return HDF_ERR_INVALID_PARAM; + } + int i; + for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { + *adapter = g_renderAndCaptureManage[i].adapter; + return HDF_SUCCESS; + } + } + return HDF_ERR_INVALID_PARAM; +} + +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."); + 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); + renderManage->renderDestory = false; + return HDF_FAILURE; + } + usleep(500); // sleep 500us + count++; + } + renderManage->renderPid = 0; + if (renderManage->adapter->DestroyRender(renderManage->adapter, renderManage->render)) { + renderManage->renderDestory = false; + return HDF_FAILURE; + } + renderManage->render = NULL; + renderManage->renderStatus = 0; + renderManage->renderBusy = false; + renderManage->renderDestory = false; + renderManage->renderPriority = -1; + return HDF_SUCCESS; +} + +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!"); + return HDF_FAILURE; + } + if (g_renderAndCaptureManage[which].renderPriority <= priority) { + if (AudioDestroyFormerRender(&g_renderAndCaptureManage[which])) { + HDF_LOGE("%{public}s", "AudioDestroyFormerRender: Fail."); + return HDF_FAILURE; + } + return HDF_SUCCESS; + } else { + return HDF_ERR_DEVICE_BUSY; + } + return HDF_FAILURE; +} + +int32_t AudioCreatRenderCheck(const char *adapterName, const int32_t priority) +{ + LOG_FUN_INFO(); + if (adapterName == NULL) { + return HDF_FAILURE; + } + int i; + for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { + if (!(g_renderAndCaptureManage[i].renderStatus)) { + return HDF_SUCCESS; + } else { + return AudioJudgeRenderPriority(priority, i); + } + } + } + HDF_LOGE("%{public}s", "AudioCreatRenderCheck:Can not find Adapter!"); + return HDF_FAILURE; +} + +int32_t AudioAddRenderInfoInAdapter(const char *adapterName, + struct AudioRender *render, + struct AudioAdapter *adapter, + const int32_t priority, + uint32_t renderPid) +{ + if (adapterName == NULL || adapter == NULL || render == NULL) { + HDF_LOGE("%{public}s", "AudioAddRenderInfoInAdapter: input para is NULL."); + return HDF_FAILURE; + } + int i; + for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { + g_renderAndCaptureManage[i].renderStatus = 1; + g_renderAndCaptureManage[i].renderPriority = priority; + g_renderAndCaptureManage[i].render = render; + g_renderAndCaptureManage[i].renderPid = renderPid; + return HDF_SUCCESS; + } + } + HDF_LOGE("%{public}s", "AudioAddRenderInfoInAdapter: Can not find Adapter!"); + return HDF_FAILURE; +} + +void AudioSetRenderStatus(const char *adapterName, bool renderStatus) +{ + LOG_FUN_INFO(); + if (adapterName == NULL) { + return; + } + int i; + for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { + g_renderAndCaptureManage[i].renderBusy = renderStatus; + return; + } + } + HDF_LOGE("%{public}s", "AudioDestroyRenderInfoInAdapter: Can not find Adapter!"); + return; +} + +int32_t AudioGetRenderStatus(const char *adapterName) +{ + LOG_FUN_INFO(); + if (adapterName == NULL) { + return HDF_FAILURE; + } + int i; + for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { + if (!g_renderAndCaptureManage[i].renderDestory) { + return HDF_SUCCESS; + } else { + g_renderAndCaptureManage[i].renderBusy = false; + return HDF_FAILURE; + } + } + } + HDF_LOGE("%{public}s", "AudioDestroyRenderInfoInAdapter: Can not find Adapter!"); + return HDF_FAILURE; +} + +int32_t AudioDestroyRenderInfoInAdapter(const char *adapterName) +{ + LOG_FUN_INFO(); + if (adapterName == NULL) { + return HDF_FAILURE; + } + int i; + for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { + g_renderAndCaptureManage[i].renderStatus = 0; + g_renderAndCaptureManage[i].renderPriority = -1; + g_renderAndCaptureManage[i].render = NULL; + g_renderAndCaptureManage[i].renderPid = 0; + return HDF_SUCCESS; + } + } + HDF_LOGE("%{public}s", "AudioDestroyRenderInfoInAdapter: Can not find Adapter!"); + return HDF_FAILURE; +} + +int32_t AudioAdapterListGetPid(const char *adapterName, uint32_t *pid) +{ + LOG_FUN_INFO(); + if (adapterName == NULL || pid == NULL) { + HDF_LOGE("%{public}s", "The pointer is null"); + return HDF_ERR_INVALID_PARAM; + } + int i; + for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { + HDF_LOGE("%{public}s i = %{public}d", "AudioAdapterListGetPid:", i); + *pid = g_renderAndCaptureManage[i].renderPid; + HDF_LOGE("%{public}s pid = %{public}u", "AudioAdapterListGetPid:", *pid); + return HDF_SUCCESS; + } + } + return HDF_ERR_INVALID_PARAM; +} + +int32_t AudioAdapterListGetAdapterRender(const char *adapterName, + struct AudioAdapter **adapter, struct AudioRender **render) +{ + LOG_FUN_INFO(); + if (adapterName == NULL || adapter == NULL || render == NULL) { + HDF_LOGE("%{public}s", "The pointer is null"); + return HDF_ERR_INVALID_PARAM; + } + int i; + for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { + *adapter = g_renderAndCaptureManage[i].adapter; + *render = g_renderAndCaptureManage[i].render; + return HDF_SUCCESS; + } + } + return HDF_ERR_INVALID_PARAM; +} + +int32_t AudioAdapterListGetRender(const char *adapterName, struct AudioRender **render, uint32_t pid) +{ + HDF_LOGE("%{public}s", "AudioAdapterListGetRender in"); + if (adapterName == NULL || render == NULL) { + HDF_LOGE("%{public}s", "The pointer is null"); + return HDF_ERR_INVALID_PARAM; + } + int i; + for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { + HDF_LOGE("%{public}s renderPid = %{public}u, pid = %{public}u", "AudioAdapterListGetRender", + g_renderAndCaptureManage[i].renderPid, pid); + if (g_renderAndCaptureManage[i].renderPid != pid) { + HDF_LOGE("%{public}s", "AudioAdapterListGetRender renderPid != pid"); + return HDF_ERR_INVALID_OBJECT; + } + *render = g_renderAndCaptureManage[i].render; + return HDF_SUCCESS; + } + } + return HDF_ERR_INVALID_PARAM; +} + +int32_t AudioAdapterListGetCapture(const char *adapterName, struct AudioCapture **capture, uint32_t pid) +{ + HDF_LOGE("%{public}s", "AudioAdapterListGetCapture in"); + if (adapterName == NULL || capture == NULL) { + HDF_LOGE("%{public}s", "The pointer is 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", + 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"); + return HDF_ERR_INVALID_OBJECT; + } + *capture = g_renderAndCaptureManage[i].capture; + return HDF_SUCCESS; + } + } + return HDF_ERR_INVALID_PARAM; +} + +int32_t AudioAdapterListCheckAndGetRender(struct AudioRender **render, struct HdfSBuf *data) +{ + if (render == NULL || data == NULL) { + return HDF_FAILURE; + } + struct AudioRender *renderTemp = NULL; + const char *adapterName = NULL; + uint32_t pid; + if (HdiServiceRenderCaptureReadData(data, &adapterName, &pid) < 0) { + HDF_LOGE("%{public}s", "HdiServiceRenderStart: HdiServiceRenderCaptureReadData fail"); + return HDF_FAILURE; + } + int ret = AudioAdapterListGetRender(adapterName, &renderTemp, pid); + if (ret < 0) { + return ret; + } + if (renderTemp == NULL) { + return HDF_FAILURE; + } + *render = renderTemp; + return HDF_SUCCESS; +} + +int32_t AudioAdapterListCheckAndGetCapture(struct AudioCapture **capture, struct HdfSBuf *data) +{ + if (capture == NULL || data == NULL) { + return HDF_FAILURE; + } + struct AudioCapture *captureTemp = NULL; + const char *adapterName = NULL; + uint32_t pid; + if (HdiServiceRenderCaptureReadData(data, &adapterName, &pid) < 0) { + HDF_LOGE("%{public}s", "HdiServiceCaptureStart: HdiServiceRenderCaptureReadData fail"); + return HDF_FAILURE; + } + int ret = AudioAdapterListGetCapture(adapterName, &captureTemp, pid); + if (ret < 0) { + return ret; + } + if (captureTemp == NULL) { + return HDF_FAILURE; + } + *capture = captureTemp; + return HDF_SUCCESS; +} + +int32_t AudioAdapterCheckListExist(const char *adapterName) +{ + LOG_FUN_INFO(); + if (adapterName == NULL) { + HDF_LOGE("%{public}s", "adapterName is NULL."); + return HDF_ERR_INVALID_PARAM; + } + int i; + for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { + if (g_renderAndCaptureManage[i].adapterUserNum == 0) { + return HDF_FAILURE; + } else if (g_renderAndCaptureManage[i].adapterUserNum > 0) { + g_renderAndCaptureManage[i].adapterUserNum++; + return HDF_SUCCESS; + } + } + } + return HDF_ERR_INVALID_PARAM; +} + +int32_t AudioAdapterListDestory(const char *adapterName, struct AudioAdapter **adapter) +{ + LOG_FUN_INFO(); + if (adapterName == NULL) { + HDF_LOGE("%{public}s", "adapterName is NULL."); + return HDF_ERR_INVALID_PARAM; + } + int i; + for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { + if (g_renderAndCaptureManage[i].adapterUserNum == 1) { + g_renderAndCaptureManage[i].adapterUserNum--; + *adapter = g_renderAndCaptureManage[i].adapter; + g_renderAndCaptureManage[i].adapter = NULL; + return HDF_SUCCESS; + } else if (g_renderAndCaptureManage[i].adapterUserNum > 1) { + g_renderAndCaptureManage[i].adapterUserNum--; + return HDF_FAILURE; + } + } + } + return HDF_ERR_INVALID_PARAM; +} + +int32_t AudioAdapterListAdd(const char *adapterName, struct AudioAdapter *adapter) +{ + LOG_FUN_INFO(); + if (adapterName == NULL || adapter == NULL) { + HDF_LOGE("%{public}s", "adapterName is NULL."); + return HDF_ERR_INVALID_PARAM; + } + int i; + for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { + g_renderAndCaptureManage[i].adapter = adapter; + g_renderAndCaptureManage[i].adapterUserNum = 1; + return HDF_SUCCESS; + } + } + return HDF_ERR_INVALID_PARAM; +} + +void AudioSetCaptureStatus(const char *adapterName, bool captureStatus) +{ + LOG_FUN_INFO(); + if (adapterName == NULL) { + return; + } + int i; + for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { + g_renderAndCaptureManage[i].captureBusy = captureStatus; + return; + } + } + HDF_LOGE("%{public}s", "AudioSetCaptureStatus: Can not find Adapter!"); + return; +} + +int32_t AudioGetCaptureStatus(const char *adapterName) +{ + LOG_FUN_INFO(); + if (adapterName == NULL) { + return HDF_FAILURE; + } + int i; + for (i = 0; i < MAX_AUDIO_ADAPTER_NUM_SERVER; i++) { + if (!strcmp(g_renderAndCaptureManage[i].adapterName, adapterName)) { + if (!g_renderAndCaptureManage[i].captureDestory) { + return HDF_SUCCESS; + } else { + g_renderAndCaptureManage[i].captureBusy = false; + return HDF_FAILURE; + } + } + } + HDF_LOGE("%{public}s", "AudioGetCaptureStatus: Can not find Adapter!"); + return HDF_FAILURE; +} + 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 new file mode 100755 index 0000000000000000000000000000000000000000..135d769872ebacf3e716f782c3044dcdacd16dd7 --- /dev/null +++ b/audio/hal/hdi_binder/server/src/hdf_audio_server_render.c @@ -0,0 +1,749 @@ +/* + * 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 "hdf_audio_server_render.h" + +int32_t GetInitRenderParaAttrs(struct HdfSBuf *data, struct AudioSampleAttributes *attrs) +{ + if (data == NULL || attrs == NULL) { + return HDF_FAILURE; + } + uint32_t tempRenderPara = 0; + if (!HdfSbufReadUint32(data, &tempRenderPara)) { + HDF_LOGE("%{public}s", " read buf fail"); + return HDF_FAILURE; + } + attrs->type = (enum AudioCategory)tempRenderPara; + if (!HdfSbufReadUint32(data, &attrs->period)) { + HDF_LOGE("%{public}s", " read buf fail"); + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &attrs->frameSize)) { + HDF_LOGE("%{public}s", " read buf fail"); + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &attrs->startThreshold)) { + HDF_LOGE("%{public}s", " read buf fail"); + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &attrs->stopThreshold)) { + HDF_LOGE("%{public}s", " read buf fail"); + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &attrs->silenceThreshold)) { + HDF_LOGE("%{public}s", " read buf fail"); + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &tempRenderPara)) { + LOG_FUN_ERR("Failed to Get Speed sBuf!"); + return HDF_FAILURE; + } + attrs->isBigEndian = (bool)tempRenderPara; + return HDF_SUCCESS; +} + +int32_t GetInitRenderPara(struct HdfSBuf *data, struct AudioDeviceDescriptor *devDesc, + struct AudioSampleAttributes *attrs) +{ + if (data == NULL || devDesc == NULL || attrs == NULL) { + return HDF_FAILURE; + } + uint32_t tempRenderPara = 0; + if (!HdfSbufReadUint32(data, &tempRenderPara)) { + LOG_FUN_ERR("Failed to Get Speed sBuf!"); + return HDF_FAILURE; + } + attrs->format = (enum AudioFormat)tempRenderPara; + if (!HdfSbufReadUint32(data, &attrs->channelCount)) { + HDF_LOGE("%{public}s", " read buf fail"); + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &attrs->sampleRate)) { + HDF_LOGE("%{public}s", " read buf fail"); + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &tempRenderPara)) { + LOG_FUN_ERR("Failed to Get Speed sBuf!"); + return HDF_FAILURE; + } + attrs->interleaved = (bool)tempRenderPara; + if (GetInitRenderParaAttrs(data, attrs) < 0) { + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &tempRenderPara)) { + LOG_FUN_ERR("Failed to Get Speed sBuf!"); + return HDF_FAILURE; + } + attrs->isSignedData = (bool)tempRenderPara; + if (!HdfSbufReadUint32(data, &devDesc->portId)) { + HDF_LOGE("%{public}s", " read buf fail"); + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &tempRenderPara)) { + HDF_LOGE("%{public}s", " read buf fail"); + return HDF_FAILURE; + } + devDesc->pins = (enum AudioPortPin)tempRenderPara; + devDesc->desc = NULL; + return HDF_SUCCESS; +} + +int32_t HdiServiceCreatRender(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + struct AudioAdapter *adapter = NULL; + struct AudioDeviceDescriptor devDesc; + struct AudioSampleAttributes attrs; + struct AudioRender *render = NULL; + const char *adapterName = NULL; + uint32_t renderPid; + if ((adapterName = HdfSbufReadString(data)) == NULL) { + HDF_LOGE("%{public}s", "adapterNameCase Is NULL"); + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &renderPid)) { + return HDF_FAILURE; + } + HDF_LOGE("%{public}s, renderPid = %{public}u", "HdiServiceCreatRender:", renderPid); + int32_t ret = GetInitRenderPara(data, &devDesc, &attrs); + if (ret < 0) { + HDF_LOGE("%{public}s", " GetInitRenderPara fail"); + return HDF_FAILURE; + } + if (AudioAdapterListGetAdapter(adapterName, &adapter)) { + HDF_LOGE("%{public}s", "AudioAdapterListGetAdapter fail"); + return HDF_FAILURE; + } + if (adapter == NULL) { + HDF_LOGE("%{public}s", "HdiServiceCreatRender adapter is NULL!"); + 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!"); + return ret; + } + ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render); + if (render == NULL || ret < 0) { + HDF_LOGE("%{public}s", "Failed to CreateRender"); + return HDF_FAILURE; + } + if (AudioAddRenderInfoInAdapter(adapterName, render, adapter, priority, renderPid)) { + HDF_LOGE("%{public}s", "AudioAddRenderInfoInAdapter"); + adapter->DestroyRender(adapter, render); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t HdiServiceRenderDestory(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + struct AudioAdapter *adapter = NULL; + struct AudioRender *render = NULL; + const char *adapterName = NULL; + uint32_t pid; + if (HdiServiceRenderCaptureReadData(data, &adapterName, &pid) < 0) { + return HDF_FAILURE; + } + int32_t ret = AudioAdapterListGetRender(adapterName, &render, pid); + if (ret < 0) { + return ret; + } + ret = AudioAdapterListGetAdapterRender(adapterName, &adapter, &render); + if (ret < 0) { + return ret; + } + if (adapter == NULL || render == NULL) { + return HDF_FAILURE; + } + ret = adapter->DestroyRender(adapter, render); + if (ret < 0) { + HDF_LOGE("%{public}s", "DestroyRender failed!"); + return ret; + } + if (AudioDestroyRenderInfoInAdapter(adapterName)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t HdiServiceRenderStart(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; + } + return render->control.Start((AudioHandle)render); +} + +int32_t HdiServiceRenderStop(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; + } + return render->control.Stop((AudioHandle)render); +} + +int32_t HdiServiceRenderPause(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + HDF_LOGE("%{public}s", "enter to HdiServiceRenderPause "); + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + return render->control.Pause((AudioHandle)render); +} + +int32_t HdiServiceRenderResume(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; + } + return render->control.Resume((AudioHandle)render); +} + +int32_t HdiServiceRenderFlush(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; + } + return render->control.Flush((AudioHandle)render); +} + +int32_t HdiServiceRenderGetFrameSize(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + uint64_t size; + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + if (render->attr.GetFrameSize((AudioHandle)render, &size)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint64(reply, size)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t HdiServiceRenderGetFrameCount(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + uint64_t count; + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + if (render->attr.GetFrameCount((AudioHandle)render, &count)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint64(reply, count)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t HdiServiceRenderSetSampleAttr(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + struct AudioSampleAttributes attrs; + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + if (ReadAudioSapmleAttrbutes(data, &attrs) < 0) { + return HDF_FAILURE; + } + return render->attr.SetSampleAttributes((AudioHandle)render, &attrs); +} + +int32_t HdiServiceRenderGetSampleAttr(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + struct AudioSampleAttributes attrs; + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + ret = render->attr.GetSampleAttributes((AudioHandle)render, &attrs); + if (ret < 0) { + return ret; + } + if (WriteAudioSampleAttributes(reply, &attrs) < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t HdiServiceRenderGetCurChannelId(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + uint32_t channelId; + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + ret = render->attr.GetCurrentChannelId((AudioHandle)render, &channelId); + if (ret < 0) { + return ret; + } + if (!HdfSbufWriteUint32(reply, channelId)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t HdiServiceRenderCheckSceneCapability(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + struct AudioSceneDescriptor scene; + bool supported = false; + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + if (!HdfSbufReadUint32(data, &scene.scene.id)) { + return HDF_FAILURE; + } + uint32_t tempPins = 0; + if (!HdfSbufReadUint32(data, &tempPins)) { + return HDF_FAILURE; + } + scene.desc.pins = (enum AudioPortPin)tempPins; + ret = render->scene.CheckSceneCapability((AudioHandle)render, &scene, &supported); + if (ret < 0) { + return ret; + } + uint32_t tempSupported = (uint32_t)supported; + if (!HdfSbufWriteUint32(reply, tempSupported)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t HdiServiceRenderSelectScene(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + struct AudioSceneDescriptor scene; + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + if (!HdfSbufReadUint32(data, &scene.scene.id)) { + return HDF_FAILURE; + } + uint32_t tempPins = 0; + if (!HdfSbufReadUint32(data, &tempPins)) { + return HDF_FAILURE; + } + scene.desc.pins = (enum AudioPortPin)tempPins; + return render->scene.SelectScene((AudioHandle)render, &scene); +} + +int32_t HdiServiceRenderGetMute(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + bool mute = false; + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + ret = render->volume.GetMute((AudioHandle)render, &mute); + if (ret < 0) { + return ret; + } + uint32_t tempMute = (uint32_t)mute; + if (!HdfSbufWriteUint32(reply, tempMute)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t HdiServiceRenderSetMute(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + bool mute = false; + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + uint32_t tempMute = 0; + if (!HdfSbufReadUint32(data, &tempMute)) { + return HDF_FAILURE; + } + mute = (bool)tempMute; + return render->volume.SetMute((AudioHandle)render, mute); +} + +int32_t HdiServiceRenderSetVolume(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + uint32_t volume; + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + if (!HdfSbufReadUint32(data, &volume)) { + return HDF_FAILURE; + } + float setVolume = (float)volume / VOLUME_CHANGE; + return render->volume.SetVolume((AudioHandle)render, setVolume); +} + +int32_t HdiServiceRenderGetVolume(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + float volume; + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + ret = render->volume.GetVolume((AudioHandle)render, &volume); + if (ret < 0) { + return ret; + } + uint32_t tempVolume = (uint32_t)(volume * VOLUME_CHANGE); + if (!HdfSbufWriteUint32(reply, tempVolume)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t HdiServiceRenderGetGainThreshold(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + float min, max; + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + ret = render->volume.GetGainThreshold((AudioHandle)render, &min, &max); + if (ret < 0) { + return ret; + } + uint32_t tempMin = (uint32_t)min; + if (!HdfSbufWriteUint32(reply, tempMin)) { + return HDF_FAILURE; + } + uint32_t tempMax = (uint32_t)max; + if (!HdfSbufWriteUint32(reply, tempMax)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t HdiServiceRenderGetGain(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + float gain; + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + ret = render->volume.GetGain((AudioHandle)render, &gain); + if (ret < 0) { + return ret; + } + uint32_t tempGain = (uint32_t)gain; + if (!HdfSbufWriteUint32(reply, tempGain)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t HdiServiceRenderSetGain(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + uint32_t tempGain; + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + if (!HdfSbufReadUint32(data, &tempGain)) { + return HDF_FAILURE; + } + return render->volume.SetGain((AudioHandle)render, (float)tempGain); +} + +int32_t HdiServiceRenderGetLatency(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + uint32_t ms; + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + ret = render->GetLatency((AudioHandle)render, &ms); + if (ret < 0) { + return ret; + } + if (!HdfSbufWriteUint32(reply, ms)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t HdiServiceRenderRenderFrame(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + HDF_LOGI("%{public}s", "HdiServiceRenderRenderFrame entry!"); + char *frame = NULL; + uint32_t requestBytes; + uint64_t replyBytes; + struct AudioRender *render = NULL; + const char *adapterName = NULL; + uint32_t pid; + if (HdiServiceRenderCaptureReadData(data, &adapterName, &pid) < 0) { + HDF_LOGE("%{public}s", "HdiServiceRenderRenderFrame:HdiServiceRenderCaptureReadData fail!"); + return HDF_FAILURE; + } + int32_t ret = AudioAdapterListGetRender(adapterName, &render, pid); + if (ret < 0) { + HDF_LOGE("%{public}s", "HdiServiceRenderRenderFrame:AudioAdapterListGetRender fail"); + return ret; + } + ret = AudioGetRenderStatus(adapterName); + if (ret < 0) { + HDF_LOGE("%{public}s", "HdiServiceRenderRenderFrame:AudioGetRenderStatus fail"); + return ret; + } + if (!HdfSbufReadBuffer(data, (const void **)&frame, &requestBytes)) { + HDF_LOGE("%{public}s", "AudioAdapterListGetRender:HdfSbufReadBuffer fail"); + 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); + if (ret < 0) { + HDF_LOGE("%{public}s ", "HdiServiceRenderRenderFrame:HdiServiceRenderRenderFrame"); + return ret; + } + return HDF_SUCCESS; +} + +int32_t HdiServiceRenderGetRenderPosition(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + 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 (!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; +} + +int32_t HdiServiceRenderGetSpeed(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + float speed; + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + ret = render->GetRenderSpeed((AudioHandle)render, &speed); + if (ret < 0) { + return ret; + } + uint64_t tempSpeed = (uint64_t)speed; + if (!HdfSbufWriteUint64(reply, tempSpeed)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t HdiServiceRenderSetSpeed(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + uint64_t speed; + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + if (!HdfSbufReadUint64(data, &speed)) { + return HDF_FAILURE; + } + return render->SetRenderSpeed((AudioHandle)render, (float)speed); +} + +int32_t HdiServiceRenderSetChannelMode(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + enum AudioChannelMode mode; + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + uint32_t tempMode = 0; + if (!HdfSbufReadUint32(data, &tempMode)) { + return HDF_FAILURE; + } + mode = (enum AudioChannelMode)tempMode; + return render->SetChannelMode((AudioHandle)render, mode); +} + +int32_t HdiServiceRenderGetChannelMode(struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + HDF_LOGE("%{public}s", "HdiServiceRenderGetChannelMode in"); + if (client == NULL || data == NULL || reply == NULL) { + return HDF_FAILURE; + } + enum AudioChannelMode mode; + struct AudioRender *render = NULL; + int ret = AudioAdapterListCheckAndGetRender(&render, data); + if (ret < 0) { + return ret; + } + ret = render->GetChannelMode((AudioHandle)render, &mode); + if (ret < 0) { + return ret; + } + uint32_t tempMode = (uint32_t)mode; + if (!HdfSbufWriteUint32(reply, tempMode)) { + return HDF_FAILURE; + } + HDF_LOGE("%{public}s", "HdiServiceRenderGetChannelMode out"); + return HDF_SUCCESS; +} + diff --git a/audio/hal/hdi_passthrough/include/audio_adapter_info_common.h b/audio/hal/hdi_passthrough/include/audio_adapter_info_common.h new file mode 100755 index 0000000000000000000000000000000000000000..2d1e15c0db6eec143617909f72cdabc3bbcbc53e --- /dev/null +++ b/audio/hal/hdi_passthrough/include/audio_adapter_info_common.h @@ -0,0 +1,38 @@ +/* + * 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_ADAPTER_INFO_COMMON_H +#define AUDIO_ADAPTER_INFO_COMMON_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "securec.h" +#include "audio_types.h" + +struct AudioAdapterDescriptor *AudioAdapterGetConfigOut(void); +struct AudioAdapterDescriptor *AudioAdapterGetConfigDescs(void); +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); +#endif diff --git a/audio/hal/hdi_passthrough/include/audio_common.h b/audio/hal/hdi_passthrough/include/audio_common.h new file mode 100755 index 0000000000000000000000000000000000000000..727f119d75efd1da3afa975e44a9a6282c8f611b --- /dev/null +++ b/audio/hal/hdi_passthrough/include/audio_common.h @@ -0,0 +1,36 @@ +/* + * 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_COMMON_H +#define AUDIO_COMMON_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "securec.h" + +void AudioDlClose(void **ppHandleSo); +void AudioMemFree(void **ppMem); +int32_t AudioGetSysTime(char *s, int32_t len); +int32_t AudioCheckParaAttr(const struct AudioSampleAttributes *attrs); + +#endif diff --git a/audio/hal/hdi_passthrough/include/audio_internal.h b/audio/hal/hdi_passthrough/include/audio_internal.h new file mode 100755 index 0000000000000000000000000000000000000000..faa456b70188388bb4f147f4e225d8c6ed7ea6fa --- /dev/null +++ b/audio/hal/hdi_passthrough/include/audio_internal.h @@ -0,0 +1,405 @@ +/* + * 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_INTERNAL_H +#define AUDIO_INTERNAL_H + +#include +#include "audio_manager.h" +#include "audio_common.h" +#include "hdf_base.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define LOG_ENABLE 0 +#define LOGV_ENABLE 0 +#define NAME_LEN 64 +#define BIT_NUM_32 32 +#define BIT_NUM_24 24 +#define BIT_NUM_16 16 +#define BIT_NUM_8 8 +#define PERIOD_SIZE 1024 +#define PERIOD_COUNT 2 +#define FRAME_DATA (8192 * 2) +#define PATHPLAN_LEN 64 +#define PATHPLAN_COUNT 32 +#define PATH_NAME_LEN 128 +#define VOLUME_CHANGE 100 +#define SEC_TO_NSEC 1000000000 +#define HDMI_PORT_ID 12 + +#ifndef LOGE + #define LOGE(fmt, arg...) printf("[Audio:E]" fmt "\n", ##arg) +#endif +#ifndef LOGI + #define LOGI(fmt, arg...) printf("[Audio:I]" fmt "\n", ##arg) +#endif +#ifndef LOGV + #define LOGV(fmt, arg...) printf("[Audio:V]" fmt "\n", ##arg) +#endif + +#if !LOG_ENABLE + #undef LOGE + #undef LOGI + #undef LOGV + + #define LOGE(...) + #define LOGI(...) + #define LOGV(...) +#else + #if !LOGV_ENABLE + #undef LOGV + #define LOGV(...) + #endif // !LOGV_ENABLE +#endif // LOG_ENABLE + +#ifndef UNUSED + #define UNUSED(x) ((void)(x)) +#endif + +#ifndef UT_TEST + #define STATIC_T static +#else + #define STATIC_T +#endif + +#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" + +#ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT +#define SO_CJSON_LIB_PATHSELECT_PATH "/system/lib/libhdi_audio_path_select.z.so" +#endif + +#define USECASE_AUDIO_RENDER_DEEP_BUFFER "deep-buffer-render" +#define USECASE_AUDIO_RENDER_LOW_LATENCY "low-latency-render" + +#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 OPEN_AUDIO_LOG_WITH_TIME 1 +#define MAX_TIME_INFO_LEN 64 + +#ifndef OPEN_AUDIO_LOG_WITH_TIME +#define LOG_FUN_INFO() do { \ + printf("%s: [%s]: [%d]\n", __FILE__, __func__, __LINE__); \ + } while (0) + +#define LOG_FUN_ERR(fmt, arg...) do { \ + printf("%s: [%s]: [%d]:[ERROR]:" fmt"\n", __FILE__, __func__, __LINE__, ##arg); \ + } while (0) + +#define LOG_PARA_INFO(fmt, arg...) do { \ + printf("%s: [%s]: [%d]:[INFO]:" fmt"\n", __FILE__, __func__, __LINE__, ##arg); \ + } while (0) +#else +#define LOG_FUN_INFO() do { \ + } while (0) + +#define LOG_FUN_ERR(fmt, arg...) do { \ + char s[MAX_TIME_INFO_LEN] = {0}; \ + AudioGetSysTime(s, MAX_TIME_INFO_LEN); \ + printf("%s %s: [%s]: [%d]:[ERROR]:" fmt"\n", s, __FILE__, __func__, __LINE__, ##arg); \ + } while (0) + +#define LOG_PARA_INFO(fmt, arg...) do { \ + } while (0) +#endif + +struct DevHandleCapture { + void *object; +}; + +struct DevHandle { + void *object; +}; + +struct AudioPortAndCapability { + struct AudioPort port; + struct AudioPortCapability capability; + enum AudioPortPassthroughMode mode; +}; + +struct AudioHwAdapter { + struct AudioAdapter common; + struct AudioAdapterDescriptor adapterDescriptor; + struct AudioPortAndCapability *portCapabilitys; +}; + +struct AudioFrameRenderMode { + uint64_t frames; + struct AudioTimeStamp time; + struct AudioSampleAttributes attrs; + enum AudioChannelMode mode; + uint32_t byteRate; + uint32_t periodSize; + uint32_t periodCount; + uint32_t startThreshold; + uint32_t stopThreshold; + uint32_t silenceThreshold; + uint32_t silenceSize; + char *buffer; + uint64_t bufferFrameSize; + uint64_t bufferSize; +}; + +struct AudioGain { + float gain; + float gainMin; + float gainMax; +}; + +struct AudioVol { + int volMin; + int volMax; +}; + +struct AudioCtlParam { + bool mute; + float volume; + float speed; + bool pause; + struct AudioVol volThreshold; + struct AudioGain audioGain; +}; + +enum PathRoute { + DEEP_BUFF = 0, + RECORD, + RECORD_LOW_LATRNCY, + LOW_LATRNCY, +}; + +struct PathPlan { + char pathPlanName[PATHPLAN_LEN]; + int value; +}; + +struct PathDeviceSwitch { + char deviceSwitch[PATHPLAN_LEN]; + int32_t value; +}; + +struct PathDeviceInfo { + char deviceType[NAME_LEN]; + int32_t deviceNum; + struct PathDeviceSwitch deviceSwitchs[PATHPLAN_COUNT]; +}; + +struct PathSelect { + char useCase[NAME_LEN]; + struct PathDeviceInfo deviceInfo; + int useCaseDeviceNum; + struct PathPlan pathPlan[PATHPLAN_COUNT]; +}; + +struct HwInfo { + uint32_t card; + uint32_t device; + int flags; + char adapterName[NAME_LEN]; + struct AudioPort portDescript; + struct AudioDeviceDescriptor deviceDescript; + enum PathRoute pathroute; + struct PathSelect pathSelect; +}; + +struct AudioHwRenderMode { + struct AudioCtlParam ctlParam; + struct HwInfo hwInfo; +}; + +struct AudioHwRenderParam { + struct AudioHwRenderMode renderMode; + struct AudioFrameRenderMode frameRenderMode; +}; + +struct AudioHwRender { + struct AudioRender common; + struct AudioHwRenderParam renderParam; + struct DevHandle *devDataHandle; // Bind Data handle + struct DevHandle *devCtlHandle; // Bind Ctl handle +}; + +struct AudioHwCaptureMode { + struct AudioCtlParam ctlParam; + struct HwInfo hwInfo; +}; + +struct AudioFrameCaptureMode { + uint64_t frames; + struct AudioTimeStamp time; + struct AudioSampleAttributes attrs; + enum AudioChannelMode mode; + uint32_t byteRate; + uint32_t periodSize; + uint32_t periodCount; + uint32_t startThreshold; + uint32_t stopThreshold; + uint32_t silenceThreshold; + uint32_t silenceSize; + char *buffer; + uint64_t bufferFrameSize; + uint64_t bufferSize; +}; + +struct AudioHwCaptureParam { + struct AudioHwCaptureMode captureMode; + struct AudioFrameCaptureMode frameCaptureMode; +}; + +struct AudioHwCapture { + struct AudioCapture common; + struct AudioHwCaptureParam captureParam; + struct DevHandleCapture *devDataHandle; // Bind Data handle + struct DevHandleCapture *devCtlHandle; // Bind Ctl handle +}; + +enum AudioAdaptType { + INVAILD_PATH_SELECT = -1, + RENDER_PATH_SELECT, + CAPTURE_PATH_SELECT, + CHECKSCENE_PATH_SELECT, + CHECKSCENE_PATH_SELECT_CAPTURE, +}; + +enum AudioServiceNameType { + AUDIO_SERVICE_IN = 0, + AUDIO_SERVICE_OUT, + AUDIO_SERVICE_MAX, +}; + +/* dispatch cmdId */ +enum AudioInterfaceLibParaCmdList { + AUDIO_DRV_PCM_IOCTL_HW_PARAMS = 0, + AUDIO_DRV_PCM_IOCTL_PREPARE, + AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE, + AUDIO_DRV_PCM_IOCTL_WRITE, + AUDIO_DRV_PCM_IOCTL_READ, + AUDIO_DRV_PCM_IOCTRL_START, + AUDIO_DRV_PCM_IOCTRL_STOP, + AUDIO_DRV_PCM_IOCTRL_START_CAPTURE, + AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE, + AUDIO_DRV_PCM_IOCTRL_PAUSE, + AUDIO_DRV_PCM_IOCTRL_PAUSE_CAPTURE, + AUDIO_DRV_PCM_IOCTRL_RESUME, + AUDIO_DRV_PCM_IOCTRL_RESUME_CAPTURE, + AUDIO_DRV_PCM_IOCTL_BUTT, +}; + +enum AudioStreamType { + AUDIO_CAPTURE_STREAM = 0, + AUDIO_RENDER_STREAM, +}; + +typedef struct DevHandle *(*BindServiceRenderSo)(const char *); +typedef int32_t (*InterfaceLibModeRenderSo)(struct DevHandle *, struct AudioHwRenderParam *, int); +typedef void(*CloseServiceRenderSo)(struct DevHandle *); + +typedef struct DevHandleCapture *(*BindServiceCaptureSo)(const char *); +typedef int32_t (*InterfaceLibModeCaptureSo)(struct DevHandleCapture *, struct AudioHwCaptureParam *, int); +typedef void(*CloseServiceCaptureSo)(struct DevHandleCapture *); + +typedef int32_t (*PathSelGetConfToJsonObj)(); +typedef int32_t (*PathSelAnalysisJson)(void *adapterParam, enum AudioAdaptType adaptType); + +BindServiceRenderSo *AudioSoGetBindServiceRender(); +InterfaceLibModeRenderSo *AudioSoGetInterfaceLibModeRender(); +CloseServiceRenderSo *AudioSoGetCloseServiceRender(); + +BindServiceCaptureSo *AudioSoGetBindServiceCapture(); +InterfaceLibModeCaptureSo *AudioSoGetInterfaceLibModeCapture(); +CloseServiceCaptureSo *AudioSoGetCloseServiceCapture(); + +#ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT +PathSelGetConfToJsonObj *AudioSoGetPathSelGetConfToJsonObj(); +PathSelAnalysisJson *AudioSoGetPathSelAnalysisJson(); +#endif + +int32_t AudioAdapterInitAllPorts(struct AudioAdapter *adapter); +int32_t AudioAdapterCreateRender(struct AudioAdapter *adapter, const struct AudioDeviceDescriptor *desc, + const struct AudioSampleAttributes *attrs, struct AudioRender **render); +int32_t AudioAdapterDestroyRender(struct AudioAdapter *adapter, struct AudioRender *render); +int32_t AudioAdapterCreateCapture(struct AudioAdapter *adapter, const struct AudioDeviceDescriptor *desc, + const struct AudioSampleAttributes *attrs, struct AudioCapture **capture); +int32_t AudioAdapterDestroyCapture(struct AudioAdapter *adapter, struct AudioCapture *capture); +int32_t AudioAdapterGetPortCapability(struct AudioAdapter *adapter, const struct AudioPort *port, + struct AudioPortCapability *capability); +int32_t AudioAdapterSetPassthroughMode(struct AudioAdapter *adapter, const struct AudioPort *port, + enum AudioPortPassthroughMode mode); +int32_t AudioAdapterGetPassthroughMode(struct AudioAdapter *adapter, const struct AudioPort *port, + enum AudioPortPassthroughMode *mode); +int32_t AudioRenderStart(AudioHandle handle); +int32_t AudioRenderStop(AudioHandle handle); +int32_t AudioRenderPause(AudioHandle handle); +int32_t AudioRenderResume(AudioHandle handle); +int32_t AudioRenderFlush(AudioHandle handle); +int32_t AudioRenderGetFrameSize(AudioHandle handle, uint64_t *size); +int32_t AudioRenderGetFrameCount(AudioHandle handle, uint64_t *count); +int32_t AudioRenderSetSampleAttributes(AudioHandle handle, const struct AudioSampleAttributes *attrs); +int32_t AudioRenderGetSampleAttributes(AudioHandle handle, struct AudioSampleAttributes *attrs); +int32_t AudioRenderGetCurrentChannelId(AudioHandle handle, uint32_t *channelId); +int32_t AudioRenderCheckSceneCapability(AudioHandle handle, const struct AudioSceneDescriptor *scene, + bool *supported); +int32_t AudioRenderSelectScene(AudioHandle handle, const struct AudioSceneDescriptor *scene); +int32_t AudioRenderSetMute(AudioHandle handle, bool mute); +int32_t AudioRenderGetMute(AudioHandle handle, bool *mute); +int32_t AudioRenderSetVolume(AudioHandle handle, float volume); +int32_t AudioRenderGetVolume(AudioHandle handle, float *volume); +int32_t AudioRenderGetGainThreshold(AudioHandle handle, float *min, float *max); +int32_t AudioRenderGetGain(AudioHandle handle, float *gain); +int32_t AudioRenderSetGain(AudioHandle handle, float gain); +int32_t AudioRenderGetLatency(struct AudioRender *render, uint32_t *ms); +int32_t AudioRenderRenderFrame(struct AudioRender *render, const void *frame, + uint64_t requestBytes, uint64_t *replyBytes); +int32_t AudioRenderGetRenderPosition(struct AudioRender *render, uint64_t *frames, struct AudioTimeStamp *time); +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 AudioCaptureStart(AudioHandle handle); +int32_t AudioCaptureStop(AudioHandle handle); +int32_t AudioCapturePause(AudioHandle handle); +int32_t AudioCaptureResume(AudioHandle handle); +int32_t AudioCaptureFlush(AudioHandle handle); +int32_t AudioCaptureGetFrameSize(AudioHandle handle, uint64_t *size); +int32_t AudioCaptureGetFrameCount(AudioHandle handle, uint64_t *count); +int32_t AudioCaptureSetSampleAttributes(AudioHandle handle, const struct AudioSampleAttributes *attrs); +int32_t AudioCaptureGetSampleAttributes(AudioHandle handle, struct AudioSampleAttributes *attrs); +int32_t AudioCaptureGetCurrentChannelId(AudioHandle handle, uint32_t *channelId); +int32_t AudioCaptureCheckSceneCapability(AudioHandle handle, const struct AudioSceneDescriptor *scene, + bool *supported); +int32_t AudioCaptureSelectScene(AudioHandle handle, const struct AudioSceneDescriptor *scene); +int32_t AudioCaptureSetMute(AudioHandle handle, bool mute); +int32_t AudioCaptureGetMute(AudioHandle handle, bool *mute); +int32_t AudioCaptureSetVolume(AudioHandle handle, float volume); +int32_t AudioCaptureGetVolume(AudioHandle handle, float *volume); +int32_t AudioCaptureGetGainThreshold(AudioHandle handle, float *min, float *max); +int32_t AudioCaptureGetGain(AudioHandle handle, float *gain); +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); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/audio/hal/hdi_passthrough/src/BUILD.gn b/audio/hal/hdi_passthrough/src/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..da21ce1e24a55a8468464daccd86a2af18d0f867 --- /dev/null +++ b/audio/hal/hdi_passthrough/src/BUILD.gn @@ -0,0 +1,111 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +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" ] +} + +ohos_shared_library("hdi_audio") { + 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", + ] + + 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" ] + } + + 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" +} diff --git a/audio/hal/hdi_passthrough/src/adapter_config.json b/audio/hal/hdi_passthrough/src/adapter_config.json new file mode 100755 index 0000000000000000000000000000000000000000..c7db261eb4866d4438541cbb3602167d35773195 --- /dev/null +++ b/audio/hal/hdi_passthrough/src/adapter_config.json @@ -0,0 +1,45 @@ +{ + "adapterNum": 3, + "adapters": [{ + "name": "internal", + "portnum": 2, + "port": [{ + "dir": "PORT_OUT", + "id": 0, + "name": "AOP" + }, + { + "dir": "PORT_IN", + "id": 0, + "name": "AIP" + }] + }, + { + "name": "usb", + "portnum": 3, + "port": [{ + "dir": "PORT_OUT", + "id": 0, + "name": "AOP" + }, + { + "dir": "PORT_IN", + "id": 0, + "name": "AIP" + }, + { + "dir": "PORT_OUT_IN", + "id": 0, + "name": "AIOP" + }] + }, + { + "name": "hdmi", + "portnum": 1, + "port": [{ + "dir": "PORT_OUT", + "id": 12, + "name": "AOP" + }] + }] +} \ No newline at end of file diff --git a/audio/hal/hdi_passthrough/src/audio_adapter.c b/audio/hal/hdi_passthrough/src/audio_adapter.c new file mode 100755 index 0000000000000000000000000000000000000000..a9843ed571e8e8d2bd4ca1234c998a0088e1ecb2 --- /dev/null +++ b/audio/hal/hdi_passthrough/src/audio_adapter.c @@ -0,0 +1,873 @@ +/* + * 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_internal.h" +#include "audio_adapter.h" +#include "audio_interface_lib_capture.h" +#include "audio_interface_lib_render.h" + +#define CONFIG_CHANNEL_COUNT 2 // two channels +#define GAIN_MAX 50.0 +#define AUDIO_SERVICE_PORTID_FLAG 10 +#define DEFAULT_RENDER_SAMPLING_RATE 48000 +#define DEEP_BUFFER_RENDER_PERIOD_SIZE 4096 +#define DEEP_BUFFER_RENDER_PERIOD_COUNT 8 +#define TYPE_RENDER "Render" +#define TYPE_CAPTURE "Capture" +#define INT_32_MAX 0x7fffffff +#define SHIFT_RIGHT_31_BITS 31 + +int32_t GetAudioRenderFunc(struct AudioHwRender *hwRender) +{ + if (hwRender == NULL) { + return HDF_FAILURE; + } + hwRender->common.control.Start = AudioRenderStart; + hwRender->common.control.Stop = AudioRenderStop; + hwRender->common.control.Pause = AudioRenderPause; + hwRender->common.control.Resume = AudioRenderResume; + hwRender->common.control.Flush = AudioRenderFlush; + 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.scene.CheckSceneCapability = AudioRenderCheckSceneCapability; + hwRender->common.scene.SelectScene = AudioRenderSelectScene; + hwRender->common.volume.SetMute = AudioRenderSetMute; + hwRender->common.volume.GetMute = AudioRenderGetMute; + hwRender->common.volume.SetVolume = AudioRenderSetVolume; + hwRender->common.volume.GetVolume = AudioRenderGetVolume; + hwRender->common.volume.GetGainThreshold = AudioRenderGetGainThreshold; + hwRender->common.volume.GetGain = AudioRenderGetGain; + hwRender->common.volume.SetGain = AudioRenderSetGain; + hwRender->common.GetLatency = AudioRenderGetLatency; + hwRender->common.RenderFrame = AudioRenderRenderFrame; + hwRender->common.GetRenderPosition = AudioRenderGetRenderPosition; + hwRender->common.SetRenderSpeed = AudioRenderSetRenderSpeed; + hwRender->common.GetRenderSpeed = AudioRenderGetRenderSpeed; + hwRender->common.SetChannelMode = AudioRenderSetChannelMode; + hwRender->common.GetChannelMode = AudioRenderGetChannelMode; + return HDF_SUCCESS; +} + +int32_t CheckParaDesc(const struct AudioDeviceDescriptor *desc, const char *type) +{ + if (NULL == desc || NULL == type) { + return HDF_FAILURE; + } + if ((desc->portId) >> SHIFT_RIGHT_31_BITS) { + return HDF_ERR_NOT_SUPPORT; + } + enum AudioPortPin pins = desc->pins; + if (!strcmp(type, TYPE_CAPTURE)) { + if (pins == PIN_IN_MIC || pins == PIN_IN_HS_MIC || pins == PIN_IN_LINEIN) { + return HDF_SUCCESS; + } else { + return HDF_ERR_NOT_SUPPORT; + } + } else if (!strcmp(type, TYPE_RENDER)) { + if (pins == PIN_OUT_SPEAKER || pins == PIN_OUT_HEADSET || pins == PIN_OUT_LINEOUT || pins == PIN_OUT_HDMI) { + return HDF_SUCCESS; + } else { + return HDF_ERR_NOT_SUPPORT; + } + } + return HDF_FAILURE; +} + +int32_t CheckParaAttr(const struct AudioSampleAttributes *attrs) +{ + if (NULL == attrs) { + return HDF_FAILURE; + } + int32_t ret = ((attrs->sampleRate) >> SHIFT_RIGHT_31_BITS) + ((attrs->channelCount) >> SHIFT_RIGHT_31_BITS) + + ((attrs->period) >> SHIFT_RIGHT_31_BITS) + ((attrs->frameSize) >> SHIFT_RIGHT_31_BITS) + + ((attrs->startThreshold) >> SHIFT_RIGHT_31_BITS) + ((attrs->stopThreshold) >> SHIFT_RIGHT_31_BITS) + + ((attrs->silenceThreshold) >> SHIFT_RIGHT_31_BITS); + if (ret > 0) { + return HDF_ERR_NOT_SUPPORT; + } + enum AudioCategory audioCategory = attrs->type; + if (AUDIO_IN_MEDIA != audioCategory && AUDIO_IN_COMMUNICATION != audioCategory) { + return HDF_ERR_NOT_SUPPORT; + } + enum AudioFormat audioFormat = attrs->format; + switch (audioFormat) { + case AUDIO_FORMAT_PCM_8_BIT: + case AUDIO_FORMAT_PCM_16_BIT: + case AUDIO_FORMAT_PCM_24_BIT: + case AUDIO_FORMAT_PCM_32_BIT: + 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: + return HDF_SUCCESS; + default: + return HDF_ERR_NOT_SUPPORT; + } +} + +int32_t AttrFormatToBit(const struct AudioSampleAttributes *attrs, int32_t *format) +{ + if (NULL == attrs || NULL == format) { + return HDF_FAILURE; + } + enum AudioFormat audioFormat = attrs->format; + switch (audioFormat) { + case AUDIO_FORMAT_PCM_8_BIT: + *format = BIT_NUM_8; + return HDF_SUCCESS; + case AUDIO_FORMAT_PCM_16_BIT: + *format = BIT_NUM_16; + return HDF_SUCCESS; + case AUDIO_FORMAT_PCM_24_BIT: + *format = BIT_NUM_24; + return HDF_SUCCESS; + case AUDIO_FORMAT_PCM_32_BIT: + *format = BIT_NUM_32; + return HDF_SUCCESS; + default: + return HDF_ERR_NOT_SUPPORT; + } +} + +int32_t InitHwRenderParam(struct AudioHwRender *hwRender, const struct AudioDeviceDescriptor *desc, + const struct AudioSampleAttributes *attrs) +{ + if (hwRender == NULL || desc == NULL || attrs == NULL) { + LOG_FUN_ERR("InitHwRenderParam param Is NULL"); + return HDF_FAILURE; + } + int32_t ret = CheckParaDesc(desc, TYPE_RENDER); + if (ret != HDF_SUCCESS) { + return ret; + } + ret = CheckParaAttr(attrs); + if (ret != HDF_SUCCESS) { + return ret; + } + int32_t formatValue = -1; + ret = AttrFormatToBit(attrs, &formatValue); + if (ret != HDF_SUCCESS) { + return ret; + } + if (attrs->channelCount == 0) { + return HDF_FAILURE; + } + hwRender->renderParam.renderMode.hwInfo.deviceDescript = *desc; + hwRender->renderParam.frameRenderMode.attrs = *attrs; + hwRender->renderParam.renderMode.ctlParam.audioGain.gainMax = GAIN_MAX; // init gainMax + hwRender->renderParam.renderMode.ctlParam.audioGain.gainMin = 0; + hwRender->renderParam.frameRenderMode.frames = 0; + hwRender->renderParam.frameRenderMode.time.tvNSec = 0; + hwRender->renderParam.frameRenderMode.time.tvSec = 0; + hwRender->renderParam.frameRenderMode.byteRate = DEFAULT_RENDER_SAMPLING_RATE; + hwRender->renderParam.frameRenderMode.periodSize = DEEP_BUFFER_RENDER_PERIOD_SIZE; + hwRender->renderParam.frameRenderMode.periodCount = DEEP_BUFFER_RENDER_PERIOD_COUNT; + hwRender->renderParam.frameRenderMode.attrs.period = attrs->period; + hwRender->renderParam.frameRenderMode.attrs.frameSize = attrs->frameSize; + hwRender->renderParam.frameRenderMode.attrs.startThreshold = attrs->startThreshold; + hwRender->renderParam.frameRenderMode.attrs.stopThreshold = attrs->stopThreshold; + hwRender->renderParam.frameRenderMode.attrs.silenceThreshold = attrs->silenceThreshold; + hwRender->renderParam.frameRenderMode.attrs.isBigEndian = attrs->isBigEndian; + hwRender->renderParam.frameRenderMode.attrs.isSignedData = attrs->isSignedData; + return HDF_SUCCESS; +} + +enum AudioFormat g_formatIdZero = AUDIO_FORMAT_PCM_16_BIT; +int32_t InitForGetPortCapability(struct AudioPort portIndex, struct AudioPortCapability *capabilityIndex) +{ + if (capabilityIndex == NULL) { + LOG_FUN_ERR("capabilityIndex Is NULL"); + return HDF_FAILURE; + } + /* get capabilityIndex from driver or default */ + if (portIndex.dir != PORT_OUT) { + capabilityIndex->hardwareMode = true; + capabilityIndex->channelMasks = AUDIO_CHANNEL_STEREO; + capabilityIndex->channelCount = CONFIG_CHANNEL_COUNT; + return HDF_SUCCESS; + } + if (portIndex.portId == 0) { + capabilityIndex->hardwareMode = true; + capabilityIndex->channelMasks = AUDIO_CHANNEL_STEREO; + capabilityIndex->channelCount = CONFIG_CHANNEL_COUNT; + capabilityIndex->deviceType = portIndex.dir; + capabilityIndex->deviceId = PIN_OUT_SPEAKER; + capabilityIndex->formatNum = 1; + capabilityIndex->formats = &g_formatIdZero; + capabilityIndex->sampleRateMasks = AUDIO_SAMPLE_RATE_MASK_16000; + capabilityIndex->subPortsNum = 1; + capabilityIndex->subPorts = (struct AudioSubPortCapability *)calloc(capabilityIndex->subPortsNum, + sizeof(struct AudioSubPortCapability)); + if (capabilityIndex->subPorts == NULL) { + LOG_FUN_ERR("capabilityIndex->subPorts is NULL!"); + return HDF_FAILURE; + } + capabilityIndex->subPorts->portId = portIndex.portId; + capabilityIndex->subPorts->desc = portIndex.portName; + capabilityIndex->subPorts->mask = PORT_PASSTHROUGH_LPCM; + return HDF_SUCCESS; + } + if (portIndex.portId == 1) { + capabilityIndex->hardwareMode = true; + capabilityIndex->channelMasks = AUDIO_CHANNEL_STEREO; + capabilityIndex->channelCount = CONFIG_CHANNEL_COUNT; + capabilityIndex->deviceType = portIndex.dir; + capabilityIndex->deviceId = PIN_OUT_HEADSET; + capabilityIndex->formatNum = 1; + capabilityIndex->formats = &g_formatIdZero; + capabilityIndex->sampleRateMasks = AUDIO_SAMPLE_RATE_MASK_16000 | AUDIO_SAMPLE_RATE_MASK_8000; + return HDF_SUCCESS; + } + if (portIndex.portId == HDMI_PORT_ID) { + return HdmiPortInit(portIndex, capabilityIndex); + } + return HDF_FAILURE; +} + +void AudioAdapterReleaseCapSubPorts(const struct AudioPortAndCapability *portCapabilitys, int32_t num) +{ + int32_t i = 0; + if (portCapabilitys == NULL) { + return; + } + while (i < num) { + if (&portCapabilitys[i] == NULL) { + break; + } + AudioMemFree((void **)(&portCapabilitys[i].capability.subPorts)); + i++; + } + return; +} + +int32_t AudioAdapterInitAllPorts(struct AudioAdapter *adapter) +{ + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + if (hwAdapter == NULL) { + LOG_FUN_ERR("hwAdapter Is NULL"); + return HDF_FAILURE; + } + if (hwAdapter->portCapabilitys != NULL) { + LOG_PARA_INFO("portCapabilitys already Init!"); + return HDF_SUCCESS; + } + int32_t portNum = hwAdapter->adapterDescriptor.portNum; + struct AudioPort *ports = hwAdapter->adapterDescriptor.ports; + if (ports == NULL) { + LOG_FUN_ERR("ports is NULL!"); + return HDF_FAILURE; + } + struct AudioPortAndCapability *portCapability = + (struct AudioPortAndCapability *)calloc(portNum, sizeof(struct AudioPortAndCapability)); + if (portCapability == NULL) { + LOG_FUN_ERR("portCapability is NULL!"); + return HDF_FAILURE; + } + 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!"); + AudioAdapterReleaseCapSubPorts(portCapability, portNum); + AudioMemFree((void **)&portCapability); + return HDF_FAILURE; + } + } + hwAdapter->portCapabilitys = portCapability; + hwAdapter->portCapabilitys->mode = PORT_PASSTHROUGH_LPCM; + return HDF_SUCCESS; +} + +void AudioReleaseRenderHandle(struct AudioHwRender *hwRender) +{ + if (hwRender == NULL) { + return; + } + CloseServiceRenderSo *pCloseServiceRender = AudioSoGetCloseServiceRender(); + if (pCloseServiceRender == NULL || (*pCloseServiceRender) == NULL) { + LOG_FUN_ERR("pCloseServiceRender func not exist"); + return; + } + if (hwRender->devDataHandle != NULL) { + (*pCloseServiceRender)(hwRender->devDataHandle); + hwRender->devDataHandle = NULL; + } + if (hwRender->devCtlHandle != NULL) { + (*pCloseServiceRender)(hwRender->devCtlHandle); + hwRender->devCtlHandle = NULL; + } + return; +} + +int32_t AudioSetAcodeModeRender(struct AudioHwRender *hwRender, + InterfaceLibModeRenderSo *pInterfaceLibModeRender) +{ + LOG_FUN_INFO(); + if (hwRender == NULL || pInterfaceLibModeRender == NULL || hwRender->devCtlHandle == NULL) { + return HDF_FAILURE; + } + if (hwRender->renderParam.renderMode.hwInfo.deviceDescript.portId < AUDIO_SERVICE_PORTID_FLAG) { + hwRender->renderParam.renderMode.hwInfo.card = AUDIO_SERVICE_IN; + return(*pInterfaceLibModeRender)(hwRender->devCtlHandle, &hwRender->renderParam, + AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN); + } else { + hwRender->renderParam.renderMode.hwInfo.card = AUDIO_SERVICE_OUT; + return(*pInterfaceLibModeRender)(hwRender->devCtlHandle, &hwRender->renderParam, + AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_OUT); + } +} + +int32_t AudioAdapterCreateRenderPre(struct AudioHwRender *hwRender, const struct AudioDeviceDescriptor *desc, + const struct AudioSampleAttributes *attrs, struct AudioAdapter *adapter) +{ + LOG_FUN_INFO(); + if (adapter == NULL || hwRender == NULL || desc == NULL || attrs == NULL) { + return HDF_FAILURE; + } + +#ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT + PathSelAnalysisJson *pPathSelAnalysisJson = AudioSoGetPathSelAnalysisJson(); + if (pPathSelAnalysisJson == NULL || *pPathSelAnalysisJson == NULL) { + LOG_FUN_ERR("PathSelAnalysisJson not exist"); + return HDF_FAILURE; + } +#endif + if (GetAudioRenderFunc(hwRender) < 0) { + return HDF_FAILURE; + } + /* Fill hwRender para */ + if (InitHwRenderParam(hwRender, desc, attrs) < 0) { + return HDF_FAILURE; + } + /* Select Path */ +#ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT + if ((*pPathSelAnalysisJson)((void *)&hwRender->renderParam, RENDER_PATH_SELECT) < 0) { + LOG_FUN_ERR("Path Select Fail!"); + 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; + } + uint32_t adapterNameLen = strlen(hwAdapter->adapterDescriptor.adapterName); + if (adapterNameLen == 0) { + LOG_FUN_ERR("adapterNameLen is null!"); + return HDF_FAILURE; + } + /* Get Adapter name */ + int32_t ret = strncpy_s(hwRender->renderParam.renderMode.hwInfo.adapterName, NAME_LEN - 1, + hwAdapter->adapterDescriptor.adapterName, adapterNameLen); + if (ret != EOK) { + LOG_FUN_ERR("copy fail"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioAdapterBindServiceRender(struct AudioHwRender *hwRender) +{ + LOG_FUN_INFO(); + int32_t ret; + if (hwRender == NULL) { + return HDF_FAILURE; + } + InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender(); + if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) { + LOG_FUN_ERR("InterfaceLibModeRender not exist"); + return HDF_FAILURE; + } +#ifndef AUDIO_HAL_USER + /* Select Codec Mode */ + ret = AudioSetAcodeModeRender(hwRender, pInterfaceLibModeRender); + if (ret < 0) { + LOG_FUN_ERR("Select Codec Mode FAIL!"); + return HDF_FAILURE; + } +#endif + /* Init RenderPathSelect send first */ + /* portId small than AUDIO_SERVICE_PORTID_FLAG shoud SceneSelect */ +#ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT + uint32_t portId = hwRender->renderParam.renderMode.hwInfo.deviceDescript.portId; + bool needSceneSelect = (portId < AUDIO_SERVICE_PORTID_FLAG) ? true : false; + if (needSceneSelect) { + ret = (*pInterfaceLibModeRender)(hwRender->devCtlHandle, &hwRender->renderParam, + AUDIODRV_CTL_IOCTL_SCENESELECT_WRITE); + if (ret < 0) { + LOG_FUN_ERR("SetParams FAIL!"); + return HDF_FAILURE; + } + } +#endif + /* set Attr Para */ + ret = (*pInterfaceLibModeRender)(hwRender->devDataHandle, &hwRender->renderParam, AUDIO_DRV_PCM_IOCTL_HW_PARAMS); + if (ret < 0) { + LOG_FUN_ERR("AudioRender SetParams FAIL"); + return HDF_FAILURE; + } + /* get volThreshold */ + ret = (*pInterfaceLibModeRender)(hwRender->devCtlHandle, &hwRender->renderParam, + AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ); + if (ret < 0) { + LOG_FUN_ERR("SetParams FAIL!"); + return HDF_FAILURE; + } +#ifndef AUDIO_HAL_USER + ret = (*pInterfaceLibModeRender)(hwRender->devDataHandle, &hwRender->renderParam, AUDIO_DRV_PCM_IOCTL_PREPARE); + if (ret < 0) { + LOG_FUN_ERR("AudioRender perpare FAIL"); + return HDF_FAILURE; + } +#endif + return HDF_SUCCESS; +} + +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) { + return HDF_FAILURE; + } + BindServiceRenderSo *pBindServiceRender = AudioSoGetBindServiceRender(); + if (pBindServiceRender == NULL || *pBindServiceRender == NULL) { + LOG_FUN_ERR("lib render func not exist"); + return HDF_FAILURE; + } + struct AudioHwRender *hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender)); + if (hwRender == NULL) { + LOG_FUN_ERR("hwRender is NULL!"); + return HDF_FAILURE; + } + int32_t ret = AudioAdapterCreateRenderPre(hwRender, desc, attrs, adapter); + if (ret != 0) { + LOG_FUN_ERR("AudioAdapterCreateRenderPre fail"); + AudioMemFree((void **)&hwRender); + return HDF_FAILURE; + } + /* bindRenderService */ + hwRender->devDataHandle = (*pBindServiceRender)(RENDER_CMD); + if (hwRender->devDataHandle == NULL) { + LOG_FUN_ERR("Render bind service failed"); + AudioMemFree((void **)&hwRender); + return HDF_FAILURE; + } + hwRender->devCtlHandle = (*pBindServiceRender)(CTRL_CMD); + if (hwRender->devCtlHandle == NULL) { + LOG_FUN_ERR("Render bind service failed"); + AudioReleaseRenderHandle(hwRender); + AudioMemFree((void **)&hwRender); + return HDF_FAILURE; + } + ret = AudioAdapterBindServiceRender(hwRender); + if (ret != 0) { + LOG_FUN_ERR("AudioAdapterBindServiceRender fail"); + AudioReleaseRenderHandle(hwRender); + AudioMemFree((void **)&hwRender); + return HDF_FAILURE; + } + *render = &hwRender->common; + return HDF_SUCCESS; +} + +int32_t AudioAdapterDestroyRender(struct AudioAdapter *adapter, struct AudioRender *render) +{ + if (adapter == NULL || render == NULL) { + return HDF_FAILURE; + } + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + if (hwRender == NULL) { + return HDF_FAILURE; + } + int ret = render->control.Stop((AudioHandle)render); + if (ret == HDF_FAILURE) { + LOG_FUN_ERR("render Stop failed"); + } + AudioReleaseRenderHandle(hwRender); + AudioMemFree((void **)&hwRender->renderParam.frameRenderMode.buffer); + AudioMemFree((void **)&render); + return HDF_SUCCESS; +} + +int32_t GetAudioCaptureFunc(struct AudioHwCapture *hwCapture) +{ + if (hwCapture == NULL) { + return HDF_FAILURE; + } + hwCapture->common.control.Start = AudioCaptureStart; + hwCapture->common.control.Stop = AudioCaptureStop; + hwCapture->common.control.Pause = AudioCapturePause; + hwCapture->common.control.Resume = AudioCaptureResume; + hwCapture->common.control.Flush = AudioCaptureFlush; + 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.scene.CheckSceneCapability = AudioCaptureCheckSceneCapability; + hwCapture->common.scene.SelectScene = AudioCaptureSelectScene; + hwCapture->common.volume.SetMute = AudioCaptureSetMute; + hwCapture->common.volume.GetMute = AudioCaptureGetMute; + hwCapture->common.volume.SetVolume = AudioCaptureSetVolume; + hwCapture->common.volume.GetVolume = AudioCaptureGetVolume; + hwCapture->common.volume.GetGainThreshold = AudioCaptureGetGainThreshold; + hwCapture->common.volume.GetGain = AudioCaptureGetGain; + hwCapture->common.volume.SetGain = AudioCaptureSetGain; + hwCapture->common.CaptureFrame = AudioCaptureCaptureFrame; + hwCapture->common.GetCapturePosition = AudioCaptureGetCapturePosition; + return HDF_SUCCESS; +} + +int32_t InitHwCaptureParam(struct AudioHwCapture *hwCapture, const struct AudioDeviceDescriptor *desc, + const struct AudioSampleAttributes *attrs) +{ + if (NULL == hwCapture || NULL == desc || NULL == attrs) { + LOG_FUN_ERR("InitHwCaptureParam param Is NULL"); + return HDF_FAILURE; + } + int32_t ret = CheckParaDesc(desc, TYPE_CAPTURE); + if (ret != HDF_SUCCESS) { + return ret; + } + ret = CheckParaAttr(attrs); + if (ret != HDF_SUCCESS) { + return ret; + } + int32_t formatValue = -1; + ret = AttrFormatToBit(attrs, &formatValue); + if (ret != HDF_SUCCESS) { + return ret; + } + if (attrs->channelCount == 0) { + return HDF_FAILURE; + } + hwCapture->captureParam.captureMode.hwInfo.deviceDescript = *desc; + hwCapture->captureParam.frameCaptureMode.attrs = *attrs; + hwCapture->captureParam.captureMode.ctlParam.audioGain.gainMax = GAIN_MAX; // init gainMax + hwCapture->captureParam.captureMode.ctlParam.audioGain.gainMin = 0; + hwCapture->captureParam.frameCaptureMode.frames = 0; + hwCapture->captureParam.frameCaptureMode.time.tvNSec = 0; + hwCapture->captureParam.frameCaptureMode.time.tvSec = 0; + hwCapture->captureParam.frameCaptureMode.byteRate = DEFAULT_RENDER_SAMPLING_RATE; + hwCapture->captureParam.frameCaptureMode.periodSize = DEEP_BUFFER_RENDER_PERIOD_SIZE; + hwCapture->captureParam.frameCaptureMode.periodCount = DEEP_BUFFER_RENDER_PERIOD_COUNT; + hwCapture->captureParam.frameCaptureMode.attrs.period = attrs->period; + hwCapture->captureParam.frameCaptureMode.attrs.frameSize = attrs->frameSize; + hwCapture->captureParam.frameCaptureMode.attrs.startThreshold = attrs->startThreshold; + hwCapture->captureParam.frameCaptureMode.attrs.stopThreshold = attrs->stopThreshold; + hwCapture->captureParam.frameCaptureMode.attrs.silenceThreshold = attrs->silenceThreshold; + hwCapture->captureParam.frameCaptureMode.attrs.isBigEndian = attrs->isBigEndian; + hwCapture->captureParam.frameCaptureMode.attrs.isSignedData = attrs->isSignedData; + return HDF_SUCCESS; +} + +void AudioReleaseCaptureHandle(struct AudioHwCapture *hwCapture) +{ + if (hwCapture == NULL) { + return; + } + CloseServiceCaptureSo *pCloseServiceCapture = AudioSoGetCloseServiceCapture(); + if (pCloseServiceCapture == NULL || (*pCloseServiceCapture) == NULL) { + LOG_FUN_ERR("pCloseServiceCapture func not exist"); + return; + } + if (hwCapture->devDataHandle != NULL) { + (*pCloseServiceCapture)(hwCapture->devDataHandle); + hwCapture->devDataHandle = NULL; + } + if (hwCapture->devCtlHandle != NULL) { + (*pCloseServiceCapture)(hwCapture->devCtlHandle); + hwCapture->devCtlHandle = NULL; + } + return; +} + +int32_t AudioAdapterCreateCapturePre(struct AudioHwCapture *hwCapture, const struct AudioDeviceDescriptor *desc, + const struct AudioSampleAttributes *attrs, struct AudioAdapter *adapter) +{ + LOG_FUN_INFO(); + if (hwCapture == NULL || desc == NULL || attrs == NULL) { + return HDF_FAILURE; + } +#ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT + PathSelAnalysisJson *pPathSelAnalysisJson = AudioSoGetPathSelAnalysisJson(); + if (pPathSelAnalysisJson == NULL || *pPathSelAnalysisJson == NULL) { + LOG_FUN_ERR("PathSelAnalysisJson not exist"); + return HDF_FAILURE; + } +#endif + if (GetAudioCaptureFunc(hwCapture) < 0) { + return HDF_FAILURE; + } + /* Fill hwCapture para */ + if (InitHwCaptureParam(hwCapture, desc, attrs) < 0) { + return HDF_FAILURE; + } + +#ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT + /* Select Path */ + if ((*pPathSelAnalysisJson)((void *)&hwCapture->captureParam, CAPTURE_PATH_SELECT) < 0) { + LOG_FUN_ERR("Path Select Fail!"); + return HDF_FAILURE; + } +#endif + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + if (hwAdapter->adapterDescriptor.adapterName == NULL) { + LOG_FUN_ERR("adapterName is NULL!"); + return HDF_FAILURE; + } + uint32_t adapterNameLen = strlen(hwAdapter->adapterDescriptor.adapterName); + if (adapterNameLen == 0) { + LOG_FUN_ERR("adapterNameLen is null!"); + return HDF_FAILURE; + } + /* Get Adapter name */ + int32_t ret = strncpy_s(hwCapture->captureParam.captureMode.hwInfo.adapterName, NAME_LEN - 1, + hwAdapter->adapterDescriptor.adapterName, adapterNameLen); + if (ret != EOK) { + LOG_FUN_ERR("copy fail"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioAdapterInterfaceLibModeCapture(struct AudioHwCapture *hwCapture) +{ + LOG_FUN_INFO(); + if (hwCapture == NULL) { + return HDF_FAILURE; + } + int32_t ret; + InterfaceLibModeCaptureSo *pInterfaceLibModeCapture = AudioSoGetInterfaceLibModeCapture(); + if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) { + LOG_FUN_ERR("lib capture func not exist"); + return HDF_FAILURE; + } +#ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT + /* Init CapturePathSelect send first */ + ret = (*pInterfaceLibModeCapture)(hwCapture->devCtlHandle, &hwCapture->captureParam, + AUDIODRV_CTL_IOCTL_SCENESELECT_CAPTURE); + if (ret < 0) { + LOG_FUN_ERR("SetParams FAIL!"); + return HDF_FAILURE; + } +#endif + ret = (*pInterfaceLibModeCapture)(hwCapture->devDataHandle, &hwCapture->captureParam, + AUDIO_DRV_PCM_IOCTL_HW_PARAMS); + if (ret < 0) { + LOG_FUN_ERR("AudioCaptureStart SetParams FAIL"); + return HDF_FAILURE; + } + /* get volThreshold capture */ + ret = (*pInterfaceLibModeCapture)(hwCapture->devCtlHandle, &hwCapture->captureParam, + AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE); + if (ret < 0) { + LOG_FUN_ERR("SetParams FAIL!"); + return HDF_FAILURE; + } +#ifdef AUDIO_HAL_USER +#else + ret = (*pInterfaceLibModeCapture)(hwCapture->devDataHandle, &hwCapture->captureParam, + AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE); + if (ret < 0) { + LOG_FUN_ERR("AudioCaptureStart prepare FAIL"); + return HDF_FAILURE; + } +#endif + return HDF_SUCCESS; +} + +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) { + return HDF_FAILURE; + } + BindServiceCaptureSo *pBindServiceCapture = AudioSoGetBindServiceCapture(); + if (pBindServiceCapture == NULL || *pBindServiceCapture == NULL) { + LOG_FUN_ERR("lib capture func not exist"); + return HDF_FAILURE; + } + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)calloc(1, sizeof(*hwCapture)); + if (hwCapture == NULL) { + LOG_FUN_ERR("calloc AudioHwCapture failed!"); + return HDF_FAILURE; + } + int32_t ret = AudioAdapterCreateCapturePre(hwCapture, desc, attrs, adapter); + 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); + if (hwCapture->devCtlHandle == NULL) { + LOG_FUN_ERR("Capture bind service failed"); + AudioReleaseCaptureHandle(hwCapture); + AudioMemFree((void **)&hwCapture); + return HDF_FAILURE; + } + ret = AudioAdapterInterfaceLibModeCapture(hwCapture); + if (ret != 0) { + LOG_FUN_ERR("AudioAdapterInterfaceLibModeCapture failed"); + AudioReleaseCaptureHandle(hwCapture); + AudioMemFree((void **)&hwCapture); + return HDF_FAILURE; + } + *capture = &hwCapture->common; + return HDF_SUCCESS; +} + +int32_t AudioAdapterDestroyCapture(struct AudioAdapter *adapter, struct AudioCapture *capture) +{ + if (adapter == NULL || capture == NULL) { + return HDF_FAILURE; + } + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + if (hwCapture == NULL) { + return HDF_FAILURE; + } + int ret = capture->control.Stop((AudioHandle)capture); + if (ret == HDF_FAILURE) { + LOG_FUN_ERR("capture Stop failed"); + } + AudioReleaseCaptureHandle(hwCapture); + AudioMemFree((void **)&hwCapture->captureParam.frameCaptureMode.buffer); + AudioMemFree((void **)&capture); + return HDF_SUCCESS; +} + +int32_t AudioAdapterGetPortCapability(struct AudioAdapter *adapter, const struct AudioPort *port, + struct AudioPortCapability *capability) +{ + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + if (hwAdapter == NULL || port == NULL || port->portName == NULL || capability == NULL) { + return HDF_FAILURE; + } + if (port->portId < 0) { + return HDF_FAILURE; + } + struct AudioPortAndCapability *hwAdapterPortCapabilitys = hwAdapter->portCapabilitys; + if (hwAdapterPortCapabilitys == NULL) { + LOG_FUN_ERR("hwAdapter portCapabilitys is NULL!"); + return HDF_FAILURE; + } + int32_t portNum = hwAdapter->adapterDescriptor.portNum; + while (hwAdapterPortCapabilitys != NULL && portNum) { + if (hwAdapterPortCapabilitys->port.portId == port->portId) { + *capability = hwAdapterPortCapabilitys->capability; + return HDF_SUCCESS; + } + hwAdapterPortCapabilitys++; + portNum--; + } + return HDF_FAILURE; +} + +int32_t AudioAdapterSetPassthroughMode(struct AudioAdapter *adapter, const struct AudioPort *port, + enum AudioPortPassthroughMode mode) +{ + if (adapter == NULL || port == NULL || port->portName == NULL) { + return HDF_FAILURE; + } + if (port->dir != PORT_OUT || port->portId < 0 || strcmp(port->portName, "AOP") != 0) { + return HDF_FAILURE; + } + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + if (hwAdapter->portCapabilitys == NULL) { + LOG_FUN_ERR("hwAdapter portCapabilitys is NULL!"); + return HDF_FAILURE; + } + struct AudioPortAndCapability *portCapabilityTemp = hwAdapter->portCapabilitys; + struct AudioPortCapability *portCapability = NULL; + int32_t portNum = hwAdapter->adapterDescriptor.portNum; + while (portCapabilityTemp != NULL && portNum > 0) { + if (portCapabilityTemp->port.portId == port->portId) { + portCapability = &portCapabilityTemp->capability; + break; + } + portCapabilityTemp++; + portNum--; + } + if (portCapability == NULL || portNum <= 0) { + LOG_FUN_ERR("hwAdapter portCapabilitys is Not Find!"); + return HDF_FAILURE; + } + struct AudioSubPortCapability *subPortCapability = portCapability->subPorts; + if (subPortCapability == NULL) { + LOG_FUN_ERR("portCapability->subPorts is NULL!"); + return HDF_FAILURE; + } + + int32_t subPortNum = portCapability->subPortsNum; + while (subPortCapability != NULL && subPortNum > 0) { + if (subPortCapability->mask == mode) { + portCapabilityTemp->mode = mode; + break; + } + subPortCapability++; + subPortNum--; + } + if (subPortNum > 0) { + return HDF_SUCCESS; + } + return HDF_FAILURE; +} + +int32_t AudioAdapterGetPassthroughMode(struct AudioAdapter *adapter, const struct AudioPort *port, + enum AudioPortPassthroughMode *mode) +{ + if (adapter == NULL || port == NULL || port->portName == NULL || mode == NULL) { + return HDF_FAILURE; + } + if (port->dir != PORT_OUT || port->portId < 0 || strcmp(port->portName, "AOP") != 0) { + return HDF_FAILURE; + } + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + if (hwAdapter->portCapabilitys == NULL) { + LOG_FUN_ERR("hwAdapter portCapabilitys is NULL!"); + return HDF_FAILURE; + } + struct AudioPortAndCapability *portCapabilitys = hwAdapter->portCapabilitys; + int32_t portNum = hwAdapter->adapterDescriptor.portNum; + while (portCapabilitys != NULL && portNum > 0) { + if (portCapabilitys->port.portId == port->portId) { + *mode = portCapabilitys->mode; + return HDF_SUCCESS; + } + portCapabilitys++; + portNum--; + } + return HDF_FAILURE; +} diff --git a/audio/hal/hdi_passthrough/src/audio_adapter_info_common.c b/audio/hal/hdi_passthrough/src/audio_adapter_info_common.c new file mode 100755 index 0000000000000000000000000000000000000000..9b3ce3d07a9cf09409831995fc185a54d67c9ca2 --- /dev/null +++ b/audio/hal/hdi_passthrough/src/audio_adapter_info_common.c @@ -0,0 +1,352 @@ +/* + * 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_internal.h" +#include "audio_adapter_info_common.h" +#include "cJSON.h" + +#define AUDIO_ADAPTER_CONFIG "/system/etc/hdfconfig/adapter_config.json" +#define ADAPTER_NAME_LEN 32 +#define PORT_NAME_LEN 32 +#define CONFIG_SIEZ_MAX 4096 +#define CONFIG_CHANNEL_COUNT 2 // two channels + + +struct AudioAdapterDescriptor *g_audioAdapterOut = NULL; +struct AudioAdapterDescriptor *g_audioAdapterDescs = NULL; +int32_t g_adapterNum = 0; + +struct AudioAdapterDescriptor *AudioAdapterGetConfigOut(void) +{ + return g_audioAdapterOut; +} + +struct AudioAdapterDescriptor *AudioAdapterGetConfigDescs(void) +{ + return g_audioAdapterDescs; +} + +int32_t AudioAdapterGetAdapterNum(void) +{ + return g_adapterNum; +} + +int32_t AudioAdapterExist(const char *adapterName) +{ + if (adapterName == NULL) { + return HDF_FAILURE; + } + if (g_audioAdapterDescs == NULL || g_adapterNum <= 0) { + LOG_FUN_ERR("no adapter info"); + return HDF_FAILURE; + } + for (int i = 0; i < g_adapterNum; i++) { + if (strcmp(adapterName, g_audioAdapterDescs[i].adapterName) == 0) { + return HDF_SUCCESS; + } + } + return HDF_FAILURE; +} + +static void AudioAdapterJudegReleaseDescs(const struct AudioAdapterDescriptor *desc) +{ + if (desc == NULL) { + return; + } + uint32_t portIdx; + if (desc->adapterName != NULL) { + AudioMemFree((void **)&desc->adapterName); + } + if (desc->ports != NULL) { + portIdx = 0; + while (portIdx < desc->portNum) { + if (desc->ports[portIdx].portName != NULL) { + AudioMemFree((void **)&desc->ports[portIdx].portName); + } + portIdx++; + } + AudioMemFree((void **)&desc->ports); + } +} + +static void AudioAdapterReleaseDescs(struct AudioAdapterDescriptor *descs, int32_t adapterNum) +{ + int32_t adapterIdx = 0; + if (descs == NULL) { + 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 (strcmp(dir, "PORT_OUT") == 0) { + return PORT_OUT; + } else if (strcmp(dir, "PORT_IN") == 0) { + return PORT_IN; + } else if (strcmp(dir, "PORT_OUT_IN") == 0) { + return PORT_OUT_IN; + } else { + return -1; + } +} + +static int32_t AudioAdapterParsePort(struct AudioPort *info, cJSON *port) +{ + int32_t ret; + cJSON *portDir = NULL; + cJSON *portID = NULL; + cJSON *portName = NULL; + portDir = cJSON_GetObjectItem(port, "dir"); + if (portDir == NULL) { + return HDF_FAILURE; + } + info->dir = AudioAdapterGetDir(portDir->valuestring); + portID = cJSON_GetObjectItem(port, "id"); + if (portID == NULL) { + return HDF_FAILURE; + } + info->portId = cJSON_GetNumberValue(portID); + portName = cJSON_GetObjectItem(port, "name"); + if (portName == NULL) { + return HDF_FAILURE; + } + info->portName = (char *)calloc(1, PORT_NAME_LEN); + if (info->portName == NULL) { + return -ENOMEM; + } + 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) +{ + uint32_t i; + int32_t ret; + 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; + } + 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"); + return HDF_FAILURE; + } + cJSON *adapterPorts = cJSON_GetObjectItem(adapter, "port"); + if (adapterPorts == NULL) { + 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; + } + 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 HDF_SUCCESS; +} + +cJSON *AudioAdaptersGetConfigToJsonObj(const char *fpath) +{ + char *pJsonStr = NULL; + if (fpath == NULL) { + return NULL; + } + FILE *fp = fopen(fpath, "r"); + if (fp == NULL) { + LOG_FUN_ERR("Can not open config file [ %s ].\n", fpath); + return NULL; + } + fseek(fp, 0, SEEK_END); + uint32_t jsonStrSize = ftell(fp); + rewind(fp); + if (jsonStrSize > CONFIG_SIEZ_MAX) { + LOG_FUN_ERR("The configuration file is too large to load!\n"); + fclose(fp); + return NULL; + } + pJsonStr = (char *)calloc(1, jsonStrSize); + if (NULL == pJsonStr) { + fclose(fp); + return NULL; + } + 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); + cJSON *cJsonObj = cJSON_Parse(pJsonStr); + if (cJsonObj == NULL) { + AudioMemFree((void **)&pJsonStr); + return NULL; + } + AudioMemFree((void **)&pJsonStr); + cJSON *adapterNum = cJSON_GetObjectItem(cJsonObj, "adapterNum"); + if (adapterNum == NULL) { + cJSON_Delete(cJsonObj); + return NULL; + } + g_adapterNum = cJSON_GetNumberValue(adapterNum); + if (g_adapterNum == 0) { + LOG_FUN_ERR("no adapter info"); + cJSON_Delete(cJsonObj); + return NULL; + } + return cJsonObj; +} + +static int32_t AudioAdaptersSetAdapter(struct AudioAdapterDescriptor **descs, + int32_t adapterNum, cJSON *adaptersObj) +{ + int32_t i, ret; + cJSON *adapterObj = NULL; + if (adaptersObj == NULL || adapterNum <= 0) { + return HDF_FAILURE; + } + 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; + } + 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); + return HDF_FAILURE; + } + } + } + return HDF_SUCCESS; +} + +int32_t AudioAdaptersForUser(struct AudioAdapterDescriptor **descs, int *size) +{ + int ret; + + if (descs == NULL || size == NULL) { + return HDF_FAILURE; + } + if (g_audioAdapterDescs != NULL && g_audioAdapterOut != NULL && + g_adapterNum > 0) { + /* 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) { + g_adapterNum = 0; + cJSON_Delete(cJsonObj); + return HDF_FAILURE; + } + ret = AudioAdaptersSetAdapter(&g_audioAdapterOut, g_adapterNum, adaptersObj); + if (ret != HDF_SUCCESS) { + /* g_audioAdapterOut failure also releases g_audioAdapterDescs */ + AudioAdapterReleaseDescs(g_audioAdapterDescs, g_adapterNum); + g_adapterNum = 0; + cJSON_Delete(cJsonObj); + return HDF_FAILURE; + } + *descs = g_audioAdapterOut; + *size = g_adapterNum; + cJSON_Delete(cJsonObj); + return HDF_SUCCESS; +} + +static enum AudioFormat g_formatIdZero = AUDIO_FORMAT_PCM_16_BIT; +int32_t HdmiPortInit(struct AudioPort portIndex, struct AudioPortCapability *capabilityIndex) +{ + if (capabilityIndex == NULL) { + LOG_FUN_ERR("capabilityIndex Is NULL"); + return HDF_FAILURE; + } + capabilityIndex->hardwareMode = true; + capabilityIndex->channelMasks = AUDIO_CHANNEL_STEREO; + capabilityIndex->channelCount = CONFIG_CHANNEL_COUNT; + capabilityIndex->deviceType = portIndex.dir; + capabilityIndex->deviceId = PIN_OUT_SPEAKER; + capabilityIndex->formatNum = 1; + capabilityIndex->formats = &g_formatIdZero; + capabilityIndex->sampleRateMasks = AUDIO_SAMPLE_RATE_MASK_16000 | AUDIO_SAMPLE_RATE_MASK_24000; + capabilityIndex->subPortsNum = 1; + capabilityIndex->subPorts = (struct AudioSubPortCapability *)calloc(capabilityIndex->subPortsNum, + sizeof(struct AudioSubPortCapability)); + if (capabilityIndex->subPorts == NULL) { + LOG_FUN_ERR("capabilityIndex->subPorts is NULL!"); + return HDF_FAILURE; + } + capabilityIndex->subPorts->portId = portIndex.portId; + capabilityIndex->subPorts->desc = portIndex.portName; + capabilityIndex->subPorts->mask = PORT_PASSTHROUGH_LPCM; + return HDF_SUCCESS; +} + diff --git a/audio/hal/hdi_passthrough/src/audio_capture.c b/audio/hal/hdi_passthrough/src/audio_capture.c new file mode 100755 index 0000000000000000000000000000000000000000..ed84f5de59c1203a4f1c860a5f69e1aa29201355 --- /dev/null +++ b/audio/hal/hdi_passthrough/src/audio_capture.c @@ -0,0 +1,667 @@ +/* + * 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_capture.h" +#include "audio_interface_lib_capture.h" +#include "audio_internal.h" + +#define CONFIG_FRAME_SIZE (1024 * 2 * 1) +#define FRAME_SIZE 1024 + +#define CONFIG_FRAME_COUNT ((8000 * 2 * 1 + (CONFIG_FRAME_SIZE - 1)) / CONFIG_FRAME_SIZE) + +/* add For Capture Bytes To Frames */ +int32_t FormatToBitsCapture(enum AudioFormat format, uint32_t *formatBits) +{ + LOG_FUN_INFO(); + 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 AudioCaptureStart(AudioHandle handle) +{ + LOG_FUN_INFO(); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL) { + return HDF_FAILURE; + } + if (hwCapture->devDataHandle == NULL) { + LOG_FUN_ERR("CaptureStart Bind Fail!"); + return HDF_FAILURE; + } + InterfaceLibModeCaptureSo *pInterfaceLibModeCapture = AudioSoGetInterfaceLibModeCapture(); + if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) { + LOG_FUN_ERR("pInterfaceLibModeCapture Fail!"); + return HDF_FAILURE; + } + if (hwCapture->captureParam.frameCaptureMode.buffer != NULL) { + LOG_FUN_ERR("AudioCapture already start!"); + return HDF_FAILURE; + } + int32_t ret = (*pInterfaceLibModeCapture)(hwCapture->devDataHandle, &hwCapture->captureParam, + AUDIO_DRV_PCM_IOCTRL_START_CAPTURE); + if (ret < 0) { + LOG_FUN_ERR("AudioCaptureStart SetParams FAIL"); + return HDF_FAILURE; + } + char *tbuffer = (char *)calloc(1, FRAME_DATA); + if (tbuffer == NULL) { + LOG_FUN_ERR("Calloc Capture tbuffer Fail!"); + return HDF_FAILURE; + } + hwCapture->captureParam.frameCaptureMode.buffer = tbuffer; + LOG_PARA_INFO("Capture Start SUCCESS!"); + return HDF_SUCCESS; +} + +int32_t AudioCaptureStop(AudioHandle handle) +{ + LOG_FUN_INFO(); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL) { + return HDF_FAILURE; + } + if (hwCapture->captureParam.frameCaptureMode.buffer != NULL) { + AudioMemFree((void **)&hwCapture->captureParam.frameCaptureMode.buffer); + } else { + LOG_FUN_ERR("AudioCapture already stop!"); + return HDF_ERR_INVALID_OBJECT; + } + if (hwCapture->devDataHandle == NULL) { + LOG_FUN_ERR("CaptureStart Bind Fail!"); + return HDF_FAILURE; + } + InterfaceLibModeCaptureSo *pInterfaceLibModeCapture = AudioSoGetInterfaceLibModeCapture(); + if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) { + LOG_FUN_ERR("pInterfaceLibModeCapture Fail!"); + return HDF_FAILURE; + } + int32_t ret = (*pInterfaceLibModeCapture)(hwCapture->devDataHandle, &hwCapture->captureParam, + AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE); + if (ret < 0) { + LOG_FUN_ERR("AudioCaptureStart SetParams FAIL"); + return HDF_FAILURE; + } + LOG_PARA_INFO("Capture Stop SUCCESS!"); + return HDF_SUCCESS; +} + +int32_t AudioCapturePause(AudioHandle handle) +{ + LOG_FUN_INFO(); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL) { + return HDF_FAILURE; + } + if (hwCapture->captureParam.frameCaptureMode.buffer == NULL) { + LOG_FUN_ERR("AudioCapture already stop!"); + return HDF_FAILURE; + } + if (hwCapture->captureParam.captureMode.ctlParam.pause) { + LOG_FUN_ERR("Audio capture is already pause!"); + return HDF_FAILURE; + } + if (hwCapture->devDataHandle == NULL) { + LOG_FUN_ERR("CaptureStart Bind Fail!"); + return HDF_FAILURE; + } + InterfaceLibModeCaptureSo *pInterfaceLibModeCapture = AudioSoGetInterfaceLibModeCapture(); + if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) { + LOG_FUN_ERR("pInterfaceLibModeCapture Fail!"); + return HDF_FAILURE; + } + bool pauseStatus = hwCapture->captureParam.captureMode.ctlParam.pause; + hwCapture->captureParam.captureMode.ctlParam.pause = true; + int32_t ret = (*pInterfaceLibModeCapture)(hwCapture->devDataHandle, &hwCapture->captureParam, + AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE); + if (ret < 0) { + LOG_FUN_ERR("Audio Capture Pause FAIL!"); + hwCapture->captureParam.captureMode.ctlParam.pause = pauseStatus; + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCaptureResume(AudioHandle handle) +{ + LOG_FUN_INFO(); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL) { + return HDF_FAILURE; + } + if (!hwCapture->captureParam.captureMode.ctlParam.pause) { + LOG_FUN_ERR("Audio capture is already Resume !"); + return HDF_FAILURE; + } + if (hwCapture->devDataHandle == NULL) { + LOG_FUN_ERR("Capture Start Bind Fail!"); + return HDF_FAILURE; + } + InterfaceLibModeCaptureSo *pInterfaceLibModeCapture = AudioSoGetInterfaceLibModeCapture(); + if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) { + LOG_FUN_ERR("pInterfaceLibModeCapture Fail!"); + return HDF_FAILURE; + } + bool resumeStatus = hwCapture->captureParam.captureMode.ctlParam.pause; + hwCapture->captureParam.captureMode.ctlParam.pause = false; + int32_t ret = (*pInterfaceLibModeCapture)(hwCapture->devDataHandle, &hwCapture->captureParam, + AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE); + if (ret < 0) { + LOG_FUN_ERR("Audio capture Pause FAIL!"); + hwCapture->captureParam.captureMode.ctlParam.pause = resumeStatus; + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCaptureFlush(AudioHandle handle) +{ + LOG_FUN_INFO(); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL) { + return HDF_FAILURE; + } + return HDF_ERR_NOT_SUPPORT; +} + +int32_t AudioCaptureGetFrameSize(AudioHandle handle, uint64_t *size) +{ + LOG_FUN_INFO(); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL || size == NULL) { + return HDF_FAILURE; + } + uint32_t channelCount = hwCapture->captureParam.frameCaptureMode.attrs.channelCount; + enum AudioFormat format = hwCapture->captureParam.frameCaptureMode.attrs.format; + uint32_t formatBitsCapture = 0; + int32_t ret = FormatToBitsCapture(format, &formatBitsCapture); + if (ret != HDF_SUCCESS) { + return ret; + } + *size = FRAME_SIZE * channelCount * (formatBitsCapture >> 3); + return HDF_SUCCESS; +} + +int32_t AudioCaptureGetFrameCount(AudioHandle handle, uint64_t *count) +{ + LOG_FUN_INFO(); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL || count == NULL) { + return HDF_FAILURE; + } + *count = hwCapture->captureParam.frameCaptureMode.frames; + return HDF_SUCCESS; +} + +int32_t AudioCaptureSetSampleAttributes(AudioHandle handle, const struct AudioSampleAttributes *attrs) +{ + LOG_FUN_INFO(); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL || attrs == NULL) { + return HDF_FAILURE; + } + int32_t ret = AudioCheckParaAttr(attrs); + if (ret != HDF_SUCCESS) { + return ret; + } + struct AudioSampleAttributes tempAttrs = hwCapture->captureParam.frameCaptureMode.attrs; + hwCapture->captureParam.frameCaptureMode.attrs.format = attrs->format; + hwCapture->captureParam.frameCaptureMode.attrs.sampleRate = attrs->sampleRate; + hwCapture->captureParam.frameCaptureMode.attrs.channelCount = attrs->channelCount; + hwCapture->captureParam.frameCaptureMode.attrs.interleaved = attrs->interleaved; + hwCapture->captureParam.frameCaptureMode.attrs.type = attrs->type; + hwCapture->captureParam.frameCaptureMode.attrs.period = attrs->period; + hwCapture->captureParam.frameCaptureMode.attrs.frameSize = attrs->frameSize; + hwCapture->captureParam.frameCaptureMode.attrs.isBigEndian = attrs->isBigEndian; + hwCapture->captureParam.frameCaptureMode.attrs.isSignedData = attrs->isSignedData; + hwCapture->captureParam.frameCaptureMode.attrs.startThreshold = attrs->startThreshold; + hwCapture->captureParam.frameCaptureMode.attrs.stopThreshold = attrs->stopThreshold; + hwCapture->captureParam.frameCaptureMode.attrs.silenceThreshold = attrs->silenceThreshold; + InterfaceLibModeCaptureSo *pInterfaceLibModeCapture = AudioSoGetInterfaceLibModeCapture(); + if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) { + hwCapture->captureParam.frameCaptureMode.attrs = tempAttrs; + LOG_FUN_ERR("pInterfaceLibModeCapture Fail!"); + return HDF_FAILURE; + } + if (hwCapture->devDataHandle == NULL) { + hwCapture->captureParam.frameCaptureMode.attrs = tempAttrs; + return HDF_FAILURE; + } + ret = (*pInterfaceLibModeCapture)(hwCapture->devDataHandle, &hwCapture->captureParam, + AUDIO_DRV_PCM_IOCTL_HW_PARAMS); + if (ret < 0) { + LOG_FUN_ERR("CaptureSetSampleAttributes FAIL"); + hwCapture->captureParam.frameCaptureMode.attrs = tempAttrs; + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCaptureGetSampleAttributes(AudioHandle handle, struct AudioSampleAttributes *attrs) +{ + LOG_FUN_INFO(); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL || attrs == NULL) { + return HDF_FAILURE; + } + attrs->format = hwCapture->captureParam.frameCaptureMode.attrs.format; + attrs->sampleRate = hwCapture->captureParam.frameCaptureMode.attrs.sampleRate; + attrs->channelCount = hwCapture->captureParam.frameCaptureMode.attrs.channelCount; + attrs->interleaved = hwCapture->captureParam.frameCaptureMode.attrs.interleaved; + attrs->type = hwCapture->captureParam.frameCaptureMode.attrs.type; + attrs->period = hwCapture->captureParam.frameCaptureMode.attrs.period; + attrs->frameSize = hwCapture->captureParam.frameCaptureMode.attrs.frameSize; + attrs->isBigEndian = hwCapture->captureParam.frameCaptureMode.attrs.isBigEndian; + attrs->isSignedData = hwCapture->captureParam.frameCaptureMode.attrs.isSignedData; + attrs->startThreshold = hwCapture->captureParam.frameCaptureMode.attrs.startThreshold; + attrs->stopThreshold = hwCapture->captureParam.frameCaptureMode.attrs.stopThreshold; + attrs->silenceThreshold = hwCapture->captureParam.frameCaptureMode.attrs.silenceThreshold; + return HDF_SUCCESS; +} + +int32_t AudioCaptureGetCurrentChannelId(AudioHandle handle, uint32_t *channelId) +{ + LOG_FUN_INFO(); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL || channelId == NULL) { + return HDF_FAILURE; + } + *channelId = hwCapture->captureParam.frameCaptureMode.attrs.channelCount; + return HDF_SUCCESS; +} + +int32_t AudioCaptureCheckSceneCapability(AudioHandle handle, const struct AudioSceneDescriptor *scene, + bool *supported) +{ + LOG_FUN_INFO(); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL || scene == NULL || supported == NULL) { + return HDF_FAILURE; + } +#ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT + *supported = false; + /* Temporary storage does not save the structure */ + struct AudioHwCaptureParam captureParam; + captureParam.frameCaptureMode.attrs.type = (enum AudioCategory)scene->scene.id; + captureParam.captureMode.hwInfo.deviceDescript.pins = scene->desc.pins; + PathSelAnalysisJson *pPathSelAnalysisJson = AudioSoGetPathSelAnalysisJson(); + if (pPathSelAnalysisJson == NULL || *pPathSelAnalysisJson == NULL) { + LOG_FUN_ERR("pPathSelAnalysisJson Is NULL!"); + return HDF_ERR_NOT_SUPPORT; + } + int ret = (*pPathSelAnalysisJson)((void *)&captureParam, CHECKSCENE_PATH_SELECT_CAPTURE); + if (ret < 0) { + if (ret == HDF_ERR_NOT_SUPPORT) { + LOG_FUN_ERR("AudioCaptureCheckSceneCapability not Support!"); + return HDF_ERR_NOT_SUPPORT; + } else { + LOG_FUN_ERR("AudioCaptureCheckSceneCapability fail!"); + return HDF_FAILURE; + } + } + *supported = true; + return HDF_SUCCESS; +#else + return HDF_ERR_NOT_SUPPORT; +#endif +} + +int32_t AudioCaptureSelectScene(AudioHandle handle, const struct AudioSceneDescriptor *scene) +{ + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL || scene == NULL) { + return HDF_FAILURE; + } + if (hwCapture->devCtlHandle == NULL) { + LOG_FUN_ERR("CaptureSelectScene Bind Fail!"); + return HDF_FAILURE; + } +#ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT + PathSelAnalysisJson *pPathSelAnalysisJson = AudioSoGetPathSelAnalysisJson(); + if (pPathSelAnalysisJson == NULL || *pPathSelAnalysisJson == NULL) { + LOG_FUN_ERR("pPathSelAnalysisJson Is NULL!"); + return HDF_ERR_NOT_SUPPORT; + } + enum AudioCategory typeTemp = hwCapture->captureParam.frameCaptureMode.attrs.type; + enum AudioPortPin pinsTemp = hwCapture->captureParam.captureMode.hwInfo.deviceDescript.pins; + hwCapture->captureParam.frameCaptureMode.attrs.type = (enum AudioCategory)(scene->scene.id); + hwCapture->captureParam.captureMode.hwInfo.deviceDescript.pins = scene->desc.pins; + if ((*pPathSelAnalysisJson)((void *)&hwCapture->captureParam, CAPTURE_PATH_SELECT) < 0) { + LOG_FUN_ERR("AudioCaptureSelectScene Fail!"); + hwCapture->captureParam.frameCaptureMode.attrs.type = typeTemp; + hwCapture->captureParam.captureMode.hwInfo.deviceDescript.pins = pinsTemp; + return HDF_FAILURE; + } + InterfaceLibModeCaptureSo *pInterfaceLibModeCapture = AudioSoGetInterfaceLibModeCapture(); + if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) { + LOG_FUN_ERR("pInterfaceLibModeCapture Is NULL"); + hwCapture->captureParam.frameCaptureMode.attrs.type = typeTemp; + hwCapture->captureParam.captureMode.hwInfo.deviceDescript.pins = pinsTemp; + return HDF_FAILURE; + } + int32_t ret = (*pInterfaceLibModeCapture)(hwCapture->devCtlHandle, &hwCapture->captureParam, + AUDIODRV_CTL_IOCTL_SCENESELECT_CAPTURE); + if (ret < 0) { + LOG_FUN_ERR("SetSelectSceneParams FAIL!"); + hwCapture->captureParam.frameCaptureMode.attrs.type = typeTemp; + hwCapture->captureParam.captureMode.hwInfo.deviceDescript.pins = pinsTemp; + return HDF_FAILURE; + } + return HDF_SUCCESS; +#else + return HDF_ERR_NOT_SUPPORT; +#endif +} + +int32_t AudioCaptureSetMute(AudioHandle handle, bool mute) +{ + LOG_FUN_INFO(); + struct AudioHwCapture *impl = (struct AudioHwCapture *)handle; + if (impl == NULL) { + return HDF_FAILURE; + } + if (impl->devCtlHandle == NULL) { + LOG_FUN_ERR("CaptureSetMute Bind Fail!"); + return HDF_FAILURE; + } + InterfaceLibModeCaptureSo *pInterfaceLibModeCapture = AudioSoGetInterfaceLibModeCapture(); + if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) { + LOG_FUN_ERR("pInterfaceLibModeCapture Fail!"); + return HDF_FAILURE; + } + bool muteStatus = impl->captureParam.captureMode.ctlParam.mute; + impl->captureParam.captureMode.ctlParam.mute = mute; + int32_t ret = (*pInterfaceLibModeCapture)(impl->devCtlHandle, &impl->captureParam, + AUDIODRV_CTL_IOCTL_MUTE_WRITE_CAPTURE); + if (ret < 0) { + LOG_FUN_ERR("SetMute SetParams FAIL"); + impl->captureParam.captureMode.ctlParam.mute = muteStatus; + return HDF_FAILURE; + } + LOG_PARA_INFO("SetMute SUCCESS!"); + return HDF_SUCCESS; +} + +int32_t AudioCaptureGetMute(AudioHandle handle, bool *mute) +{ + LOG_FUN_INFO(); + struct AudioHwCapture *impl = (struct AudioHwCapture *)handle; + if (impl == NULL || mute == NULL) { + return HDF_FAILURE; + } + if (impl->devCtlHandle == NULL) { + LOG_FUN_ERR("CaptureGetMute Bind Fail!"); + return HDF_FAILURE; + } + InterfaceLibModeCaptureSo *pInterfaceLibModeCapture = AudioSoGetInterfaceLibModeCapture(); + if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) { + LOG_FUN_ERR("pInterfaceLibModeCapture Fail!"); + return HDF_FAILURE; + } + int32_t ret = (*pInterfaceLibModeCapture)(impl->devCtlHandle, &impl->captureParam, + AUDIODRV_CTL_IOCTL_MUTE_READ_CAPTURE); + if (ret < 0) { + LOG_FUN_ERR("GetMute SetParams FAIL"); + return HDF_FAILURE; + } + *mute = impl->captureParam.captureMode.ctlParam.mute; + LOG_PARA_INFO("Get Mute SUCCESS!"); + return HDF_SUCCESS; +} + +int32_t AudioCaptureSetVolume(AudioHandle handle, float volume) +{ + LOG_FUN_INFO(); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL) { + return HDF_FAILURE; + } + float volumeTemp = hwCapture->captureParam.captureMode.ctlParam.volume; + float volMax = (float)hwCapture->captureParam.captureMode.ctlParam.volThreshold.volMax; + float volMin = (float)hwCapture->captureParam.captureMode.ctlParam.volThreshold.volMin; + if (hwCapture->devCtlHandle == NULL) { + LOG_FUN_ERR("Bind Fail!"); + return HDF_FAILURE; + } + if (volume < 0 || volume > 1) { + LOG_FUN_ERR("volume param Is error!"); + return HDF_FAILURE; + } + InterfaceLibModeCaptureSo *pInterfaceLibModeCapture = AudioSoGetInterfaceLibModeCapture(); + if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) { + LOG_FUN_ERR("pInterfaceLibModeCapture Fail!"); + return HDF_FAILURE; + } + volume = (volume == 0) ? 1 : (volume * VOLUME_CHANGE); + /* change volume to db */ + float volTemp = ((volMax - volMin) / 2) * log10(volume) + volMin; + if (volTemp < volMin || volTemp > volMax) { + LOG_FUN_ERR("volTemp fail"); + return HDF_FAILURE; + } + hwCapture->captureParam.captureMode.ctlParam.volume = volTemp; + int32_t ret = (*pInterfaceLibModeCapture)(hwCapture->devCtlHandle, &hwCapture->captureParam, + AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE); + if (ret < 0) { + LOG_FUN_ERR("SetParams FAIL!"); + hwCapture->captureParam.captureMode.ctlParam.volume = volumeTemp; + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCaptureGetVolume(AudioHandle handle, float *volume) +{ + LOG_FUN_INFO(); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (NULL == hwCapture || NULL == volume) { + return HDF_FAILURE; + } + if (hwCapture->devCtlHandle == NULL) { + LOG_FUN_ERR("CaptureStart Bind Fail!"); + return HDF_FAILURE; + } + InterfaceLibModeCaptureSo *pInterfaceLibModeCapture = AudioSoGetInterfaceLibModeCapture(); + if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) { + LOG_FUN_ERR("pInterfaceLibModeCapture Fail!"); + return HDF_FAILURE; + } + int ret = (*pInterfaceLibModeCapture)(hwCapture->devCtlHandle, &hwCapture->captureParam, + AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE); + if (ret < 0) { + LOG_FUN_ERR("Get Volume FAIL!"); + return HDF_FAILURE; + } + float volumeTemp = hwCapture->captureParam.captureMode.ctlParam.volume; + float volMax = (float)hwCapture->captureParam.captureMode.ctlParam.volThreshold.volMax; + float volMin = (float)hwCapture->captureParam.captureMode.ctlParam.volThreshold.volMin; + 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) + return HDF_SUCCESS; +} + +int32_t AudioCaptureGetGainThreshold(AudioHandle handle, float *min, float *max) +{ + LOG_FUN_INFO(); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle; + if (hwCapture == NULL || min == NULL || max == NULL) { + return HDF_FAILURE; + } + if (hwCapture->devCtlHandle == NULL) { + LOG_FUN_ERR("AudioCaptureGetGainThreshold Bind Fail!"); + return HDF_FAILURE; + } + InterfaceLibModeCaptureSo *pInterfaceLibModeCapture = AudioSoGetInterfaceLibModeCapture(); + if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) { + LOG_FUN_ERR("pInterfaceLibModeCapture Is NULL"); + return HDF_FAILURE; + } + int32_t ret = (*pInterfaceLibModeCapture)(hwCapture->devCtlHandle, &hwCapture->captureParam, + AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_CAPTURE); + if (ret < 0) { + LOG_FUN_ERR("SetParams FAIL!"); + return HDF_FAILURE; + } + *max = hwCapture->captureParam.captureMode.ctlParam.audioGain.gainMax; + *min = hwCapture->captureParam.captureMode.ctlParam.audioGain.gainMin; + return HDF_SUCCESS; +} + +int32_t AudioCaptureGetGain(AudioHandle handle, float *gain) +{ + LOG_FUN_INFO(); + struct AudioHwCapture *impl = (struct AudioHwCapture *)handle; + if (impl == NULL || gain == NULL) { + return HDF_FAILURE; + } + if (impl->devCtlHandle == NULL) { + LOG_FUN_ERR("CaptureStart Bind Fail!"); + return HDF_FAILURE; + } + InterfaceLibModeCaptureSo *pInterfaceLibModeCapture = AudioSoGetInterfaceLibModeCapture(); + if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) { + LOG_FUN_ERR("pInterfaceLibModeCapture Fail!"); + return HDF_FAILURE; + } + int32_t ret = (*pInterfaceLibModeCapture)(impl->devCtlHandle, &impl->captureParam, + AUDIODRV_CTL_IOCTL_GAIN_READ_CAPTURE); + if (ret < 0) { + LOG_FUN_ERR("Get Volume FAIL!"); + return HDF_FAILURE; + } + *gain = impl->captureParam.captureMode.ctlParam.audioGain.gain; + return HDF_SUCCESS; +} + +int32_t AudioCaptureSetGain(AudioHandle handle, float gain) +{ + LOG_FUN_INFO(); + struct AudioHwCapture *impl = (struct AudioHwCapture *)handle; + if (impl == NULL) { + return HDF_FAILURE; + } + if (impl->devCtlHandle == NULL) { + LOG_FUN_ERR("CaptureSetGain Bind Fail!"); + return HDF_FAILURE; + } + float gainTemp = impl->captureParam.captureMode.ctlParam.audioGain.gain; + impl->captureParam.captureMode.ctlParam.audioGain.gain = gain; + InterfaceLibModeCaptureSo *pInterfaceLibModeCapture = AudioSoGetInterfaceLibModeCapture(); + if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) { + LOG_FUN_ERR("pInterfaceLibModeCapture Fail!"); + impl->captureParam.captureMode.ctlParam.audioGain.gain = gainTemp; + return HDF_FAILURE; + } + int32_t ret = (*pInterfaceLibModeCapture)(impl->devCtlHandle, &impl->captureParam, + AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE); + if (ret < 0) { + LOG_FUN_ERR("CaptureSetGain FAIL!"); + impl->captureParam.captureMode.ctlParam.audioGain.gain = gainTemp; + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t TimeToAudioTimeStampCapture(int64_t *totalTime, struct AudioTimeStamp *time) +{ + if (totalTime == NULL || time == 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; + } + return HDF_SUCCESS; +} + +int32_t AudioCaptureCaptureFrame(struct AudioCapture *capture, void *frame, + uint64_t requestBytes, uint64_t *replyBytes) +{ + LOG_FUN_INFO(); + struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture; + if (hwCapture == NULL || frame == NULL || replyBytes == NULL || + hwCapture->captureParam.frameCaptureMode.buffer == NULL) { + LOG_FUN_ERR("Param is NULL Fail!"); + return HDF_FAILURE; + } + InterfaceLibModeCaptureSo *pInterfaceLibModeCapture = AudioSoGetInterfaceLibModeCapture(); + if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) { + LOG_FUN_ERR("pInterfaceLibModeCapture Fail!"); + return HDF_FAILURE; + } + 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!"); + return HDF_FAILURE; + } + if (requestBytes < hwCapture->captureParam.frameCaptureMode.bufferSize) { + LOG_FUN_ERR("Capture Frame requestBytes too little!"); + return HDF_FAILURE; + } + ret = memcpy_s(frame, requestBytes, hwCapture->captureParam.frameCaptureMode.buffer, + hwCapture->captureParam.frameCaptureMode.bufferSize); + if (ret != EOK) { + LOG_FUN_ERR("memcpy_s fail"); + return HDF_FAILURE; + } + *replyBytes = hwCapture->captureParam.frameCaptureMode.bufferSize; + hwCapture->captureParam.frameCaptureMode.frames += hwCapture->captureParam.frameCaptureMode.bufferFrameSize; + 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) { + LOG_FUN_ERR("Frame is NULL"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCaptureGetCapturePosition(struct AudioCapture *capture, uint64_t *frames, struct AudioTimeStamp *time) +{ + LOG_FUN_INFO(); + struct AudioHwCapture *impl = (struct AudioHwCapture *)capture; + if (impl == NULL || frames == NULL || time == NULL) { + return HDF_FAILURE; + } + *frames = impl->captureParam.frameCaptureMode.frames; + *time = impl->captureParam.frameCaptureMode.time; + + return HDF_SUCCESS; +} diff --git a/audio/hal/hdi_passthrough/src/audio_common.c b/audio/hal/hdi_passthrough/src/audio_common.c new file mode 100755 index 0000000000000000000000000000000000000000..69691b1b017dcb98d70b8fd19b6462784335d8eb --- /dev/null +++ b/audio/hal/hdi_passthrough/src/audio_common.c @@ -0,0 +1,86 @@ +/* + * 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_internal.h" +#include "osal_time.h" + +void AudioDlClose(void **ppHandleSo) +{ + if ((ppHandleSo != NULL) && ((*ppHandleSo) != NULL)) { + dlclose(*ppHandleSo); + *ppHandleSo = NULL; + } + return; +} + +void AudioMemFree(void **ppMem) +{ + if ((ppMem != NULL) && ((*ppMem) != NULL)) { + free(*ppMem); + *ppMem = NULL; + } + return; +} + +int32_t AudioGetSysTime(char *s, int32_t len) +{ + OsalTimespec time; + if (s == NULL) { + return -1; + } + OsalGetTime(&time); + s[0] = 0; + int32_t ret = snprintf_s(s, len, len - 1, "[%llu.%llu]", time.sec, time.usec); + return ret; +} + +int32_t AudioCheckParaAttr(const struct AudioSampleAttributes *attrs) +{ + 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; + } + enum AudioFormat audioFormat = attrs->format; + switch (audioFormat) { + case AUDIO_FORMAT_PCM_8_BIT: + case AUDIO_FORMAT_PCM_16_BIT: + case AUDIO_FORMAT_PCM_24_BIT: + case AUDIO_FORMAT_PCM_32_BIT: + 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: + return HDF_ERR_NOT_SUPPORT; + } + 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; + } +} diff --git a/audio/hal/hdi_passthrough/src/audio_manager.c b/audio/hal/hdi_passthrough/src/audio_manager.c new file mode 100755 index 0000000000000000000000000000000000000000..3d59e20f7237408b60c7fcbf8989364fd7e2681d --- /dev/null +++ b/audio/hal/hdi_passthrough/src/audio_manager.c @@ -0,0 +1,257 @@ +/* + * 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_adapter_info_common.h" +#include "audio_interface_lib_capture.h" +#include "audio_interface_lib_render.h" +#include "audio_internal.h" + +BindServiceRenderSo g_bindServiceRender = NULL; +InterfaceLibModeRenderSo g_interfaceLibModeRender = NULL; +CloseServiceRenderSo g_closeServiceRender = NULL; + +BindServiceCaptureSo g_bindServiceCapture = NULL; +InterfaceLibModeCaptureSo g_interfaceLibModeCapture = NULL; +CloseServiceCaptureSo g_closeServiceCapture = NULL; + +#ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT +PathSelGetConfToJsonObj g_pathSelGetConfToJsonObj = NULL; +PathSelAnalysisJson g_pathSelAnalysisJson = NULL; +#endif + +static char *g_captureSoPath = SO_INTERFACE_LIB_CAPTURE_PATH; +static char *g_renderSoPath = SO_INTERFACE_LIB_RENDER_PATH; + +#ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT +static char *g_pathSelectSoPath = SO_CJSON_LIB_PATHSELECT_PATH; +#endif + +static void *g_ptrCaptureHandle = NULL; +static void *g_ptrRenderHandle = NULL; + +#ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT +static void *g_ptrPathSelHandle = NULL; +#endif + +BindServiceRenderSo *AudioSoGetBindServiceRender() +{ + return &g_bindServiceRender; +} + +InterfaceLibModeRenderSo *AudioSoGetInterfaceLibModeRender() +{ + return &g_interfaceLibModeRender; +} + +CloseServiceRenderSo *AudioSoGetCloseServiceRender() +{ + return &g_closeServiceRender; +} + +BindServiceCaptureSo *AudioSoGetBindServiceCapture() +{ + return &g_bindServiceCapture; +} + +InterfaceLibModeCaptureSo *AudioSoGetInterfaceLibModeCapture() +{ + return &g_interfaceLibModeCapture; +} + +CloseServiceCaptureSo *AudioSoGetCloseServiceCapture() +{ + return &g_closeServiceCapture; +} + + +#ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT +PathSelGetConfToJsonObj *AudioSoGetPathSelGetConfToJsonObj() +{ + return &g_pathSelGetConfToJsonObj; +} + +PathSelAnalysisJson *AudioSoGetPathSelAnalysisJson() +{ + return &g_pathSelAnalysisJson; +} +#endif + +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"); + return HDF_FAILURE; + } + g_bindServiceCapture = dlsym(g_ptrCaptureHandle, "AudioBindServiceCapture"); + g_interfaceLibModeCapture = dlsym(g_ptrCaptureHandle, "AudioInterfaceLibModeCapture"); + g_closeServiceCapture = dlsym(g_ptrCaptureHandle, "AudioCloseServiceCapture"); + if (g_bindServiceCapture == NULL || g_interfaceLibModeCapture == NULL || g_closeServiceCapture == NULL) { + LOG_FUN_ERR("lib capture so func not found!"); + AudioDlClose(&g_ptrCaptureHandle); + return HDF_FAILURE; + } + } + return HDF_SUCCESS; +} + +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"); + return HDF_FAILURE; + } + g_bindServiceRender = dlsym(g_ptrRenderHandle, "AudioBindServiceRender"); + g_interfaceLibModeRender = dlsym(g_ptrRenderHandle, "AudioInterfaceLibModeRender"); + g_closeServiceRender = dlsym(g_ptrRenderHandle, "AudioCloseServiceRender"); + if (g_bindServiceRender == NULL || g_interfaceLibModeRender == NULL || g_closeServiceRender == NULL) { + LOG_FUN_ERR("lib render so func not found!"); + AudioDlClose(&g_ptrRenderHandle); + return HDF_FAILURE; + } + } + return HDF_SUCCESS; +} + +#ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT +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"); + return HDF_FAILURE; + } + g_pathSelGetConfToJsonObj = dlsym(g_ptrPathSelHandle, "AudioPathSelGetConfToJsonObj"); + g_pathSelAnalysisJson = dlsym(g_ptrPathSelHandle, "AudioPathSelAnalysisJson"); + if (g_pathSelGetConfToJsonObj == NULL || g_pathSelAnalysisJson == NULL) { + LOG_FUN_ERR("lib PathSelct so func not found!"); + AudioDlClose(&g_ptrPathSelHandle); + return HDF_FAILURE; + } + } + return HDF_SUCCESS; +} +#endif + +int32_t AudioManagerGetAllAdapters(struct AudioManager *manager, + struct AudioAdapterDescriptor **descs, + int *size) +{ + int32_t ret; + LOG_FUN_INFO(); + if (manager == NULL || descs == NULL || size == NULL) { + return HDF_FAILURE; + } + ret = AudioAdaptersForUser(descs, size); + if (ret < 0) { + LOG_FUN_ERR("AudioAdaptersForUser FAIL!"); + + return HDF_FAILURE; + } + ret = InitCaptureSoHandle(g_captureSoPath); + if (ret < 0) { + LOG_FUN_ERR("InitCaptureSoHandle FAIL!"); + return HDF_FAILURE; + } + ret = InitRenderSoHandle(g_renderSoPath); + if (ret < 0) { + LOG_FUN_ERR("InitRenderSoHandle FAIL!"); + AudioDlClose(&g_ptrCaptureHandle); + return HDF_FAILURE; + } +#ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT + ret = InitPathSelectSoHandle(g_pathSelectSoPath); + if (ret < 0) { + LOG_FUN_ERR("InitPathSelectSoHandle FAIL!"); + AudioDlClose(&g_ptrRenderHandle); + AudioDlClose(&g_ptrCaptureHandle); + return HDF_FAILURE; + } + ret = g_pathSelGetConfToJsonObj(); + if (ret < 0) { + LOG_FUN_ERR("g_pathSelGetConfToJsonObj FAIL!"); + AudioDlClose(&g_ptrRenderHandle); + AudioDlClose(&g_ptrCaptureHandle); + AudioDlClose(&g_ptrPathSelHandle); + return HDF_FAILURE; + } +#endif + return HDF_SUCCESS; +} + +int32_t AudioManagerLoadAdapter(struct AudioManager *manager, const struct AudioAdapterDescriptor *desc, + struct AudioAdapter **adapter) +{ + LOG_FUN_INFO(); + if (manager == NULL || desc == NULL || desc->adapterName == NULL || adapter == NULL) { + return HDF_FAILURE; + } + LOGV("%s: adapter name %s", __func__, desc->adapterName); + if (AudioAdapterExist(desc->adapterName)) { + LOGE("%s: not supported this adapter %s", __func__, desc->adapterName); + return HDF_FAILURE; + } + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)calloc(1, sizeof(*hwAdapter)); + if (hwAdapter == NULL) { + LOGE("%s: calloc AudioHwAdapter failed", __func__); + return -ENOMEM; + } + hwAdapter->common.InitAllPorts = AudioAdapterInitAllPorts; + hwAdapter->common.CreateRender = AudioAdapterCreateRender; + hwAdapter->common.DestroyRender = AudioAdapterDestroyRender; + hwAdapter->common.CreateCapture = AudioAdapterCreateCapture; + hwAdapter->common.DestroyCapture = AudioAdapterDestroyCapture; + hwAdapter->common.GetPortCapability = AudioAdapterGetPortCapability; + hwAdapter->common.SetPassthroughMode = AudioAdapterSetPassthroughMode; + hwAdapter->common.GetPassthroughMode = AudioAdapterGetPassthroughMode; + *adapter = &hwAdapter->common; + hwAdapter->adapterDescriptor = *desc; + return HDF_SUCCESS; +} + +void AudioManagerUnloadAdapter(struct AudioManager *manager, struct AudioAdapter *adapter) +{ + struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter; + if (manager == NULL || hwAdapter == NULL) { + return; + } + if (hwAdapter->portCapabilitys != NULL) { + int32_t portNum = hwAdapter->adapterDescriptor.portNum; + int32_t i = 0; + while (i < portNum) { + if (&hwAdapter->portCapabilitys[i] != NULL) { + AudioMemFree((void **)&hwAdapter->portCapabilitys[i].capability.subPorts); + } + i++; + } + AudioMemFree((void **)&hwAdapter->portCapabilitys); + } + AudioMemFree((void **)&adapter); +} + +static struct AudioManager g_audioManagerFuncs = { + .GetAllAdapters = AudioManagerGetAllAdapters, + .LoadAdapter = AudioManagerLoadAdapter, + .UnloadAdapter = AudioManagerUnloadAdapter, +}; + +struct AudioManager *GetAudioManagerFuncs(void) +{ + return &g_audioManagerFuncs; +} diff --git a/audio/hal/hdi_passthrough/src/audio_render.c b/audio/hal/hdi_passthrough/src/audio_render.c new file mode 100755 index 0000000000000000000000000000000000000000..21267b357e635d93cbf9f8c558e8af41f46a8dd7 --- /dev/null +++ b/audio/hal/hdi_passthrough/src/audio_render.c @@ -0,0 +1,759 @@ +/* + * 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_internal.h" +#include "audio_interface_lib_render.h" +#include "audio_render.h" + +#define CONFIG_OUT_LATENCY_MS 100 // unit: ms + +/* 1 buffer: 8000(8kHz sample rate) * 2(bytes, PCM_16_BIT) * 1(channel) */ +/* 1 frame: 1024(sample) * 2(bytes, PCM_16_BIT) * 1(channel) */ +#define CONFIG_FRAME_SIZE (1024 * 2 * 1) +#define FRAME_SIZE 1024 +#define CONFIG_FRAME_COUNT ((8000 * 2 * 1 + (CONFIG_FRAME_SIZE - 1)) / CONFIG_FRAME_SIZE) + +#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) { + return HDF_SUCCESS; + } + uint32_t formatBits = 0; + int32_t ret = FormatToBits(frameRenderMode->attrs.format, &formatBits); + if (ret != HDF_SUCCESS) { + return ret; + } + *frameCount = bytes / (frameRenderMode->attrs.channelCount * + (formatBits >> 3)); // Adapter num max is 3 + return HDF_SUCCESS; +} + +int32_t AudioRenderStart(AudioHandle handle) +{ + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + 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->renderParam.frameRenderMode.buffer != NULL) { + LOG_FUN_ERR("AudioRender already start!"); + return HDF_FAILURE; + } + if (hwRender->devDataHandle == NULL) { + return HDF_FAILURE; + } + int32_t ret = (*pInterfaceLibModeRender)(hwRender->devDataHandle, &hwRender->renderParam, + AUDIO_DRV_PCM_IOCTRL_START); + if (ret < 0) { + LOG_FUN_ERR("AudioRenderStart SetParams FAIL"); + return HDF_FAILURE; + } + char *buffer = (char *)calloc(1, FRAME_DATA); + if (buffer == NULL) { + LOG_FUN_ERR("Calloc Render buffer Fail!"); + return HDF_FAILURE; + } + hwRender->renderParam.frameRenderMode.buffer = buffer; + LOG_PARA_INFO("Render Start SUCCESS!"); + return HDF_SUCCESS; +} + +int32_t AudioRenderStop(AudioHandle handle) +{ + LOG_FUN_INFO(); + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL) { + return HDF_FAILURE; + } + 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) { + LOG_FUN_ERR("RenderStart Bind Fail!"); + return HDF_FAILURE; + } + InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender(); + if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) { + LOG_FUN_ERR("pInterfaceLibModeRender Is NULL"); + return HDF_FAILURE; + } + int32_t ret = (*pInterfaceLibModeRender)(hwRender->devDataHandle, &hwRender->renderParam, + AUDIO_DRV_PCM_IOCTRL_STOP); + if (ret < 0) { + LOG_FUN_ERR("AudioRenderStart SetParams FAIL"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioRenderPause(AudioHandle handle) +{ + LOG_FUN_INFO(); + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL) { + return HDF_FAILURE; + } + if (hwRender->renderParam.frameRenderMode.buffer == NULL) { + LOG_FUN_ERR("AudioRender already stop!"); + return HDF_FAILURE; + } + if (hwRender->renderParam.renderMode.ctlParam.pause) { + LOG_FUN_ERR("Audio is already pause!"); + return HDF_FAILURE; + } + if (hwRender->devDataHandle == NULL) { + LOG_FUN_ERR("RenderPause Bind Fail!"); + return HDF_FAILURE; + } + InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender(); + if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) { + LOG_FUN_ERR("pInterfaceLibModeRender Is NULL"); + return HDF_FAILURE; + } + bool pauseStatus = hwRender->renderParam.renderMode.ctlParam.pause; + hwRender->renderParam.renderMode.ctlParam.pause = true; + int32_t ret = (*pInterfaceLibModeRender)(hwRender->devDataHandle, &hwRender->renderParam, + AUDIODRV_CTL_IOCTL_PAUSE_WRITE); + if (ret < 0) { + LOG_FUN_ERR("RenderPause FAIL!"); + hwRender->renderParam.renderMode.ctlParam.pause = pauseStatus; + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioRenderResume(AudioHandle handle) +{ + LOG_FUN_INFO(); + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL) { + return HDF_FAILURE; + } + if (!hwRender->renderParam.renderMode.ctlParam.pause) { + LOG_FUN_ERR("Audio is already Resume !"); + return HDF_FAILURE; + } + if (hwRender->devDataHandle == NULL) { + LOG_FUN_ERR("RenderResume Bind Fail!"); + return HDF_FAILURE; + } + InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender(); + if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) { + LOG_FUN_ERR("pInterfaceLibModeRender Is NULL"); + return HDF_FAILURE; + } + bool resumeStatus = hwRender->renderParam.renderMode.ctlParam.pause; + hwRender->renderParam.renderMode.ctlParam.pause = false; + int32_t ret = (*pInterfaceLibModeRender)(hwRender->devDataHandle, &hwRender->renderParam, + AUDIODRV_CTL_IOCTL_PAUSE_WRITE); + if (ret < 0) { + LOG_FUN_ERR("RenderResume FAIL!"); + hwRender->renderParam.renderMode.ctlParam.pause = resumeStatus; + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioRenderFlush(AudioHandle handle) +{ + LOG_FUN_INFO(); + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL) { + return HDF_FAILURE; + } + return HDF_ERR_NOT_SUPPORT; +} + +int32_t AudioRenderGetFrameSize(AudioHandle handle, uint64_t *size) +{ + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL || size == NULL) { + return HDF_FAILURE; + } + uint32_t channelCount = hwRender->renderParam.frameRenderMode.attrs.channelCount; + enum AudioFormat format = hwRender->renderParam.frameRenderMode.attrs.format; + uint32_t formatBits = 0; + int32_t ret = FormatToBits(format, &formatBits); + if (ret != HDF_SUCCESS) { + return ret; + } + *size = FRAME_SIZE * channelCount * (formatBits >> 3); + return HDF_SUCCESS; +} + +int32_t AudioRenderGetFrameCount(AudioHandle handle, uint64_t *count) +{ + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL || count == NULL) { + return HDF_FAILURE; + } + *count = hwRender->renderParam.frameRenderMode.frames; + return HDF_SUCCESS; +} + +int32_t AudioRenderSetSampleAttributes(AudioHandle handle, const struct AudioSampleAttributes *attrs) +{ + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL || attrs == NULL) { + return HDF_FAILURE; + } + int32_t ret = AudioCheckParaAttr(attrs); + if (ret != HDF_SUCCESS) { + return ret; + } + /* attrs temp */ + struct AudioSampleAttributes tempAttrs = hwRender->renderParam.frameRenderMode.attrs; + hwRender->renderParam.frameRenderMode.attrs.format = attrs->format; + hwRender->renderParam.frameRenderMode.attrs.sampleRate = attrs->sampleRate; + hwRender->renderParam.frameRenderMode.attrs.channelCount = attrs->channelCount; + hwRender->renderParam.frameRenderMode.attrs.interleaved = attrs->interleaved; + hwRender->renderParam.frameRenderMode.attrs.type = attrs->type; + hwRender->renderParam.frameRenderMode.attrs.period = attrs->period; + hwRender->renderParam.frameRenderMode.attrs.frameSize = attrs->frameSize; + hwRender->renderParam.frameRenderMode.attrs.isBigEndian = attrs->isBigEndian; + hwRender->renderParam.frameRenderMode.attrs.isSignedData = attrs->isSignedData; + hwRender->renderParam.frameRenderMode.attrs.startThreshold = attrs->startThreshold; + hwRender->renderParam.frameRenderMode.attrs.stopThreshold = attrs->stopThreshold; + hwRender->renderParam.frameRenderMode.attrs.silenceThreshold = attrs->silenceThreshold; + InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender(); + if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) { + hwRender->renderParam.frameRenderMode.attrs = tempAttrs; + LOG_FUN_ERR("pInterfaceLibModeRender Is NULL"); + return HDF_FAILURE; + } + ret = (*pInterfaceLibModeRender)(hwRender->devDataHandle, + &hwRender->renderParam, + AUDIO_DRV_PCM_IOCTL_HW_PARAMS); + if (ret < 0) { + LOG_FUN_ERR("SetSampleAttributes FAIL"); + hwRender->renderParam.frameRenderMode.attrs = tempAttrs; + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioRenderGetSampleAttributes(AudioHandle handle, struct AudioSampleAttributes *attrs) +{ + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL || attrs == NULL) { + return HDF_FAILURE; + } + attrs->format = hwRender->renderParam.frameRenderMode.attrs.format; + attrs->sampleRate = hwRender->renderParam.frameRenderMode.attrs.sampleRate; + attrs->channelCount = hwRender->renderParam.frameRenderMode.attrs.channelCount; + attrs->type = hwRender->renderParam.frameRenderMode.attrs.type; + attrs->interleaved = hwRender->renderParam.frameRenderMode.attrs.interleaved; + attrs->period = hwRender->renderParam.frameRenderMode.attrs.period; + attrs->frameSize = hwRender->renderParam.frameRenderMode.attrs.frameSize; + attrs->isBigEndian = hwRender->renderParam.frameRenderMode.attrs.isBigEndian; + attrs->isSignedData = hwRender->renderParam.frameRenderMode.attrs.isSignedData; + attrs->startThreshold = hwRender->renderParam.frameRenderMode.attrs.startThreshold; + attrs->stopThreshold = hwRender->renderParam.frameRenderMode.attrs.stopThreshold; + attrs->silenceThreshold = hwRender->renderParam.frameRenderMode.attrs.silenceThreshold; + return HDF_SUCCESS; +} + +int32_t AudioRenderGetCurrentChannelId(AudioHandle handle, uint32_t *channelId) +{ + LOG_FUN_INFO(); + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL || channelId == NULL) { + return HDF_FAILURE; + } + *channelId = hwRender->renderParam.frameRenderMode.attrs.channelCount; + return HDF_SUCCESS; +} + +int32_t AudioRenderCheckSceneCapability(AudioHandle handle, const struct AudioSceneDescriptor *scene, + bool *supported) +{ + LOG_FUN_INFO(); + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL || scene == NULL || supported == NULL) { + return HDF_FAILURE; + } +#ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT + *supported = false; + /* Temporary storage does not save the structure */ + struct AudioHwRenderParam renderParam; + renderParam.frameRenderMode.attrs.type = (enum AudioCategory)scene->scene.id; + renderParam.renderMode.hwInfo.deviceDescript.pins = scene->desc.pins; + PathSelAnalysisJson *pPathSelAnalysisJson = AudioSoGetPathSelAnalysisJson(); + if (pPathSelAnalysisJson == NULL) { + LOG_FUN_ERR("pPathSelAnalysisJson Is NULL!"); + return HDF_ERR_NOT_SUPPORT; + } + int ret = (*pPathSelAnalysisJson)((void *)&renderParam, CHECKSCENE_PATH_SELECT); + if (ret < 0) { + if (ret == HDF_ERR_NOT_SUPPORT) { + LOG_FUN_ERR("AudioRenderCheckSceneCapability not Support!"); + return HDF_ERR_NOT_SUPPORT; + } else { + LOG_FUN_ERR("AudioRenderCheckSceneCapability fail!"); + return HDF_FAILURE; + } + } + *supported = true; + return HDF_SUCCESS; +#else + return HDF_ERR_NOT_SUPPORT; +#endif +} + +int32_t AudioRenderSelectScene(AudioHandle handle, const struct AudioSceneDescriptor *scene) +{ + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL || scene == NULL) { + return HDF_FAILURE; + } + if (hwRender->devCtlHandle == NULL) { + LOG_FUN_ERR("RenderSelectScene Bind Fail!"); + return HDF_FAILURE; + } +#ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT + PathSelAnalysisJson *pPathSelAnalysisJson = AudioSoGetPathSelAnalysisJson(); + if (pPathSelAnalysisJson == NULL) { + LOG_FUN_ERR("pPathSelAnalysisJson Is NULL!"); + return HDF_ERR_NOT_SUPPORT; + } + enum AudioCategory sceneId = hwRender->renderParam.frameRenderMode.attrs.type; + enum AudioPortPin descPins = hwRender->renderParam.renderMode.hwInfo.deviceDescript.pins; + hwRender->renderParam.frameRenderMode.attrs.type = (enum AudioCategory)(scene->scene.id); + hwRender->renderParam.renderMode.hwInfo.deviceDescript.pins = scene->desc.pins; + if ((*pPathSelAnalysisJson)((void *)&hwRender->renderParam, RENDER_PATH_SELECT) < 0) { + LOG_FUN_ERR("AudioRenderSelectScene Fail!"); + hwRender->renderParam.frameRenderMode.attrs.type = sceneId; + hwRender->renderParam.renderMode.hwInfo.deviceDescript.pins = descPins; + return HDF_FAILURE; + } + InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender(); + if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) { + LOG_FUN_ERR("pInterfaceLibModeRender Is NULL"); + hwRender->renderParam.frameRenderMode.attrs.type = sceneId; + hwRender->renderParam.renderMode.hwInfo.deviceDescript.pins = descPins; + return HDF_FAILURE; + } + int32_t ret = (*pInterfaceLibModeRender)(hwRender->devCtlHandle, &hwRender->renderParam, + AUDIODRV_CTL_IOCTL_SCENESELECT_WRITE); + if (ret < 0) { + LOG_FUN_ERR("SetParams FAIL!"); + hwRender->renderParam.frameRenderMode.attrs.type = sceneId; + hwRender->renderParam.renderMode.hwInfo.deviceDescript.pins = descPins; + return HDF_FAILURE; + } + return HDF_SUCCESS; +#else + return HDF_ERR_NOT_SUPPORT; +#endif +} + +int32_t AudioRenderSetMute(AudioHandle handle, bool mute) +{ + struct AudioHwRender *impl = (struct AudioHwRender *)handle; + if (impl == NULL) { + return HDF_FAILURE; + } + if (impl->devCtlHandle == NULL) { + LOG_FUN_ERR("RenderSetMute Bind Fail!"); + return HDF_FAILURE; + } + InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender(); + if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) { + LOG_FUN_ERR("pInterfaceLibModeRender Is NULL"); + return HDF_FAILURE; + } + bool muteStatus = impl->renderParam.renderMode.ctlParam.mute; + impl->renderParam.renderMode.ctlParam.mute = mute; + int32_t ret = (*pInterfaceLibModeRender)(impl->devCtlHandle, &impl->renderParam, AUDIODRV_CTL_IOCTL_MUTE_WRITE); + if (ret < 0) { + LOG_FUN_ERR("SetMute SetParams FAIL"); + impl->renderParam.renderMode.ctlParam.mute = muteStatus; + return HDF_FAILURE; + } + LOG_PARA_INFO("SetMute SUCCESS!"); + return HDF_SUCCESS; +} + +int32_t AudioRenderGetMute(AudioHandle handle, bool *mute) +{ + struct AudioHwRender *impl = (struct AudioHwRender *)handle; + if (impl == NULL || mute == NULL) { + return HDF_FAILURE; + } + + if (impl->devCtlHandle == NULL) { + LOG_FUN_ERR("RenderGetMute Bind Fail!"); + return HDF_FAILURE; + } + InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender(); + if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) { + LOG_FUN_ERR("pInterfaceLibModeRender Is NULL"); + return HDF_FAILURE; + } + int32_t ret = (*pInterfaceLibModeRender)(impl->devCtlHandle, &impl->renderParam, AUDIODRV_CTL_IOCTL_MUTE_READ); + if (ret < 0) { + LOG_FUN_ERR("Get Mute FAIL!"); + return HDF_FAILURE; + } + *mute = impl->renderParam.renderMode.ctlParam.mute; + LOG_PARA_INFO("GetMute SUCCESS!"); + return HDF_SUCCESS; +} + +int32_t AudioRenderSetVolume(AudioHandle handle, float volume) +{ + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (hwRender == NULL) { + return HDF_FAILURE; + } + 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 (volume < 0 || volume > 1) { + LOG_FUN_ERR("volume param Is error!"); + return HDF_FAILURE; + } + if (hwRender->devCtlHandle == NULL) { + LOG_FUN_ERR("RenderSetVolume Bind Fail!"); + return HDF_FAILURE; + } + InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender(); + if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) { + LOG_FUN_ERR("pInterfaceLibModeRender Is NULL"); + return HDF_FAILURE; + } + volume = (volume == 0) ? 1 : (volume * VOLUME_CHANGE); + /* change volume to db */ + float volTemp = ((volMax - volMin) / 2) * log10(volume) + volMin; + if (volTemp < volMin || volTemp > volMax) { + LOG_FUN_ERR("volTemp fail"); + return HDF_FAILURE; + } + hwRender->renderParam.renderMode.ctlParam.volume = volTemp; + int32_t ret = (*pInterfaceLibModeRender)(hwRender->devCtlHandle, &hwRender->renderParam, + AUDIODRV_CTL_IOCTL_ELEM_WRITE); + if (ret < 0) { + LOG_FUN_ERR("RenderSetVolume FAIL!"); + hwRender->renderParam.renderMode.ctlParam.volume = volumeTemp; + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioRenderGetVolume(AudioHandle handle, float *volume) +{ + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (NULL == hwRender || NULL == volume) { + return HDF_FAILURE; + } + if (hwRender->devCtlHandle == NULL) { + LOG_FUN_ERR("RenderGetVolume Bind Fail!"); + return HDF_FAILURE; + } + InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender(); + if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) { + LOG_FUN_ERR("pInterfaceLibModeRender Is NULL"); + return HDF_FAILURE; + } + int ret = (*pInterfaceLibModeRender)(hwRender->devCtlHandle, &hwRender->renderParam, AUDIODRV_CTL_IOCTL_ELEM_READ); + if (ret < 0) { + LOG_FUN_ERR("RenderGetVolume FAIL!"); + return HDF_FAILURE; + } + 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; + 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) + return HDF_SUCCESS; +} + +int32_t AudioRenderGetGainThreshold(AudioHandle handle, float *min, float *max) +{ + LOG_FUN_INFO(); + struct AudioHwRender *hwRender = (struct AudioHwRender *)handle; + if (NULL == hwRender || NULL == min || NULL == max) { + return HDF_FAILURE; + } + if (hwRender->devCtlHandle == NULL) { + LOG_FUN_ERR("RenderGetGainThreshold Bind Fail!"); + return HDF_FAILURE; + } + InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender(); + if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) { + LOG_FUN_ERR("pInterfaceLibModeRender Is NULL"); + return HDF_FAILURE; + } + int32_t ret = (*pInterfaceLibModeRender)(hwRender->devCtlHandle, &hwRender->renderParam, + AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ); + if (ret < 0) { + LOG_FUN_ERR("SetParams FAIL!"); + return HDF_FAILURE; + } + *max = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMax; + *min = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMin; + return HDF_SUCCESS; +} + +int32_t AudioRenderGetGain(AudioHandle handle, float *gain) +{ + LOG_FUN_INFO(); + struct AudioHwRender *impl = (struct AudioHwRender *)handle; + if (impl == NULL || gain == NULL) { + return HDF_FAILURE; + } + if (impl->devCtlHandle == NULL) { + LOG_FUN_ERR("RenderGetGain Bind Fail!"); + return HDF_FAILURE; + } + InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender(); + if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) { + LOG_FUN_ERR("pInterfaceLibModeRender Is NULL"); + return HDF_FAILURE; + } + int32_t ret = (*pInterfaceLibModeRender)(impl->devCtlHandle, &impl->renderParam, AUDIODRV_CTL_IOCTL_GAIN_READ); + if (ret < 0) { + LOG_FUN_ERR("RenderGetGain FAIL"); + return HDF_FAILURE; + } + *gain = impl->renderParam.renderMode.ctlParam.audioGain.gain; + LOG_PARA_INFO("RenderGetGain SUCCESS!"); + return HDF_SUCCESS; +} + +int32_t AudioRenderSetGain(AudioHandle handle, float gain) +{ + LOG_FUN_INFO(); + struct AudioHwRender *impl = (struct AudioHwRender *)handle; + if (impl == NULL) { + return HDF_FAILURE; + } + float gainTemp = impl->renderParam.renderMode.ctlParam.audioGain.gain; + impl->renderParam.renderMode.ctlParam.audioGain.gain = gain; + if (impl->devCtlHandle == NULL) { + LOG_FUN_ERR("RenderSetGain Bind Fail!"); + impl->renderParam.renderMode.ctlParam.audioGain.gain = gainTemp; + return HDF_FAILURE; + } + InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender(); + if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) { + LOG_FUN_ERR("pInterfaceLibModeRender Is NULL"); + impl->renderParam.renderMode.ctlParam.audioGain.gain = gainTemp; + return HDF_FAILURE; + } + int32_t ret = (*pInterfaceLibModeRender)(impl->devCtlHandle, &impl->renderParam, AUDIODRV_CTL_IOCTL_GAIN_WRITE); + if (ret < 0) { + LOG_FUN_ERR("RenderSetGain FAIL"); + impl->renderParam.renderMode.ctlParam.audioGain.gain = gainTemp; + return HDF_FAILURE; + } + LOG_PARA_INFO("RenderSetGain SUCCESS!"); + return HDF_SUCCESS; +} + +int32_t AudioRenderGetLatency(struct AudioRender *render, uint32_t *ms) +{ + struct AudioHwRender *impl = (struct AudioHwRender *)render; + if (impl == NULL || ms == NULL) { + return HDF_FAILURE; + } + uint32_t byteRate = impl->renderParam.frameRenderMode.byteRate; + uint32_t periodSize = impl->renderParam.frameRenderMode.periodSize; + uint32_t periodCount = impl->renderParam.frameRenderMode.periodCount; + uint32_t period_ms = (periodCount * periodSize * 1000) / byteRate; + *ms = period_ms; + return HDF_SUCCESS; +} + +int32_t TimeToAudioTimeStamp(int64_t *totalTime, struct AudioTimeStamp *time) +{ + if (totalTime == NULL || time == 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; + } + return HDF_SUCCESS; +} + +int32_t AudioRenderRenderFrame(struct AudioRender *render, const void *frame, + uint64_t requestBytes, uint64_t *replyBytes) +{ + LOG_FUN_INFO(); + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + if (hwRender == NULL || frame == NULL || replyBytes == NULL || + hwRender->renderParam.frameRenderMode.buffer == NULL) { + LOG_FUN_ERR("Render Frame Paras is NULL!"); + return HDF_FAILURE; + } + if (FRAME_DATA < requestBytes) { + 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); + if (ret != EOK) { + LOG_FUN_ERR("memcpy_s fail"); + return HDF_FAILURE; + } + hwRender->renderParam.frameRenderMode.bufferSize = requestBytes; + uint32_t frameCount = 0; + ret = PcmBytesToFrames(&hwRender->renderParam.frameRenderMode, requestBytes, &frameCount); + if (ret != HDF_SUCCESS) { + return ret; + } + hwRender->renderParam.frameRenderMode.bufferFrameSize = (uint64_t)frameCount; + InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender(); + if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) { + LOG_FUN_ERR("pInterfaceLibModeRender Is NULL"); + 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) { + LOG_FUN_ERR("Frame is NULL"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioRenderGetRenderPosition(struct AudioRender *render, uint64_t *frames, struct AudioTimeStamp *time) +{ + struct AudioHwRender *impl = (struct AudioHwRender *)render; + if (impl == NULL || frames == NULL || time == NULL) { + return HDF_FAILURE; + } + *frames = impl->renderParam.frameRenderMode.frames; + *time = impl->renderParam.frameRenderMode.time; + return HDF_SUCCESS; +} + +int32_t AudioRenderSetRenderSpeed(struct AudioRender *render, float speed) +{ + LOG_FUN_INFO(); + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + if (hwRender == NULL) { + return HDF_FAILURE; + } + return HDF_ERR_NOT_SUPPORT; +} + +int32_t AudioRenderGetRenderSpeed(struct AudioRender *render, float *speed) +{ + LOG_FUN_INFO(); + struct AudioHwRender *hwRender = (struct AudioHwRender *)render; + if (hwRender == NULL || speed == NULL) { + return HDF_FAILURE; + } + return HDF_ERR_NOT_SUPPORT; +} + +int32_t AudioRenderSetChannelMode(struct AudioRender *render, enum AudioChannelMode mode) +{ + LOG_FUN_INFO(); + struct AudioHwRender *impl = (struct AudioHwRender *)render; + if (impl == NULL) { + return HDF_FAILURE; + } + if (impl->devCtlHandle == NULL) { + LOG_FUN_ERR("Bind Fail!"); + return HDF_FAILURE; + } + enum AudioChannelMode tempMode = impl->renderParam.frameRenderMode.mode; + impl->renderParam.frameRenderMode.mode = mode; + InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender(); + if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) { + LOG_FUN_ERR("pInterfaceLibModeRender Is NULL"); + impl->renderParam.frameRenderMode.mode = tempMode; + return HDF_FAILURE; + } + int32_t ret = (*pInterfaceLibModeRender)(impl->devCtlHandle, &impl->renderParam, + AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE); + if (ret < 0) { + LOG_FUN_ERR("SetParams FAIL!"); + impl->renderParam.frameRenderMode.mode = tempMode; + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioRenderGetChannelMode(struct AudioRender *render, enum AudioChannelMode *mode) +{ + LOG_FUN_INFO(); + struct AudioHwRender *impl = (struct AudioHwRender *)render; + if (impl == NULL || mode == NULL) { + return HDF_FAILURE; + } + InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender(); + if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) { + LOG_FUN_ERR("pInterfaceLibModeRender Is NULL"); + return HDF_FAILURE; + } + int ret = (*pInterfaceLibModeRender)(impl->devCtlHandle, &impl->renderParam, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ); + if (ret < 0) { + LOG_FUN_ERR("Get ChannelMode FAIL!"); + return HDF_FAILURE; + } + *mode = impl->renderParam.frameRenderMode.mode; + return HDF_SUCCESS; +} diff --git a/audio/hal/pathselect/include/audio_pathselect.h b/audio/hal/pathselect/include/audio_pathselect.h new file mode 100755 index 0000000000000000000000000000000000000000..969b1596e8a420de977d1d6fae1c8e45612c533e --- /dev/null +++ b/audio/hal/pathselect/include/audio_pathselect.h @@ -0,0 +1,34 @@ +/* + * 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_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" + +#define CJSONFILE_CONFIG_PATH "/system/etc/hdfconfig/parse.json" + +int32_t AudioPathSelGetConfToJsonObj(); +int32_t AudioPathSelAnalysisJson(void *adapterParam, enum AudioAdaptType adaptType); + +#endif + diff --git a/audio/hal/pathselect/src/BUILD.gn b/audio/hal/pathselect/src/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..fef400147c7041a176acc1e0f223ccb8ba68c6a2 --- /dev/null +++ b/audio/hal/pathselect/src/BUILD.gn @@ -0,0 +1,94 @@ +# 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("pathseltct_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("hdi_audio_path_select") { + 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" + ] + + 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 = [ ":pathseltct_config" ] + + subsystem_name = "hdf" +} \ No newline at end of file diff --git a/audio/hal/pathselect/src/audio_pathselect.c b/audio/hal/pathselect/src/audio_pathselect.c new file mode 100755 index 0000000000000000000000000000000000000000..a49220aed163d289282ef5d8b98d544c38bb2d07 --- /dev/null +++ b/audio/hal/pathselect/src/audio_pathselect.c @@ -0,0 +1,561 @@ +/* + * 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_pathselect.h" + +#define SPEAKER "Speaker" +#define HEADPHONES "headphones" +#define MIC "mic" +#define HS_MIC "micHs" +#define JSON_UNPRINT 1 + +static cJSON *g_cJsonObj; + +/* Depend on Audio_types.h : enum AudioCategory */ +enum AudioCategoryPathSel { + PATH_USE_IN_MEDIA = 0, + PATH_USE_IN_COMMUNICATION, + PATH_USE_TYPE_MAX, +}; + +enum AudioPortPinPathSel { + PATH_DEV_NONE = 0x0u, /**< Invalid pin */ + PATH_DEV_OUT_SPEAKER = 0x1u, /**< Speaker output pin */ + PATH_DEV_OUT_HEADSET = 0x2u, /**< Wired headset pin for output */ + PATH_DEV_OUT_LINEOUT = 0x4u, /**< Line-out pin */ + PATH_DEV_OUT_HDMI = 0x8u, /**< HDMI output pin */ + PATH_DEV_MID = 0x8000000u, /**< Microphone input pin */ + PATH_DEV_IN_MIC = 0x8000001u, /**< Microphone input pin */ + PATH_DEV_IN_HS_MIC = 0x8000002u, /**< Wired headset microphone pin for input */ + PATH_DEV_IN_LINEIN = 0x8000004u, /**< Line-in pin */ + PATH_DEV_MAX, +}; + +int32_t AudioPathSelGetConfToJsonObj() +{ + LOG_FUN_INFO(); + FILE *fpJson = NULL; + char *pJsonStr = NULL; + fpJson = fopen(CJSONFILE_CONFIG_PATH, "r"); + if (NULL == fpJson) { + LOG_FUN_ERR("parse.json file fail!"); + return HDF_FAILURE; + } + fseek(fpJson, 0, SEEK_END); + int32_t jsonStrSize = ftell(fpJson); + rewind(fpJson); + pJsonStr = (char *)calloc(1, jsonStrSize); + if (NULL == pJsonStr) { + fclose(fpJson); + return HDF_FAILURE; + } + if (fread(pJsonStr, jsonStrSize, 1, fpJson) != 1) { + LOG_FUN_ERR("read to file fail!"); + fclose(fpJson); + fpJson = NULL; + AudioMemFree((void **)&pJsonStr); + return HDF_FAILURE; + } + fclose(fpJson); + fpJson = NULL; +#ifndef JSON_UNPRINT + LOG_PARA_INFO("pJsonStr = %s", pJsonStr); +#endif + g_cJsonObj = cJSON_Parse(pJsonStr); + if (NULL == g_cJsonObj) { + LOG_FUN_ERR("cJSON_GetErrorPtr() = %s", cJSON_GetErrorPtr()); + AudioMemFree((void **)&pJsonStr); + return HDF_FAILURE; + } + AudioMemFree((void **)&pJsonStr); + return HDF_SUCCESS; +} + +static const char *AudioPathSelGetDeviceType(enum AudioPortPin pins) +{ + if (pins < PATH_DEV_NONE || pins > PATH_DEV_MAX) { + return NULL; + } + switch (pins) { + case PATH_DEV_OUT_SPEAKER: + return SPEAKER; + case PATH_DEV_OUT_HEADSET: + return HEADPHONES; + case PATH_DEV_IN_MIC: + return MIC; + case PATH_DEV_IN_HS_MIC: + return HS_MIC; + default: + LOG_FUN_ERR("UseCase not support!"); + break; + } + return NULL; +} + +const char *AudioPathSelGetUseCase(enum AudioCategory type) +{ + static const char *usecaseType[PATH_USE_TYPE_MAX + 1] = { + [PATH_USE_IN_MEDIA] = "deep-buffer-playback", + [PATH_USE_IN_COMMUNICATION] = "low-latency-playback", + [PATH_USE_TYPE_MAX] = "none", + }; + + if (type < 0 || type > PATH_USE_TYPE_MAX) { + return NULL; + } + return usecaseType[type]; +} + +static int32_t AudioPathSelGetPlanRenderScene(struct AudioHwRenderParam *renderSceneParam) +{ + LOG_FUN_INFO(); + int32_t ret; + if (renderSceneParam == NULL) { + LOG_FUN_ERR("AudioPathSelGetPlanRenderScene param Is NULL"); + return HDF_FAILURE; + } + char pathName[PATH_NAME_LEN] = {0}; + enum AudioPortPin pins = renderSceneParam->renderMode.hwInfo.deviceDescript.pins; + if (pins >= PATH_DEV_MAX || pins < PATH_DEV_NONE) { + LOG_FUN_ERR("deviceDescript pins error!"); + return HDF_FAILURE; + } + enum AudioCategory type = renderSceneParam->frameRenderMode.attrs.type; + const char *useCase = AudioPathSelGetUseCase(type); + const char *deviceType = AudioPathSelGetDeviceType(pins); + if (useCase == NULL || deviceType == NULL) { + LOG_FUN_ERR("pins or type not support!"); + return HDF_FAILURE; + } + if (snprintf_s(pathName, sizeof(pathName), sizeof(pathName) - 1, "%s %s", useCase, deviceType) < 0) { + LOG_FUN_ERR("snprintf_s failed!"); + return HDF_FAILURE; + } + if (g_cJsonObj == NULL) { + LOG_FUN_ERR("g_cJsonObj is NULL!"); + return HDF_FAILURE; + } + cJSON *pathNode = cJSON_GetObjectItem(g_cJsonObj, pathName); + if (pathNode == NULL) { + LOG_FUN_ERR("Get Object Fail!"); + return HDF_ERR_NOT_SUPPORT; + } + cJSON *deviceNode = cJSON_GetObjectItem(g_cJsonObj, deviceType); + if (deviceNode == NULL) { + LOG_FUN_ERR("Get Object Fail!"); + return HDF_ERR_NOT_SUPPORT; + } + ret = strncpy_s(renderSceneParam->renderMode.hwInfo.pathSelect.useCase, + NAME_LEN - 1, useCase, strlen(useCase) + 1); + if (ret != 0) { + LOG_FUN_ERR("strncpy_s failed!"); + return HDF_FAILURE; + } + ret = strncpy_s(renderSceneParam->renderMode.hwInfo.pathSelect.deviceInfo.deviceType, + NAME_LEN - 1, deviceType, strlen(deviceType) + 1); + if (ret != 0) { + LOG_FUN_ERR("strncpy_s failed!"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +static int32_t AudioPathSelGetPlanCaptureScene(struct AudioHwCaptureParam *captureSceneParam) +{ + LOG_FUN_INFO(); + int32_t ret; + if (captureSceneParam == NULL) { + LOG_FUN_ERR("AudioPathSelGetPlanCaptureScene param Is NULL"); + return HDF_FAILURE; + } + char pathName[PATH_NAME_LEN] = {0}; + enum AudioPortPin pins = captureSceneParam->captureMode.hwInfo.deviceDescript.pins; + if (pins >= PATH_DEV_MAX || pins < PATH_DEV_MID) { + LOG_FUN_ERR("deviceDescript pins error!"); + return HDF_FAILURE; + } + enum AudioCategory type = captureSceneParam->frameCaptureMode.attrs.type; + const char *useCase = AudioPathSelGetUseCase(type); + const char *deviceType = AudioPathSelGetDeviceType(pins); + if (useCase == NULL || deviceType == NULL) { + LOG_FUN_ERR("pins or type not support!"); + return HDF_FAILURE; + } + if (snprintf_s(pathName, sizeof(pathName), sizeof(pathName) - 1, "%s %s", useCase, deviceType) < 0) { + LOG_FUN_ERR("snprintf_s failed!"); + return HDF_FAILURE; + } + if (g_cJsonObj == NULL) { + LOG_FUN_ERR("g_cJsonObj is NULL!"); + return HDF_FAILURE; + } + cJSON *pathNode = cJSON_GetObjectItem(g_cJsonObj, pathName); + if (pathNode == NULL) { + LOG_FUN_ERR("Get Object Fail!"); + return HDF_ERR_NOT_SUPPORT; + } + cJSON *deviceNode = cJSON_GetObjectItem(g_cJsonObj, deviceType); + if (deviceNode == NULL) { + LOG_FUN_ERR("Get Object Fail!"); + return HDF_ERR_NOT_SUPPORT; + } + ret = strncpy_s(captureSceneParam->captureMode.hwInfo.pathSelect.useCase, + NAME_LEN - 1, useCase, strlen(useCase) + 1); + if (ret != 0) { + LOG_FUN_ERR("strncpy_s failed!"); + return HDF_FAILURE; + } + ret = strncpy_s(captureSceneParam->captureMode.hwInfo.pathSelect.deviceInfo.deviceType, + NAME_LEN - 1, deviceType, strlen(deviceType) + 1); + if (ret != 0) { + LOG_FUN_ERR("strncpy_s failed!"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + + +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) { + LOG_FUN_ERR("AudioCapturePathSel Get Object Fail!"); + return HDF_FAILURE; + } + cJSON *pathList = pathNode->child; + if (pathList == NULL) { + LOG_FUN_ERR("AudioCapturePathSel Get pathList Fail!"); + return HDF_FAILURE; + } + while (pathList != NULL) { + cJSON *device = cJSON_GetObjectItem(pathList, "name"); + if (device == NULL) { + LOG_FUN_ERR("Get Object Fail!"); + return HDF_FAILURE; + } + pathKey = device->valuestring; + if (pathKey == NULL) { + pathList = pathList->next; + continue; + } + pathValue = cJSON_GetObjectItem(pathList, "value")->valueint; + captureParam->captureMode.hwInfo.pathSelect.pathPlan[pathIndex].value = pathValue; + ret = strncpy_s(captureParam->captureMode.hwInfo.pathSelect.pathPlan[pathIndex].pathPlanName, + PATHPLAN_LEN - 1, pathKey, strlen(pathKey) + 1); + if (ret != 0) { + LOG_FUN_ERR("strncpy_s failed!"); + return HDF_FAILURE; + } + pathList = pathList->next; + pathIndex++; + } + if (pathIndex >= PATHPLAN_COUNT || pathIndex < 0) { + LOG_FUN_ERR("AudioCapturePathSel Get Object Fail!"); + return HDF_FAILURE; + } + captureParam->captureMode.hwInfo.pathSelect.useCaseDeviceNum = pathIndex; + 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; + } + 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!"); + return HDF_FAILURE; + } + while (deviceList != NULL) { + cJSON *device = cJSON_GetObjectItem(deviceList, "name"); + if (device == NULL) { + LOG_FUN_ERR("Get Object Fail!"); + return HDF_FAILURE; + } + decKey = device->valuestring; + if (decKey == NULL) { + deviceList = deviceList->next; + continue; + } + decValue = cJSON_GetObjectItem(deviceList, "value")->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); + if (ret != 0) { + LOG_FUN_ERR("strncpy_s failed!"); + return HDF_FAILURE; + } + deviceList = deviceList->next; + decIndex++; + } + if (decIndex >= PATHPLAN_COUNT || decIndex < 0) { + LOG_FUN_ERR("Get Object Fail!"); + return HDF_FAILURE; + } + captureParam->captureMode.hwInfo.pathSelect.deviceInfo.deviceNum = decIndex; + return HDF_SUCCESS; +} + +static int32_t AudioPathSelGetPlanCapture(struct AudioHwCaptureParam *captureParam) +{ + LOG_FUN_INFO(); + int32_t ret; + if (captureParam == NULL) { + LOG_FUN_ERR("AudioPathSelGetPlanCapture param Is NULL"); + return HDF_FAILURE; + } + char pathName[PATH_NAME_LEN] = {0}; + enum AudioPortPin pins = captureParam->captureMode.hwInfo.deviceDescript.pins; + if (pins <= PATH_DEV_MID) { + LOG_FUN_ERR("deviceDescript pins error!"); + return HDF_FAILURE; + } + enum AudioCategory type = captureParam->frameCaptureMode.attrs.type; + const char *useCase = AudioPathSelGetUseCase(type); + const char *deviceType = AudioPathSelGetDeviceType(pins); + if (useCase == NULL || deviceType == NULL) { + LOG_FUN_ERR("pins or type not support!"); + return HDF_FAILURE; + } + ret = strncpy_s(captureParam->captureMode.hwInfo.pathSelect.useCase, + NAME_LEN - 1, useCase, strlen(useCase) + 1); + if (ret != 0) { + LOG_FUN_ERR("strncpy_s failed!"); + return HDF_FAILURE; + } + ret = strncpy_s(captureParam->captureMode.hwInfo.pathSelect.deviceInfo.deviceType, + NAME_LEN - 1, deviceType, strlen(deviceType) + 1); + if (ret != 0) { + LOG_FUN_ERR("strncpy_s failed!"); + return HDF_FAILURE; + } + if (snprintf_s(pathName, sizeof(pathName), sizeof(pathName) - 1, "%s %s", useCase, deviceType) < 0) { + LOG_FUN_ERR("snprintf_s failed!"); + return HDF_FAILURE; + } + if (AudioCapturePathSelGetUsecaseDevice(captureParam, pathName) < 0) { + LOG_FUN_ERR("AudioCapturePathSelGetUsecaseDevice failed!"); + return HDF_FAILURE; + } + if (AudioCapturePathSelGetDevice(captureParam, deviceType) < 0) { + LOG_FUN_ERR("AudioCapturePathSelGetDevice failed!"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +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) { + LOG_FUN_ERR("AudioRenderPathSel Get Object Fail!"); + return HDF_FAILURE; + } + cJSON *pathList = pathNode->child; + if (pathList == NULL) { + LOG_FUN_ERR("AudioRenderPathSel Get pathList Fail!"); + return HDF_FAILURE; + } + while (pathList != NULL) { + cJSON *device = cJSON_GetObjectItem(pathList, "name"); + if (device == NULL) { + LOG_FUN_ERR("Get Object Fail!"); + return HDF_FAILURE; + } + pathKey = device->valuestring; + if (pathKey == NULL) { + pathList = pathList->next; + continue; + } + pathValue = cJSON_GetObjectItem(pathList, "value")->valueint; + renderParam->renderMode.hwInfo.pathSelect.pathPlan[pathIndex].value = pathValue; + ret = strncpy_s(renderParam->renderMode.hwInfo.pathSelect.pathPlan[pathIndex].pathPlanName, + PATHPLAN_LEN - 1, pathKey, strlen(pathKey)); + if (ret != 0) { + LOG_FUN_ERR("strncpy_s is Fail!"); + return HDF_FAILURE; + } + pathList = pathList->next; + pathIndex++; + } + if (pathIndex >= PATHPLAN_COUNT || pathIndex < 0) { + LOG_FUN_ERR("AudioRenderPathSel Get Object Fail!"); + return HDF_FAILURE; + } + renderParam->renderMode.hwInfo.pathSelect.useCaseDeviceNum = pathIndex; + return HDF_SUCCESS; +} + +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) { + LOG_FUN_ERR("Get Object Fail!"); + return HDF_FAILURE; + } + cJSON *deviceList = deviceNode->child; + if (deviceList == NULL) { + LOG_FUN_ERR("deviceList is NULL!"); + return HDF_FAILURE; + } + while (deviceList != NULL) { + cJSON *device = cJSON_GetObjectItem(deviceList, "name"); + if (device == NULL) { + LOG_FUN_ERR("Get Object Fail!"); + return HDF_FAILURE; + } + decKey = device->valuestring; + if (decKey == NULL) { + deviceList = deviceList->next; + continue; + } + decValue = cJSON_GetObjectItem(deviceList, "value")->valueint; + renderParam->renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[decIndex].value = decValue; + ret = strncpy_s(renderParam->renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[decIndex].deviceSwitch, + PATHPLAN_LEN - 1, decKey, strlen(decKey) + 1); + if (ret != 0) { + LOG_FUN_ERR("strncpy_s is Fail!"); + return HDF_FAILURE; + } + deviceList = deviceList->next; + decIndex++; + } + if (decIndex >= PATHPLAN_COUNT || decIndex < 0) { + LOG_FUN_ERR("Get Object Fail!"); + return HDF_FAILURE; + } + renderParam->renderMode.hwInfo.pathSelect.deviceInfo.deviceNum = decIndex; + return HDF_SUCCESS; +} + +static int32_t AudioPathSelGetPlanRender(struct AudioHwRenderParam *renderParam) +{ + LOG_FUN_INFO(); + int32_t ret; + if (renderParam == NULL) { + LOG_FUN_ERR("AudioPathSelGetPlanRender param Is NULL"); + return HDF_FAILURE; + } + char pathName[PATH_NAME_LEN] = {0}; + enum AudioPortPin pins = renderParam->renderMode.hwInfo.deviceDescript.pins; + if (pins >= PATH_DEV_MID) { + LOG_FUN_ERR("deviceDescript pins error!"); + return HDF_FAILURE; + } + enum AudioCategory type = renderParam->frameRenderMode.attrs.type; + const char *useCase = AudioPathSelGetUseCase(type); + const char *deviceType = AudioPathSelGetDeviceType(pins); + if (useCase == NULL || deviceType == NULL) { + LOG_FUN_ERR("pins or type not support!"); + return HDF_FAILURE; + } + ret = strncpy_s(renderParam->renderMode.hwInfo.pathSelect.useCase, + NAME_LEN - 1, useCase, strlen(useCase) + 1); + if (ret != 0) { + LOG_FUN_ERR("strncpy_s is Fail!"); + return HDF_FAILURE; + } + ret = strncpy_s(renderParam->renderMode.hwInfo.pathSelect.deviceInfo.deviceType, + NAME_LEN - 1, deviceType, strlen(deviceType) + 1); + if (ret != 0) { + LOG_FUN_ERR("strncpy_s is Fail!"); + return HDF_FAILURE; + } + if (snprintf_s(pathName, sizeof(pathName), sizeof(pathName) - 1, "%s %s", useCase, deviceType) < 0) { + LOG_FUN_ERR("snprintf_s failed!"); + return HDF_FAILURE; + } + if (AudioRenderPathSelGetUsecaseDevice(renderParam, pathName) < 0) { + LOG_FUN_ERR("AudioRenderPathSelGetUsecaseDevice failed!"); + return HDF_FAILURE; + } + if (AudioRenderPathSelGetDevice(renderParam, deviceType) < 0) { + LOG_FUN_ERR("AudioRenderPathSelGetDevice failed!"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioPathSelAnalysisJson(void *adapterParam, enum AudioAdaptType adaptType) +{ + LOG_FUN_INFO(); + if (adaptType < 0 || adapterParam == NULL) { + LOG_FUN_ERR("Param Invaild!"); + return HDF_FAILURE; + } + struct AudioHwRenderParam *renderParam = NULL; + struct AudioHwCaptureParam *captureParam = NULL; + struct AudioHwRenderParam *renderSceneCheck = NULL; + struct AudioHwCaptureParam *captureScenceCheck = NULL; + switch (adaptType) { + case RENDER_PATH_SELECT: + renderParam = (struct AudioHwRenderParam *)adapterParam; + return (AudioPathSelGetPlanRender(renderParam)); + case CAPTURE_PATH_SELECT: + captureParam = (struct AudioHwCaptureParam *)adapterParam; + return (AudioPathSelGetPlanCapture(captureParam)); + /* Scene is surport */ + case CHECKSCENE_PATH_SELECT: + renderSceneCheck = (struct AudioHwRenderParam *)adapterParam; + return (AudioPathSelGetPlanRenderScene(renderSceneCheck)); + case CHECKSCENE_PATH_SELECT_CAPTURE: + captureScenceCheck = (struct AudioHwCaptureParam *)adapterParam; + return (AudioPathSelGetPlanCaptureScene(captureScenceCheck)); + default: + LOG_FUN_ERR("Path select mode invaild"); + break; + } + return HDF_FAILURE; +} + diff --git a/audio/hal/pathselect/src/parse.json b/audio/hal/pathselect/src/parse.json new file mode 100755 index 0000000000000000000000000000000000000000..965acb36383799d39f728cd72088e4e51a09be2f --- /dev/null +++ b/audio/hal/pathselect/src/parse.json @@ -0,0 +1,66 @@ +{ + "deep-buffer-playback Speaker": [{ + "name": "DACL Left Speaker Mixer", + "value": 1 + }, + { + "name": "DACR Left Speaker Mixer", + "value": 1 + }], + "Speaker": [{ + "name": "Dacl enable", + "value": 1 + }, + { + "name": "Dacr enable", + "value": 1 + }], + "headphones": [{ + "name": "Dacl enable", + "value": 0 + }, + { + "name": "Dacr enable", + "value": 0 + }], + "deep-buffer-playback headphones": [{ + "name": "DACL Left Speaker Mixer", + "value": 1 + }, + { + "name": "DACR Left Speaker Mixer", + "value": 1 + }], + "deep-buffer-playback mic": [{ + "name": "DACL Left Speaker Mixer", + "value": 1 + }, + { + "name": "DACR Left Speaker Mixer", + "value": 1 + }], + "deep-buffer-playback micHs": [{ + "name": "DACL Left Speaker Mixer", + "value": 1 + }, + { + "name": "DACR Left Speaker Mixer", + "value": 1 + }], + "mic": [{ + "name": "LPGA MIC Switch", + "value": 1 + }, + { + "name": "RPGA MIC Switch", + "value": 0 + }], + "micHs": [{ + "name": "LPGA MIC Switch", + "value": 0 + }, + { + "name": "RPGA MIC Switch", + "value": 0 + }] +} diff --git a/audio/interfaces/include/audio_attribute.h b/audio/interfaces/include/audio_attribute.h index 2ec64460527a03fe44c046e968974ebee5af163c..b9ca60a685e07f2b84e3c87697cdadcd3fb7f8a6 100755 --- a/audio/interfaces/include/audio_attribute.h +++ b/audio/interfaces/include/audio_attribute.h @@ -94,6 +94,46 @@ struct AudioAttribute { * @return Returns 0 if the data channel ID is obtained; returns a negative value otherwise. */ int32_t (*GetCurrentChannelId)(AudioHandle handle, uint32_t *channelId); + + /** + * @brief Sets extra audio parameters. + * + * @param handle Indicates the audio handle. + * @param keyValueList Indicates the pointer to the key-value list of the extra audio parameters. + * 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 (*SetExtraParams)(AudioHandle handle, const char *keyValueList); + + /** + * @brief Obtains extra audio parameters. + * + * @param handle Indicates the audio handle. + * @param keyValueList Indicates the pointer to the key-value list of the extra audio parameters. + * 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); + + /** + * @brief Requests a mmap buffer. + * + * @param handle Indicates the audio handle. + * @param reqSize Indicates the size of the request mmap buffer. + * @param desc Indicates the pointer to the mmap buffer descriptor. + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + */ + int32_t (*ReqMmapBuffer)(AudioHandle handle, int32_t reqSize, struct AudioMmapBufferDescripter *desc); + + /** + * @brief Obtains the read/write position of the current mmap buffer. + * + * @param handle Indicates the audio handle. + * @param frames Indicates the pointer to the frame where the read/write starts. + * @param time Indicates the pointer to the timestamp associated with the frame where the read/write starts. + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + */ + int32_t (*GetMmapPosition)(AudioHandle handle, uint64_t *frames, struct AudioTimeStamp *time); }; #endif /* AUDIO_ATTRIBUTE_H */ diff --git a/audio/interfaces/include/audio_control.h b/audio/interfaces/include/audio_control.h index a9370ba928af62f548f204cb38547b795e3b0008..0a17153876d8b6fef7dee0fe19be6165874c40af 100755 --- a/audio/interfaces/include/audio_control.h +++ b/audio/interfaces/include/audio_control.h @@ -93,6 +93,25 @@ struct AudioControl { * @return Returns 0 if the flush is successful; returns a negative value otherwise. */ int32_t (*Flush)(AudioHandle handle); + + /** + * @brief Sets or cancels the standby mode of the audio device. + * + * @param handle Indicates the audio handle. + * @return Returns 0 if the device is set to standby mode; returns a positive value if the standby mode is + * canceled; returns a negative value if the setting fails. + */ + int32_t (*TurnStandbyMode)(AudioHandle handle); + + /** + * @brief Dumps information about the audio device. + * + * @param handle Indicates the audio handle. + * @param range Indicates the range of the device information to dump, which can be brief or full information. + * @param fd Indicates the file to which the device information will be dumped. + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + */ + int32_t (*AudioDevDump)(AudioHandle handle, int32_t range, int32_t fd); }; #endif /* AUDIO_CONTROL_H */ diff --git a/audio/interfaces/include/audio_render.h b/audio/interfaces/include/audio_render.h index 500f6b0b60e901c48ce40b86830c5726c9bea20f..7d473580385414160e44f9ae83b052526d069a85 100755 --- a/audio/interfaces/include/audio_render.h +++ b/audio/interfaces/include/audio_render.h @@ -141,6 +141,29 @@ struct AudioRender { * @see SetChannelMode */ int32_t (*GetChannelMode)(struct AudioRender *render, enum AudioChannelMode *mode); + + /** + * @brief Registers an audio callback that will be invoked during playback when buffer data writing or + * buffer drain is complete. + * + * @param render Indicates the pointer to the AudioRender object to operate. + * @param callback Indicates the callback to register. + * @param cookie Indicates the pointer to the callback parameters. + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * @see RegCallback + */ + int32_t (*RegCallback)(struct AudioRender *render, RenderCallback callback, void* cookie); + + /** + * @brief Drains the buffer. + * + * @param render Indicates the pointer to the AudioRender object to operate. + * @param type Indicates the pointer to the execution type of this function. For details, + * see {@link AudioDrainNotifyType}. + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * @see RegCallback + */ + int32_t (*DrainBuffer)(struct AudioRender *render, enum AudioDrainNotifyType *type); }; #endif /* AUDIO_RENDER_H */ diff --git a/audio/interfaces/include/audio_types.h b/audio/interfaces/include/audio_types.h index 6cbad28cf473d69c87e68fbd8eeff5031f3512a7..8acefb426ddb241b62a882be361895d429aaeaee 100755 --- a/audio/interfaces/include/audio_types.h +++ b/audio/interfaces/include/audio_types.h @@ -174,13 +174,20 @@ enum AudioSampleRatesMask { * @brief Defines audio sampling attributes. */ struct AudioSampleAttributes { - enum AudioCategory type; /**< Audio type. For details, see {@link AudioCategory} */ - bool interleaved; /**< Interleaving flag of audio data */ - enum AudioFormat format; /**< Audio data format. For details, see {@link AudioFormat}. */ - uint32_t sampleRate; /**< Audio sampling rate */ - uint32_t channelCount; /**< Number of audio channels. For example, for the mono channel, the value is 1, - * and for the stereo channel, the value is 2. - */ + enum AudioCategory type; /**< Audio type. For details, see {@link AudioCategory} */ + bool interleaved; /**< Interleaving flag of audio data */ + enum AudioFormat format; /**< Audio data format. For details, see {@link AudioFormat}. */ + uint32_t sampleRate; /**< Audio sampling rate */ + uint32_t channelCount; /**< Number of audio channels. For example, for the mono channel, the value is 1, + * and for the stereo channel, the value is 2. + */ + uint32_t period; /**< Audio sampling period */ + uint32_t frameSize; /**< Frame size of the audio data */ + bool isBigEndian; /**< Big endian flag of audio data */ + bool isSignedData; /**< Signed or unsigned flag of audio data */ + uint32_t startThreshold; /**< Audio render start threshold. */ + uint32_t stopThreshold; /**< Audio render stop threshold. */ + uint32_t silenceThreshold; /**< Audio capture buffer threshold. */ }; /** @@ -248,4 +255,47 @@ enum AudioChannelMode { AUDIO_CHANNEL_BOTH_MUTE, /**< Both left and right channels muted */ }; +/** + * @brief Enumerates the execution types of the DrainBuffer function. + */ +enum AudioDrainNotifyType { + AUDIO_DRAIN_NORMAL_MODE, /**< The DrainBuffer function returns after all data finishes playback. */ + AUDIO_DRAIN_EARLY_MODE, /**< The DrainBuffer function returns before all the data of the current track + * finishes playback to reserve time for a smooth track switch by the audio service. + */ +}; + +/** + * @brief Enumerates callback notification events. + */ +enum AudioCallbackType { + AUDIO_NONBLOCK_WRITE_COMPELETED, /**< The non-block write is complete. */ + AUDIO_DRAIN_COMPELETED, /**< The draining is complete. */ + AUDIO_FLUSH_COMPLETED, /**< The flush is complete. */ + AUDIO_RENDER_FULL, /**< The render buffer is full.*/ + AUDIO_ERROR_OCCUR, /**< An error occurs.*/ +}; + +/** + * @brief Describes a mmap buffer. + */ +struct AudioMmapBufferDescripter { + void *memoryAddress; /**< Pointer to the mmap buffer */ + int32_t memoryFd; /**< File descriptor of the mmap buffer */ + 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 */ +}; + +/** + * @brief Called when an event defined in {@link AudioCallbackType} occurs. + * + * @param AudioCallbackType Indicates the occurred event that triggers this callback. + * @param reserved Indicates the pointer to a reserved field. + * @param cookie Indicates the pointer to the cookie for data transmission. + * @return Returns 0 if the callback is successfully executed; returns a negative value otherwise. + * @see RegCallback + */ +typedef int32_t (*RenderCallback)(enum AudioCallbackType, void *reserved, void *cookie); + #endif /* AUDIO_TYPES_H */ diff --git a/audio/sample/BUILD.gn b/audio/sample/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..b3b70040d1d40a5a425f7f776a2d4cde61b693db --- /dev/null +++ b/audio/sample/BUILD.gn @@ -0,0 +1,125 @@ +# 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") + +ohos_executable("audio_test_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" ] + } + + install_enable = true + subsystem_name = "hdf" +} + +ohos_executable("audio_test_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" ] + } + + install_enable = true + subsystem_name = "hdf" +} diff --git a/audio/sample/framework_capture.c b/audio/sample/framework_capture.c new file mode 100755 index 0000000000000000000000000000000000000000..9e26d098637248237871196b04e8c711822e22b1 --- /dev/null +++ b/audio/sample/framework_capture.c @@ -0,0 +1,796 @@ +/* + * 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_manager.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include "audio_types.h" +#include "hdf_base.h" + +#define AUDIO_CHANNELCOUNT 2 +#define AUDIO_SAMPLE_RATE_48K 48000 +#define PATH_LEN 256 + +#define DEEP_BUFFER_RENDER_PERIOD_SIZE 4096 +#define DEEP_BUFFER_RENDER_PERIOD_COUNT 8 +#define INT_32_MAX 0x7fffffff +#define PERIOD_SIZE 1024 +#define AUDIO_BUFF_SIZE (1024 * 16) +#define PCM_8_BIT 8 +#define PCM_16_BIT 16 +#define AUDIO_TOTALSIZE_15M (1024 * 15) +#define AUDIO_RECORD_INTERVAL_512KB 512 + +struct StrParaCapture { + struct AudioCapture *capture; + FILE *file; + struct AudioSampleAttributes attrs; + uint64_t *replyBytes; + char *frame; + int32_t bufferSize; +}; +struct AudioAdapter *g_adapter = NULL; +struct AudioDeviceDescriptor g_devDesc; +struct AudioSampleAttributes g_attrs; +struct AudioCapture *g_capture = NULL; +struct AudioManager *g_manager = NULL; +struct StrParaCapture g_str; + +pthread_t g_tids; +FILE *g_file; +char *g_frame; +void *g_handle; +char g_path[256]; + +enum CaptureMenuId { + CAPTURE_START = 1, + CAPTURE_STOP, + CAPTURE_RESUME, + CAPTURE_PAUSE, + SET_CAPTURE_VOLUME, + SET_CAPTURE_GAIN, + SET_CAPTURE_MUTE, + SET_CAPTURE_ATTRIBUTES, + SET_CAPTURE_SLECET_SCENE, +}; + +enum CaptureInputType { + INPUT_INT = 0, + INPUT_FLOAT, + INPUT_UINT32, +}; + +typedef int32_t (*AudioCaptureOperation)(struct AudioCapture **); + +struct ProcessCaptureMenuSwitchList { + enum CaptureMenuId cmd; + AudioCaptureOperation operation; +}; + +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) + +int32_t CheckInputName(int type, void *val) +{ + if (val == NULL) { + return HDF_FAILURE; + } + int ret; + int inputInt = 0; + float inputFloat = 0.0; + uint32_t inputUint = 0; + switch (type) { + case INPUT_INT: + ret = scanf_s("%d", &inputInt); + if (inputInt < 0 || inputInt > SET_CAPTURE_SLECET_SCENE + 1) { + printf("Input failure\n"); + return HDF_FAILURE; + } + *(int *)val = inputInt; + break; + case INPUT_FLOAT: + ret = scanf_s("%f", &inputFloat); + *(float *)val = inputFloat; + break; + case INPUT_UINT32: + ret = scanf_s("%u", &inputUint); + if (inputUint > 0xFFFFFFFF || inputUint < 0) { + return HDF_FAILURE; + } + *(uint32_t *)val = inputUint; + break; + default: + ret = EOF; + break; + } + if (ret == 0) { + fflush(stdin); + } else if (ret == EOF) { + printf("Input failure occurs!\n"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} +void SystemInputFail() +{ + printf("please ENTER to go on..."); + while (getchar() != '\n') { + continue; + } + printf("%c", getchar()); +} +int32_t InitAttrsCapture(struct AudioSampleAttributes *attrs) +{ + if (attrs == NULL) { + return HDF_FAILURE; + } + /* Initialization of audio parameters for playback */ + attrs->format = AUDIO_FORMAT_PCM_16_BIT; + attrs->channelCount = AUDIO_CHANNELCOUNT; + attrs->sampleRate = AUDIO_SAMPLE_RATE_48K; + attrs->interleaved = 0; + attrs->type = AUDIO_IN_MEDIA; + attrs->period = DEEP_BUFFER_RENDER_PERIOD_SIZE; + attrs->frameSize = PCM_16_BIT * attrs->channelCount / PCM_8_BIT; + attrs->isBigEndian = false; + attrs->isSignedData = true; + attrs->startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (attrs->frameSize); + attrs->stopThreshold = INT_32_MAX; + attrs->silenceThreshold = AUDIO_BUFF_SIZE; + return 0; +} + +int32_t InitDevDescCapture(struct AudioDeviceDescriptor *devDesc, + uint32_t portId) +{ + if (devDesc == NULL) { + return HDF_FAILURE; + } + /* Initialization of audio parameters for playback */ + devDesc->portId = portId; + devDesc->pins = PIN_IN_MIC; + devDesc->desc = NULL; + 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) { + case AUDIO_FORMAT_PCM_16_BIT: + return PCM_16_BIT; + case AUDIO_FORMAT_PCM_8_BIT: + return PCM_8_BIT; + default: + return PCM_16_BIT; + }; +} + +uint32_t PcmFramesToBytes(const struct AudioSampleAttributes attrs) +{ + return DEEP_BUFFER_RENDER_PERIOD_SIZE * attrs.channelCount * (PcmFormatToBits(attrs.format) >> 3); +} + +int32_t StopButtonCapture(struct AudioCapture **captureS) +{ + if (captureS == NULL) { + return HDF_FAILURE; + } + if (!g_closeEnd) { + g_closeEnd = true; + pthread_join(g_tids, NULL); + } + struct AudioCapture *capture = *captureS; + if (capture == NULL) { + return HDF_FAILURE; + } + int ret = capture->control.Stop((AudioHandle)capture); + if (ret < 0) { + printf("Stop capture!\n"); + } + if (g_adapter == NULL) { + return HDF_FAILURE; + } + ret = g_adapter->DestroyCapture(g_adapter, capture); + if (ret < 0) { + printf("Capture already destroy!\n"); + } + capture = NULL; + g_capture = NULL; + if (g_frame != NULL) { + free(g_frame); + g_frame = NULL; + } + if (g_file != NULL) { + fclose(g_file); + g_file = NULL; + } + printf("Stop Successful\n"); + return HDF_SUCCESS; +} + +int32_t FrameStartCapture(void *param) +{ + if (param == NULL) { + return HDF_FAILURE; + } + struct StrParaCapture *strParam = (struct StrParaCapture *)param; + struct AudioCapture *capture = strParam->capture; + FILE *file = strParam->file; + int32_t ret; + uint32_t bufferSize = AUDIO_BUFF_SIZE; // 16 * 1024 = 16KB, it needs to be calculated by audio parameters + 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); + if (frame == NULL) { + return HDF_FAILURE; + } + do { + ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes); + if (ret < 0) { + if (ret == HDF_ERR_INVALID_OBJECT) { + printf("Record already stop!\n"); + break; + } + continue; + } + 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 %lluKb\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); + } + return HDF_SUCCESS; +} + +int32_t StartButtonCapture(struct AudioCapture **captureS) +{ + if (captureS == NULL) { + return HDF_FAILURE; + } + if (g_file != NULL) { + printf("the capture is playing,please stop first\n"); + return HDF_FAILURE; + } + g_closeEnd = false; + struct AudioCapture *capture; + int32_t ret = g_adapter->CreateCapture(g_adapter, &g_devDesc, &g_attrs, &capture); + if (capture == NULL || ret < 0) { + return HDF_FAILURE; + } + g_file = fopen(g_path, "wb+"); + if (g_file == NULL) { + printf("failed to open '%s'\n", g_path); + return HDF_FAILURE; + } + ret = capture->control.Start((AudioHandle)capture); + if (ret < 0) { + if (g_file != NULL) { + fclose(g_file); + g_file = 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 StrParaCapture), 0, sizeof(struct StrParaCapture)); + g_str.capture = capture; + g_str.file = g_file; + g_str.attrs = g_attrs; + g_str.frame = g_frame; + ret = pthread_create(&g_tids, NULL, (void *)(&FrameStartCapture), &g_str); + if (ret != 0) { + return HDF_FAILURE; + } + *captureS = capture; + printf("Start Successful\n"); + return HDF_SUCCESS; +} + +int32_t SwitchAdapterCapture(struct AudioAdapterDescriptor *descs, const char *adapterNameCase, + enum AudioPortDirection portFlag, struct AudioPort *capturePort, const int32_t size) +{ + if (descs == NULL || adapterNameCase == NULL || capturePort == NULL) { + return HDF_FAILURE; + } + for (int32_t index = 0; index < size; index++) { + struct AudioAdapterDescriptor *desc = &descs[index]; + if (strcmp(desc->adapterName, adapterNameCase)) { + printf("adapter name case = %s\n", adapterNameCase); + continue; + } + for (uint32_t port = 0; ((desc != NULL) && (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]; + return index; + } + } + } + return HDF_FAILURE; +} +void PrintMenu1() +{ + printf(" ============== Play Capture Loading Mode ===========\n"); + printf("| 1. Capture Direct Loading |\n"); + printf("| 2. Capture Service Loading |\n"); + printf("| Note: switching is not supported in the MPI's |\n"); + printf("| version. |\n"); + printf(" =================================================== \n"); +} +int32_t SelectLoadingMode(char *resolvedPath, char *func) +{ + system("clear"); + int choice = 0; + PrintMenu1(); + printf("Please enter your choice:"); + int32_t 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"); + 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"); + 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"); + break; + } + return HDF_SUCCESS; +} + +int32_t InitParam() +{ + 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) { + return HDF_FAILURE; + } + void *handle = dlopen(resolvedPath, 1); + struct AudioPort audioPort; + struct AudioAdapterDescriptor *descs = NULL; + struct AudioPort capturePort; + struct AudioManager *(*getAudioManager)() = NULL; + getAudioManager = (struct AudioManager *(*)())(dlsym(handle, func)); + audioPort.dir = PORT_IN; + audioPort.portId = 0; + audioPort.portName = "AOP"; + struct AudioManager *manager = getAudioManager(); + if (manager == NULL) { + 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) { + return HDF_ERR_NOT_SUPPORT; + } + char adapterNameCase[PATH_LEN] = "usb"; + index = SwitchAdapterCapture(descs, adapterNameCase, audioPort.dir, &capturePort, size); + if (index < 0) { + return HDF_ERR_NOT_SUPPORT; + } + struct AudioAdapterDescriptor *desc = &descs[index]; + if (manager->LoadAdapter(manager, desc, &g_adapter) != 0) { + return HDF_ERR_NOT_SUPPORT; + } + g_manager = manager; + if (g_adapter == NULL) { + 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) { + return HDF_FAILURE; + } + // Specify a hardware device + if (InitDevDescCapture(&g_devDesc, capturePort.portId) < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t SetCaptureMute() +{ + int32_t val = 0; + bool isMute = false; + int32_t ret; + if (g_capture == NULL) { + return HDF_FAILURE; + } + ret = g_capture->volume.GetMute((AudioHandle)g_capture, &isMute); + if (ret < 0) { + printf("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); + if (ret < 0) { + return HDF_FAILURE; + } + if (isMute != 0 && isMute != 1) { + printf("Invalid value,"); + SystemInputFail(); + return HDF_FAILURE; + } + if (g_capture == NULL) { + printf("Record already complete,Please record againand,"); + SystemInputFail(); + return HDF_FAILURE; + } + if (val == 1) { + ret = g_capture->volume.SetMute((AudioHandle)g_capture, !isMute); + } + return ret; +} + +int32_t SetCaptureVolume() +{ + int32_t ret; + float val = 0.5; + if (g_capture == NULL) { + return HDF_FAILURE; + } + ret = g_capture->volume.GetVolume((AudioHandle)g_capture, &val); + if (ret < 0) { + printf("Get current volume failed,"); + SystemInputFail(); + return ret; + } + printf("Now the volume is %f ,Please enter the volume value you want to set (0.0-1.0):\n", val); + ret = CheckInputName(INPUT_FLOAT, (void *)&val); + if (ret < 0) { + return HDF_FAILURE; + } + if (val < 0.0 || val > 1.0) { + printf("Invalid volume value,"); + SystemInputFail(); + return HDF_FAILURE; + } + if (g_capture == NULL) { + printf("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,"); + SystemInputFail(); + } + return ret; +} + +int32_t SetCaptureGain() +{ + int32_t ret; + float val = 1.0; + if (g_capture == NULL) { + return HDF_FAILURE; + } + ret = g_capture->volume.GetGain((AudioHandle)g_capture, &val); + if (ret < 0) { + LOG_FUN_ERR_TS("Get current gain failed,"); + SystemInputFail(); + return HDF_FAILURE; + } + printf("Now the gain is %f, Please enter the gain value you want to set (0.0-15.0):\n", val); + ret = CheckInputName(INPUT_FLOAT, (void *)&val); + if (ret < 0) { + return HDF_FAILURE; + } + // gain is 0.0 ~ 15.0 + if (val < 0.0 || val > 15.0) { + printf("Invalid gain value,"); + SystemInputFail(); + return HDF_FAILURE; + } + if (g_capture == NULL) { + printf("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,"); + SystemInputFail(); + } + return ret; +} + +int32_t SetCaptyrePause() +{ + int32_t ret; + if (g_capture == NULL) { + return HDF_FAILURE; + } + ret = g_capture->control.Pause((AudioHandle)g_capture); + if (ret != 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t SetCaptureResume() +{ + int32_t ret; + if (g_capture == NULL) { + return HDF_FAILURE; + } + ret = g_capture->control.Resume((AudioHandle)g_capture); + if (ret != 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +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"); +} + +int32_t SelectAttributesFomat(uint32_t *fomat) +{ + PrintAttributesFromat(); + printf("Please select audio format,If not selected, the default is 16bit:"); + uint32_t ret; + int val = 0; + ret = CheckInputName(INPUT_INT, (void *)&val); + if (ret < 0) { + return HDF_FAILURE; + } + switch (val) { + case AUDIO_FORMAT_PCM_8_BIT: + *fomat = AUDIO_FORMAT_PCM_8_BIT; + break; + case AUDIO_FORMAT_PCM_16_BIT: + *fomat = AUDIO_FORMAT_PCM_16_BIT; + break; + case AUDIO_FORMAT_PCM_24_BIT: + *fomat = AUDIO_FORMAT_PCM_24_BIT; + break; + case AUDIO_FORMAT_PCM_32_BIT: + *fomat = AUDIO_FORMAT_PCM_32_BIT; + break; + default: + *fomat = AUDIO_FORMAT_PCM_16_BIT; + break; + } + return HDF_SUCCESS; +} + +int32_t SetCaptureAttributes() +{ + int32_t ret; + struct AudioSampleAttributes attrs; + ret = g_capture->attr.GetSampleAttributes((AudioHandle)g_capture, &attrs); + if (ret < 0) { + LOG_FUN_ERR_TS("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); + } + printf("Set Sample Attributes,"); + SystemInputFail(); + system("clear"); + 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"); + return HDF_FAILURE; + } + printf("\nPlease input sample rate(48000,44100,32000...):"); + ret = CheckInputName(INPUT_UINT32, (void *)(&attrs.sampleRate)); + if (ret < 0) return HDF_FAILURE; + printf("\nPlease input bigEndian(false=0/true=1):"); + ret = CheckInputName(INPUT_UINT32, (void *)(&attrs.isBigEndian)); + if (ret < 0) { + return HDF_FAILURE; + } + if (g_capture == NULL) { + printf("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,"); + SystemInputFail(); + } + return ret; +} + +int32_t SelectCaptureScene() +{ + system("clear"); + int32_t ret; + int val = 0; + struct AudioSceneDescriptor scene; + printf(" ==================== Select Scene ==================== \n"); + printf("0 is Mic. |\n"); + printf("1 is Headphone mic. |\n"); + printf(" ======================================================= \n"); + printf("Please input your choice:\n"); + ret = CheckInputName(INPUT_INT, (void *)&val); + if (ret < 0 || (val != 0 && val != 1)) { + printf("Invalid value,"); + SystemInputFail(); + return HDF_FAILURE; + } + if (val == 1) { + scene.scene.id = 0; + scene.desc.pins = PIN_IN_HS_MIC; + } else { + scene.scene.id = 0; + scene.desc.pins = PIN_IN_MIC; + } + if (g_capture == NULL) { + printf("Record already stop,"); + SystemInputFail(); + return HDF_FAILURE; + } + ret = g_capture->scene.SelectScene((AudioHandle)g_capture, &scene); + if (ret < 0) { + printf("Select scene fail\n"); + } + return ret; +} + +void PrintMenu2() +{ + printf(" ================== Play Capture Menu ================== \n"); + printf("| 1. Capture Start |\n"); + printf("| 2. Capture Stop |\n"); + printf("| 3. Capture Resume |\n"); + printf("| 4. Capture Pause |\n"); + printf("| 5. Capture SetVolume |\n"); + printf("| 6. Capture SetGain |\n"); + printf("| 7. Capture SetMute |\n"); + printf("| 8. Capture SetAttributes |\n"); + printf("| 9. Capture SelectScene |\n"); + printf("| 10.Exit |\n"); + printf(" ======================================================= \n"); +} + +static struct ProcessCaptureMenuSwitchList g_processCaptureMenuSwitchList[] = { + {CAPTURE_START, StartButtonCapture}, + {CAPTURE_STOP, StopButtonCapture}, + {CAPTURE_RESUME, SetCaptureResume}, + {CAPTURE_PAUSE, SetCaptyrePause}, + {SET_CAPTURE_VOLUME, SetCaptureVolume}, + {SET_CAPTURE_GAIN, SetCaptureGain}, + {SET_CAPTURE_MUTE, SetCaptureMute}, + {SET_CAPTURE_ATTRIBUTES, SetCaptureAttributes}, + {SET_CAPTURE_SLECET_SCENE, SelectCaptureScene}, +}; + +void ProcessMenu(int32_t choice) +{ + int32_t i; + if (choice == SET_CAPTURE_SLECET_SCENE + 1) { + printf("Exit from application program!\n"); + return; + } + if (g_capture == NULL && choice != 1) { + printf("this capture already release,"); + SystemInputFail(); + return; + } + for (i = CAPTURE_START; i <= SET_CAPTURE_SLECET_SCENE; ++i) { + if ((choice == (int32_t)g_processCaptureMenuSwitchList[i - 1].cmd) && + (g_processCaptureMenuSwitchList[i - 1].operation != NULL)) { + g_processCaptureMenuSwitchList[i - 1].operation(&g_capture); + } + } +} + +int32_t main(int32_t argc, char const *argv[]) +{ + 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) { + system("clear"); + PrintMenu2(); + printf("your choice is:\n"); + ret = CheckInputName(INPUT_INT, (void *)&choice); + if (ret < 0) { + continue; + } + if (choice < CAPTURE_START || choice > SET_CAPTURE_SLECET_SCENE + 1) { + printf("You input is wrong,"); + choice = 0; + SystemInputFail(); + continue; + } + ProcessMenu(choice); + } + if (g_capture != NULL && g_adapter != NULL) { + StopButtonCapture(&g_capture); + } + if (g_manager != NULL) { + g_manager->UnloadAdapter(g_manager, g_adapter); + } + 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 new file mode 100755 index 0000000000000000000000000000000000000000..56da5ede786df2182d49873e79f283719b9ba881 --- /dev/null +++ b/audio/sample/framework_render.c @@ -0,0 +1,970 @@ +/* + * 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_manager.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include "audio_types.h" +#include "hdf_base.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 MAX_AUDIO_ADAPTER_NUM_T 3 // Number of sound cards supported +#define BUFFER_LEN 256 +#define ID_RIFF 0x46464952 +#define ID_WAVE 0x45564157 +#define ID_FMT 0x20746d66 +#define ID_DATA 0x61746164 +#define MOVE_LEFT_NUM 8 +#define AUDIO_SAMPLE_RATE_8K 8000 +#define AUDIO_CHANNELCOUNT 2 +#define AUDIO_SAMPLE_RATE_48K 48000 +#define PATH_LEN 256 +#define DEEP_BUFFER_RENDER_PERIOD_SIZE 4096 +#define DEEP_BUFFER_RENDER_PERIOD_COUNT 8 +#define INT_32_MAX 0x7fffffff +#define PERIOD_SIZE 1024 + +enum AudioPCMBit { + PCM_8_BIT = 8, /**< 8-bit PCM */ + PCM_16_BIT = 16, /**< 16-bit PCM */ + PCM_24_BIT = 24, /**< 24-bit PCM */ + PCM_32_BIT = 32, /**< 32-bit PCM */ +}; + +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; +}; + +struct StrPara { + struct AudioRender *render; + FILE *file; + struct AudioSampleAttributes attrs; + uint64_t *replyBytes; + char *frame; + int32_t bufferSize; +}; + +struct AudioRender *g_render = NULL; +struct AudioAdapter *g_adapter = NULL; +struct AudioManager *g_manager = NULL; +struct AudioDeviceDescriptor g_devDesc; +struct AudioSampleAttributes g_attrs; +struct AudioPort g_audioPort; +struct AudioHeadInfo g_wavHeadInfo; +struct StrPara g_str; + +pthread_t g_tids; +char *g_frame = NULL; +void *g_handle; +FILE *g_file; + +char g_path[256]; +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; + +enum RenderMenuId { + RENDER_START = 1, + RENDER_STOP, + RENDER_RESUME, + RENDER_PAUSE, + SET_RENDER_VOLUME, + SET_RENDER_GAIN, + SET_RENDER_MUTE, + SET_RENDER_ATTRIBUTES, + SET_RENDER_SLECET_SCENE, +}; + +enum RenderInputType { + INPUT_INT = 0, + INPUT_FLOAT, + INPUT_UINT32, +}; + +typedef int32_t (*AudioRenderOperation)(struct AudioRender **); + +struct ProcessRenderMenuSwitchList { + enum RenderMenuId cmd; + AudioRenderOperation operation; +}; +int32_t CheckInputName(int type, void *val) +{ + int ret; + int inputInt = 0; + float inputFloat = 0.0; + uint32_t inputUint = 0; + switch (type) { + case INPUT_INT: + ret = scanf_s("%d", &inputInt); + if (inputInt < 0 || inputInt > SET_RENDER_SLECET_SCENE + 1) { + printf("Input failure\n"); + return HDF_FAILURE; + } + *(int *)val = inputInt; + break; + case INPUT_FLOAT: + ret = scanf_s("%f", &inputFloat); + *(float *)val = inputFloat; + break; + case INPUT_UINT32: + ret = scanf_s("%u", &inputUint); + if (inputUint > 0xFFFFFFFF || inputUint < 0) { + return HDF_FAILURE; + } + *(uint32_t *)val = inputUint; + break; + default: + ret = EOF; + break; + } + if (ret == 0) { + fflush(stdin); + } else if (ret == EOF) { + printf("Input failure occurs!\n"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +void SystemInputFail() +{ + printf("please ENTER to go on..."); + while (getchar() != '\n') { + continue; + } + printf("%c", getchar()); +} + +int32_t InitAttrs(struct AudioSampleAttributes *attrs) +{ + if (attrs == NULL) { + return HDF_FAILURE; + } + /* Initialization of audio parameters for playback */ + attrs->format = AUDIO_FORMAT_PCM_16_BIT; + attrs->channelCount = AUDIO_CHANNELCOUNT; + attrs->sampleRate = AUDIO_SAMPLE_RATE_48K; + attrs->interleaved = 0; + attrs->type = AUDIO_IN_MEDIA; + attrs->period = DEEP_BUFFER_RENDER_PERIOD_SIZE; + attrs->frameSize = PCM_16_BIT * attrs->channelCount / PCM_8_BIT; + attrs->isBigEndian = false; + attrs->isSignedData = true; + attrs->startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (attrs->frameSize); + attrs->stopThreshold = INT_32_MAX; + attrs->silenceThreshold = 0; + 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) { + return HDF_FAILURE; + } + /* Initialization of audio parameters for playback */ + devDesc->portId = portId; + devDesc->pins = PIN_OUT_SPEAKER; + devDesc->desc = NULL; + return HDF_SUCCESS; +} + +uint32_t StringToInt(char *flag) +{ + if (flag == NULL) { + return 0; + } + uint32_t temp = flag[0]; + for (int32_t i = strlen(flag) - 1; i >= 0; i--) { + temp <<= MOVE_LEFT_NUM; + temp += flag[i]; + } + return temp; +} +int32_t WavHeadAnalysis(FILE *file, struct AudioSampleAttributes *attrs) +{ + if (file == NULL || attrs == NULL) { + return HDF_FAILURE; + } + int32_t ret; + char *audioRiffIdParam = "RIFF"; + char *audioFileFmtParam = "WAVE"; + char *aduioDataIdParam = "data"; + ret = fread(&g_wavHeadInfo, sizeof(g_wavHeadInfo), 1, file); + if (ret != 1) { + return HDF_FAILURE; + } + uint32_t audioRiffId = StringToInt(audioRiffIdParam); + uint32_t audioFileFmt = StringToInt(audioFileFmtParam); + uint32_t aduioDataId = StringToInt(aduioDataIdParam); + if (g_wavHeadInfo.testFileRiffId != audioRiffId || g_wavHeadInfo.testFileFmt != audioFileFmt || + g_wavHeadInfo.dataId != aduioDataId) { + return HDF_FAILURE; + } + attrs->channelCount = g_wavHeadInfo.audioChannelNum; + attrs->sampleRate = g_wavHeadInfo.audioSampleRate; + switch (g_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; +} + +int32_t SwitchAdapter(struct AudioAdapterDescriptor *descs, + const char *adapterNameCase, enum AudioPortDirection portFlag, + struct AudioPort *renderPort, int32_t size) +{ + if (descs == NULL || adapterNameCase == NULL || renderPort == NULL) { + return HDF_FAILURE; + } + for (int32_t index = 0; index < size; index++) { + struct AudioAdapterDescriptor *desc = &descs[index]; + if (strcmp(desc->adapterName, adapterNameCase)) { + continue; + } + for (uint32_t port = 0; ((desc != NULL) && (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]; + return index; + } + } + } + return HDF_ERR_NOT_SUPPORT; +} + +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) { + case AUDIO_FORMAT_PCM_16_BIT: + return PCM_16_BIT; + case AUDIO_FORMAT_PCM_8_BIT: + return PCM_8_BIT; + default: + return PCM_16_BIT; + }; +} + +uint32_t PcmFramesToBytes(const struct AudioSampleAttributes attrs) +{ + return DEEP_BUFFER_RENDER_PERIOD_SIZE * attrs.channelCount * (PcmFormatToBits(attrs.format) >> 3); +} + +int32_t StopAudioFiles(struct AudioRender **renderS) +{ + if (renderS == NULL) { + return HDF_FAILURE; + } + if (g_waitSleep) { + pthread_mutex_lock(&g_mutex); + g_waitSleep = 0; + pthread_cond_signal(&g_functionCond); + pthread_mutex_unlock(&g_mutex); + } + if (!g_closeEnd) { + g_closeEnd = true; + pthread_join(g_tids, NULL); + } + struct AudioRender *render = *renderS; + if (render == NULL) { + LOG_PARA_INFO_TS("render is null"); + return HDF_FAILURE; + } + int32_t ret = render->control.Stop((AudioHandle)render); + if (ret < 0) { + printf("Stop Render!\n"); + } + if (g_adapter == NULL) { + return HDF_FAILURE; + } + ret = g_adapter->DestroyRender(g_adapter, render); + if (ret < 0) { + printf("Destroy Render!\n"); + } + render = NULL; + g_render = NULL; + if (g_frame != NULL) { + free(g_frame); + g_frame = NULL; + } + if (g_file != NULL) { + fclose(g_file); + g_file = NULL; + } + return ret; +} + +int32_t FrameStart(void *param) +{ + if (param == NULL) { + return HDF_FAILURE; + } + struct StrPara *strParam = (struct StrPara *)param; + struct AudioRender *render = strParam->render; + char *frame = strParam->frame; + int32_t bufferSize = strParam->bufferSize; + int32_t ret; + int32_t readSize; + int32_t remainingDataSize = g_wavHeadInfo.testFileRiffSize; + int32_t numRead; + signal(SIGINT, StreamClose); + uint64_t replyBytes; + 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"); + break; + } + remainingDataSize -= numRead; + } + while (g_waitSleep) { + printf("music pause now.\n"); + pthread_cond_wait(&g_functionCond, &g_mutex); + printf("music resume now.\n"); + } + } while (!g_closeEnd && numRead > 0 && remainingDataSize > 0); + if (!g_closeEnd) { + printf("\nPlay complete, please select input again\n"); + StopAudioFiles(&render); + } + return HDF_SUCCESS; +} + +void FileClose(FILE **file) +{ + if ((file != NULL) || ((*file) != NULL)) { + fclose(*file); + *file = NULL; + } + return; +} + +int32_t PlayingAudioFiles(struct AudioRender **renderS) +{ + if (renderS == NULL || g_adapter == NULL) { + return HDF_FAILURE; + } + if (g_file != NULL) { + printf("the music is playing,please stop first\n"); + return HDF_FAILURE; + } + g_closeEnd = false; + struct AudioRender *render; + 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"); + 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"); + FileClose(&g_file); + return HDF_FAILURE; + } + // Playing audio files + if (render->control.Start((AudioHandle)render)) { + LOG_FUN_ERR_TS("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) { + 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"); + FileClose(&g_file); + return HDF_FAILURE; + } + *renderS = render; + printf("Start Successful,Music is playing\n"); + return HDF_SUCCESS; +} + +void PrintMenu0() +{ + printf(" ============= Play Render Sound Card Mode ==========\n"); + printf("| 1. Render Acodec |\n"); + printf("| 2. Render SmartPA |\n"); + printf(" =================================================== \n"); +} + +void PrintMenu1() +{ + printf(" ============== Play Render Loading Mode ===========\n"); + printf("| 1. Render Direct Loading |\n"); + printf("| 2. Render Service Loading |\n"); + printf("| Note: switching is not supported in the MPI's |\n"); + printf("| version. |\n"); + printf(" ================================================== \n"); +} + +int32_t SwitchInternalOrExternal(char *adapterNameCase) +{ + system("clear"); + int choice = 0; + PrintMenu0(); + printf("Please enter your choice:"); + int32_t ret = CheckInputName(INPUT_INT, (void *)&choice); + if (ret < 0) return HDF_FAILURE; + switch (choice) { + case 1: + snprintf_s(adapterNameCase, PATH_LEN, PATH_LEN - 1, "%s", "usb"); + break; + case 2: // 2. Render SmartPA + snprintf_s(adapterNameCase, PATH_LEN, PATH_LEN - 1, "%s", "hdmi"); + break; + default: + printf("Input error,Switched to Acodec in for you,"); + SystemInputFail(); + snprintf_s(adapterNameCase, PATH_LEN, PATH_LEN - 1, "%s", "usb"); + break; + } + return HDF_SUCCESS; +} + +int32_t SelectLoadingMode(char *resolvedPath, char *func) +{ + system("clear"); + int choice = 0; + PrintMenu1(); + printf("Please enter your choice:"); + int32_t 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"); + 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"); + 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"); + break; + } + return HDF_SUCCESS; +} + +int32_t InitParamSplit(struct AudioAdapterDescriptor *descs, struct AudioManager *manager, + const char *adapterNameCase, int size) +{ + if (descs == NULL || manager == NULL || adapterNameCase == NULL) { + return HDF_FAILURE; + } + int32_t index; + struct AudioPort renderPort; + /* Set sound card information */ + enum AudioPortDirection port = PORT_OUT; // Set port information + /* Get qualified sound card and port */ + index = SwitchAdapter(descs, adapterNameCase, port, &renderPort, size); + if (index < 0) { + LOG_FUN_ERR_TS("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_TS("Load Adapter Fail"); + return HDF_ERR_NOT_SUPPORT; + } + g_manager = manager; + if (g_adapter == NULL) { + LOG_FUN_ERR_TS("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) { + return HDF_FAILURE; + } + // Specify a hardware device + if (InitDevDesc(&g_devDesc, renderPort.portId) < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +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 func[PATH_LEN] = {0}; + if (SelectLoadingMode(resolvedPath, func) < 0) { + return HDF_FAILURE; + } + /* Select loading mode,end */ + struct AudioManager *(*getAudioManager)() = NULL; + 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"); + 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; + } + return HDF_SUCCESS; +} + +int32_t SetRenderMute() +{ + int32_t val; + bool isMute = false; + int32_t ret; + if (g_render == NULL) { + return HDF_FAILURE; + } + ret = g_render->volume.GetMute((AudioHandle)g_render, &isMute); + if (ret < 0) { + printf("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); + if (ret < 0) { + return HDF_FAILURE; + } + if (isMute != 0 && isMute != 1) { + printf("Invalid value,"); + SystemInputFail(); + return HDF_FAILURE; + } + if (g_render == NULL) { + printf("Music already stop,"); + SystemInputFail(); + return HDF_FAILURE; + } + if (val == 1) { + ret = g_render->volume.SetMute((AudioHandle)g_render, !isMute); + } + return ret; +} + +int32_t SetRenderVolume() +{ + int32_t ret; + float val = 0.0; + if (g_render == NULL) { + return HDF_FAILURE; + } + ret = g_render->volume.GetVolume((AudioHandle)g_render, &val); + if (ret < 0) { + printf("Get current volume failed,"); + SystemInputFail(); + return ret; + } + printf("Now the volume is %f ,Please enter the volume value you want to set (0.0-1.0):", val); + ret = CheckInputName(INPUT_FLOAT, (void *)&val); + if (ret < 0) return HDF_FAILURE; + if (val < 0.0 || val > 1.0) { + printf("Invalid volume value,"); + SystemInputFail(); + return HDF_FAILURE; + } + if (g_render == NULL) { + printf("Music already stop,"); + SystemInputFail(); + return HDF_FAILURE; + } + ret = g_render->volume.SetVolume((AudioHandle)g_render, val); + if (ret < 0) { + printf("set volume fail,"); + SystemInputFail(); + } + return ret; +} + +int32_t GetRenderGain() +{ + int32_t ret; + float val = 1.0; + if (g_render == NULL) { + return HDF_FAILURE; + } + ret = g_render->volume.GetGain((AudioHandle)g_render, &val); + if (ret < 0) { + printf("Get current gain failed,"); + SystemInputFail(); + return HDF_FAILURE; + } + printf("Now the gain is %f,", val); + SystemInputFail(); + return HDF_SUCCESS; +} + +int32_t SetRenderPause() +{ + if (g_waitSleep) { + printf("Already pause,not need pause again,"); + SystemInputFail(); + return HDF_FAILURE; + } + int32_t ret; + if (g_render == NULL) { + return HDF_FAILURE; + } + ret = g_render->control.Pause((AudioHandle)g_render); + if (ret != 0) { + return HDF_FAILURE; + } + printf("Pause success!\n"); + g_waitSleep = 1; + return HDF_SUCCESS; +} +int32_t SetRenderResume() +{ + if (!g_waitSleep) { + printf("Now is Playing,not need resume,"); + SystemInputFail(); + return HDF_FAILURE; + } + int32_t ret; + if (g_render == NULL) { + return HDF_FAILURE; + } + ret = g_render->control.Resume((AudioHandle)g_render); + if (ret != 0) { + return HDF_FAILURE; + } + printf("resume success!\n"); + pthread_mutex_lock(&g_mutex); + g_waitSleep = 0; + pthread_cond_signal(&g_functionCond); + pthread_mutex_unlock(&g_mutex); + return HDF_SUCCESS; +} +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"); +} +int32_t SelectAttributesFomat(uint32_t *fomat) +{ + PrintAttributesFromat(); + printf("Please select audio format,If not selected, the default is 16bit:"); + uint32_t ret; + int val = 0; + ret = CheckInputName(INPUT_INT, (void *)&val); + if (ret < 0) return HDF_FAILURE; + switch (val) { + case AUDIO_FORMAT_PCM_8_BIT: + *fomat = AUDIO_FORMAT_PCM_8_BIT; + break; + case AUDIO_FORMAT_PCM_16_BIT: + *fomat = AUDIO_FORMAT_PCM_16_BIT; + break; + case AUDIO_FORMAT_PCM_24_BIT: + *fomat = AUDIO_FORMAT_PCM_24_BIT; + break; + case AUDIO_FORMAT_PCM_32_BIT: + *fomat = AUDIO_FORMAT_PCM_32_BIT; + break; + default: + *fomat = AUDIO_FORMAT_PCM_16_BIT; + break; + } + return HDF_SUCCESS; +} +int32_t SetRenderAttributes() +{ + int32_t ret; + struct AudioSampleAttributes attrs; + ret = g_render->attr.GetSampleAttributes((AudioHandle)g_render, &attrs); + if (ret < 0) { + LOG_FUN_ERR_TS("GetRenderAttributes 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); + } + printf("Set Sample Attributes,"); + SystemInputFail(); + system("clear"); + 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"); + return HDF_FAILURE; + } + printf("\nPlease input sample rate(48000,44100,32000...):"); + ret = CheckInputName(INPUT_UINT32, (void *)(&attrs.sampleRate)); + if (ret < 0) { + return HDF_FAILURE; + } + printf("\nPlease input bigEndian(false=0/true=1):"); + ret = CheckInputName(INPUT_UINT32, (void *)(&attrs.isBigEndian)); + if (ret < 0) { + return HDF_FAILURE; + } + if (g_render == NULL) { + printf("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,"); + SystemInputFail(); + } + return ret; +} + +int32_t SelectRenderScene() +{ + system("clear"); + int32_t ret; + int val = 0; + struct AudioSceneDescriptor scene; + printf(" =================== Select Scene ===================== \n"); + printf("0 is Speaker. |\n"); + printf("1 is HeadPhones. |\n"); + printf(" ====================================================== \n"); + printf("Please input your choice:\n"); + ret = CheckInputName(INPUT_INT, (void *)&val); + if (ret < 0 || (val != 0 && val != 1)) { + printf("Invalid value,"); + SystemInputFail(); + return HDF_FAILURE; + } + if (val == 1) { + scene.scene.id = 0; + scene.desc.pins = PIN_OUT_HEADSET; + } else { + scene.scene.id = 0; + scene.desc.pins = PIN_OUT_SPEAKER; + } + if (g_render == NULL) { + printf("Music already stop,"); + SystemInputFail(); + return HDF_FAILURE; + } + ret = g_render->scene.SelectScene((AudioHandle)g_render, &scene); + if (ret < 0) { + printf("Select scene fail\n"); + } + return ret; +} +void PrintMenu2() +{ + printf(" ================== Play Render Menu ================== \n"); + printf("| 1. Render Start |\n"); + printf("| 2. Render Stop |\n"); + printf("| 3. Render Resume |\n"); + printf("| 4. Render Pause |\n"); + printf("| 5. Render SetVolume |\n"); + printf("| 6. Render GetGain |\n"); + printf("| 7. Render SetMute |\n"); + printf("| 8. Render SetAttributes |\n"); + printf("| 9. Render SelectScene |\n"); + printf("| 10.Exit |\n"); + printf(" ====================================================== \n"); +} + +static struct ProcessRenderMenuSwitchList g_processRenderMenuSwitchList[] = { + {RENDER_START, PlayingAudioFiles}, + {RENDER_STOP, StopAudioFiles}, + {RENDER_RESUME, SetRenderResume}, + {RENDER_PAUSE, SetRenderPause}, + {SET_RENDER_VOLUME, SetRenderVolume}, + {SET_RENDER_GAIN, GetRenderGain}, + {SET_RENDER_MUTE, SetRenderMute}, + {SET_RENDER_ATTRIBUTES, SetRenderAttributes}, + {SET_RENDER_SLECET_SCENE, SelectRenderScene}, +}; + +void ProcessMenu(int32_t choice) +{ + int32_t i; + if (choice == SET_RENDER_SLECET_SCENE + 1) { + printf("Exit from application program!\n"); + return; + } + if (g_render == NULL && choice != 1) { + printf("This render already release,"); + SystemInputFail(); + return; + } + for (i = RENDER_START; i <= SET_RENDER_SLECET_SCENE; ++i) { + if ((choice == (int32_t)g_processRenderMenuSwitchList[i - 1].cmd) && + (g_processRenderMenuSwitchList[i - 1].operation != NULL)) { + g_processRenderMenuSwitchList[i - 1].operation(&g_render); + } + } +} + +int32_t main(int32_t argc, char const *argv[]) +{ + 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) { + system("clear"); + PrintMenu2(); + printf("your choice is:\n"); + ret = CheckInputName(INPUT_INT, (void *)&choice); + if (ret < 0) { + continue; + } + if (choice < RENDER_START || choice > SET_RENDER_SLECET_SCENE + 1) { + printf("You input is wrong,"); + choice = 0; + SystemInputFail(); + continue; + } + ProcessMenu(choice); + } + if (g_render != NULL && g_adapter != NULL) { + StopAudioFiles(&g_render); + } + if (g_manager != NULL) { + g_manager->UnloadAdapter(g_manager, g_adapter); + } + dlclose(g_handle); + return 0; +} diff --git a/audio/supportlibs/adm_adapter/include/audio_interface_lib_capture.h b/audio/supportlibs/adm_adapter/include/audio_interface_lib_capture.h new file mode 100755 index 0000000000000000000000000000000000000000..6d05c98117e77d4b2315430e8d5e1bf0748e15da --- /dev/null +++ b/audio/supportlibs/adm_adapter/include/audio_interface_lib_capture.h @@ -0,0 +1,89 @@ +/* + * 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_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" + +#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 + +enum AudioCriBuffStatusCapture { + CIR_BUFF_NORMAL = 1, + CIR_BUFF_EMPTY = 3, +}; + +enum AudioInterfaceLibCaptureCtrl { + AUDIODRV_CTL_IOCTL_ELEM_INFO_CAPTURE = CTRL_NUM, // Ctrl + AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE, + AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE, + AUDIODRV_CTL_IOCTL_MUTE_READ_CAPTURE, // mute + AUDIODRV_CTL_IOCTL_MUTE_WRITE_CAPTURE, + AUDIODRV_CTL_IOCTL_PAUSE_READ_CAPTURE, // pause + AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE, + AUDIODRV_CTL_IOCTL_ELEM_BUTT_CAPTURE, + AUDIODRV_CTL_IOCTL_GAIN_READ_CAPTURE, // gain + AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE, + AUDIODRV_CTL_IOCTL_SCENESELECT_CAPTURE, // scene selsect + AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_CAPTURE, // scene threshold + AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE, // scene threshold +}; + +struct DevHandleCapture *AudioBindServiceCapture(const char *name); +void AudioCloseServiceCapture(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, + 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, + int cmdId, struct AudioHwCaptureParam *handleData); +#ifdef __cplusplus +} +#endif +#endif /* AUDIO_INTERFACE_LIB_CAPTURE_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 new file mode 100755 index 0000000000000000000000000000000000000000..a37158c7abd6739c08f377685a4da234268a4b46 --- /dev/null +++ b/audio/supportlibs/adm_adapter/include/audio_interface_lib_render.h @@ -0,0 +1,93 @@ +/* + * 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_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" + +#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 + +enum AudioCriBuffStatus { + CIR_BUFF_NO_FULL = 1, + CIR_BUFF_FULL, +}; + +enum AudioInterfaceLibRenderCtrl { + AUDIODRV_CTL_IOCTL_ELEM_INFO = CTRL_NUM, // Ctrl + AUDIODRV_CTL_IOCTL_ELEM_READ, + AUDIODRV_CTL_IOCTL_ELEM_WRITE, + AUDIODRV_CTL_IOCTL_MUTE_READ, // mute + AUDIODRV_CTL_IOCTL_MUTE_WRITE, + AUDIODRV_CTL_IOCTL_PAUSE_WRITE, + AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ, + AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE, + AUDIODRV_CTL_IOCTL_GAIN_WRITE, // gain + AUDIODRV_CTL_IOCTL_GAIN_READ, + AUDIODRV_CTL_IOCTL_SCENESELECT_WRITE, // scene selsect + AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ, // scene threshold + AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN, // acodec change in + AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_OUT, // acodec change out + AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, // get VolThreshold +}; + +typedef int32_t (*InterfaceLibCtlRender)(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); + +struct InterfaceLibCtlRenderList { + enum AudioInterfaceLibRenderCtrl cmd; + InterfaceLibCtlRender func; +}; + +struct DevHandle *AudioBindServiceRender(const char *name); +void AudioCloseServiceRender(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); + +#ifdef __cplusplus +} +#endif +#endif /* AUDIO_INTERFACE_LIB_RENDER_H */ diff --git a/audio/supportlibs/adm_adapter/src/BUILD.gn b/audio/supportlibs/adm_adapter/src/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..bed981a7bd689b937f84bbf3fc40a3c7c27fce44 --- /dev/null +++ b/audio/supportlibs/adm_adapter/src/BUILD.gn @@ -0,0 +1,141 @@ +# 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", + "//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", + "//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 new file mode 100755 index 0000000000000000000000000000000000000000..5bd5a7dde1776f41b24220e056458ec6a8823949 --- /dev/null +++ b/audio/supportlibs/adm_adapter/src/audio_interface_lib_capture.c @@ -0,0 +1,1337 @@ +/* + * 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_interface_lib_capture.h" + +/* virtual mixer device */ +#define AUDIODRV_CTL_CAPTUREELEM_IFACE_MIXER ((int32_t)2) +#define AUDIODRV_CTL_ELEM_IFACE_ADC 1 +#define AUDIODRV_CTL_ELEM_IFACE_GAIN 2 +#define AUDIODRV_CTL_ELEM_IFACE_SELECT 5 + +#define AUDIO_REPLY_EXTEND 16 +#define AUDIO_SIZE_FRAME_16K (16 * 1024) +#define AUDIO_MIN_DEVICENUM 1 + +#define AUDIO_WAIT_MSEC 10000 + +/* Out Put 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] = { + [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) { + LOG_FUN_ERR("card is Error!"); + return HDF_FAILURE; + } + 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.format = handleData->frameCaptureMode.attrs.format; + g_hwParams.period = handleData->frameCaptureMode.attrs.period; + g_hwParams.frameSize = handleData->frameCaptureMode.attrs.frameSize; + g_hwParams.isBigEndian = handleData->frameCaptureMode.attrs.isBigEndian; + g_hwParams.isSignedData = handleData->frameCaptureMode.attrs.isSignedData; + g_hwParams.startThreshold = handleData->frameCaptureMode.attrs.startThreshold; + g_hwParams.stopThreshold = handleData->frameCaptureMode.attrs.stopThreshold; + g_hwParams.silenceThreshold = handleData->frameCaptureMode.attrs.silenceThreshold; + return HDF_SUCCESS; +} + +int32_t ParamsSbufWriteBufferCapture(struct HdfSBuf *sBuf) +{ + if (!HdfSbufWriteUint32(sBuf, (uint32_t)g_hwParams.streamType)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, g_hwParams.channels)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, g_hwParams.rate)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, g_hwParams.periodSize)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, g_hwParams.periodCount)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, (uint32_t)(g_hwParams.format))) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_hwParams.cardServiceName)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, g_hwParams.period)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, g_hwParams.frameSize)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, (uint32_t)(g_hwParams.isBigEndian))) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, (uint32_t)(g_hwParams.isSignedData))) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, g_hwParams.startThreshold)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, g_hwParams.stopThreshold)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, g_hwParams.silenceThreshold)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCtlCaptureSetPauseBuf(struct HdfSBuf *sBuf, 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) { + 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])) { + LOG_FUN_ERR("CaptureSetPauseBuf pause Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(sBuf, g_elemCaptureValue.id.iface)) { + LOG_FUN_ERR("CaptureSetPauseBuf iface Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemCaptureValue.id.cardServiceName)) { + LOG_FUN_ERR("CaptureSetPauseBuf cardServiceName Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_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 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(); + if (sBuf == NULL) { + LOG_FUN_ERR("CaptureSetPauseStu Failed to obtain sBuf"); + return HDF_FAILURE; + } + ret = AudioCtlCaptureSetPauseBuf(sBuf, handleData); + if (ret < 0) { + LOG_FUN_ERR("Failed to Set Pause sBuf!"); + AudioCaptureBufReplyRecycle(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); + return HDF_FAILURE; + } + 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); + return ret; +} + +int32_t AudioCtlCaptureGetVolumeSBuf(struct HdfSBuf *sBuf, 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) { + 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)) { + LOG_FUN_ERR("CaptureGetVolumeSBuf iface Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemCaptureValue.id.cardServiceName)) { + LOG_FUN_ERR("CaptureGetVolumeSBuf cardServiceName Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_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 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(); + if (sBuf == NULL) { + LOG_FUN_ERR("CaptureGetVolume Failed to obtain sBuf"); + return HDF_FAILURE; + } + reply = AudioCapturebtainHdfSBuf(); + if (reply == NULL) { + LOG_FUN_ERR("Failed to obtain reply"); + AudioCaptureBufReplyRecycle(sBuf, NULL); + return HDF_FAILURE; + } + ret = AudioCtlCaptureGetVolumeSBuf(sBuf, handleData); + if (ret < 0) { + LOG_FUN_ERR("Failed to Get Volume sBuf!"); + AudioCaptureBufReplyRecycle(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); + if (ret != HDF_SUCCESS) { + LOG_FUN_ERR("GetVolume Dispatch Fail!"); + AudioCaptureBufReplyRecycle(sBuf, reply); + return HDF_FAILURE; + } + struct AudioCtlCaptureElemValue elemValue; + memset_s(&elemValue, sizeof(struct AudioCtlCaptureElemValue), 0, sizeof(struct AudioCtlCaptureElemValue)); + if (!HdfSbufReadInt32(reply, &elemValue.value[0])) { + LOG_FUN_ERR("Failed to Get Volume sBuf!"); + AudioCaptureBufReplyRecycle(sBuf, reply); + return HDF_FAILURE; + } + handleData->captureMode.ctlParam.volume = elemValue.value[0]; + AudioCaptureBufReplyRecycle(sBuf, reply); + return ret; +} + +int32_t AudioCtlCaptureSetVolumeSBuf(struct HdfSBuf *sBuf, 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) { + 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])) { + LOG_FUN_ERR("CaptureSetVolumeSBuf value[0] Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(sBuf, g_elemCaptureValue.id.iface)) { + LOG_FUN_ERR("CaptureSetVolumeSBuf iface Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemCaptureValue.id.cardServiceName)) { + LOG_FUN_ERR("CaptureSetVolumeSBuf cardServiceName Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_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 ret; + LOG_FUN_INFO(); + if (handle == NULL || handle->object == NULL || handleData == NULL) { + LOG_FUN_ERR("CaptureSetVolume paras is NULL!"); + return HDF_FAILURE; + } + struct HdfIoService *service = NULL; + struct HdfSBuf *reply = NULL; + struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + if (sBuf == NULL) { + LOG_FUN_ERR("CaptureSetVolume Failed to obtain sBuf"); + return HDF_FAILURE; + } + ret = AudioCtlCaptureSetVolumeSBuf(sBuf, handleData); + if (ret < 0) { + LOG_FUN_ERR("CaptureSetVolume Failed to Set Volume sBuf!"); + AudioCaptureBufReplyRecycle(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); + return HDF_FAILURE; + } + 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); + return ret; +} + +int32_t AudioCtlCaptureSetMuteSBuf(struct HdfSBuf *sBuf, 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) { + 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])) { + LOG_FUN_ERR("CaptureSetMuteSBuf mute Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(sBuf, g_elemCaptureValue.id.iface)) { + LOG_FUN_ERR("CaptureSetMuteSBuf iface Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemCaptureValue.id.cardServiceName)) { + LOG_FUN_ERR("CaptureSetMuteSBuf cardServiceName Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_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 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(); + if (sBuf == NULL) { + LOG_FUN_ERR("CaptureSetMuteStu Failed to obtain sBuf"); + return HDF_FAILURE; + } + ret = AudioCtlCaptureSetMuteSBuf(sBuf, handleData); + if (ret < 0) { + LOG_FUN_ERR("CaptureSetMuteStu Failed to Get Mute sBuf!"); + AudioCaptureBufReplyRecycle(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); + return HDF_FAILURE; + } + 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); + return ret; +} + +int32_t AudioCtlCaptureGetMuteSBuf(struct HdfSBuf *sBuf, 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) { + 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)) { + LOG_FUN_ERR("CaptureGetMuteSBuf iface Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemCaptureValue.id.cardServiceName)) { + LOG_FUN_ERR("CaptureGetMuteSBuf cardServiceName Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_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 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(); + if (sBuf == NULL) { + LOG_FUN_ERR("CaptureGetMuteStu Failed to obtain sBuf"); + return HDF_FAILURE; + } + reply = AudioCapturebtainHdfSBuf(); + if (reply == NULL) { + LOG_FUN_ERR("Failed to obtain reply"); + AudioCaptureBufReplyRecycle(sBuf, NULL); + return HDF_FAILURE; + } + ret = AudioCtlCaptureGetMuteSBuf(sBuf, handleData); + if (ret < 0) { + LOG_FUN_ERR("Failed to Get Mute sBuf!"); + AudioCaptureBufReplyRecycle(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); + if (ret != HDF_SUCCESS) { + LOG_FUN_ERR("CaptureGetMuteStu Dispatch Fail!"); + AudioCaptureBufReplyRecycle(sBuf, reply); + return HDF_FAILURE; + } + struct AudioCtlCaptureElemValue muteValueStu; + memset_s(&muteValueStu, sizeof(struct AudioCtlCaptureElemValue), 0, sizeof(struct AudioCtlCaptureElemValue)); + if (!HdfSbufReadInt32(reply, &muteValueStu.value[0])) { + LOG_FUN_ERR("CaptureGetMuteStu Failed to Get Volume sBuf!"); + AudioCaptureBufReplyRecycle(sBuf, reply); + return HDF_FAILURE; + } + handleData->captureMode.ctlParam.mute = muteValueStu.value[0]; + AudioCaptureBufReplyRecycle(sBuf, reply); + return ret; +} + +int32_t AudioCtlCaptureSetGainSBuf(struct HdfSBuf *sBuf, 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) { + 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])) { + LOG_FUN_ERR("CaptureSetGainSBuf mute Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(sBuf, g_elemCaptureValue.id.iface)) { + LOG_FUN_ERR("CaptureSetGainSBuf iface Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemCaptureValue.id.cardServiceName)) { + LOG_FUN_ERR("CaptureSetGainSBuf cardServiceName Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_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) +{ + LOG_FUN_INFO(); + int32_t ret; + if (handle == NULL || handle->object == NULL || handleData == NULL) { + LOG_FUN_ERR("paras is NULL!"); + return HDF_FAILURE; + } + struct HdfIoService *service = NULL; + struct HdfSBuf *reply = NULL; + struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + if (sBuf == NULL) { + LOG_FUN_ERR("CaptureSetGainStu Failed to obtain sBuf"); + return HDF_FAILURE; + } + ret = AudioCtlCaptureSetGainSBuf(sBuf, handleData); + if (ret < 0) { + LOG_FUN_ERR("Failed to Get Gain sBuf!"); + AudioCaptureBufReplyRecycle(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); + return HDF_FAILURE; + } + 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); + return ret; +} + +int32_t AudioCtlCaptureGetGainSBuf(struct HdfSBuf *sBuf, 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) { + 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)) { + LOG_FUN_ERR("CaptureGetGainSBuf iface Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemCaptureValue.id.cardServiceName)) { + LOG_FUN_ERR("CaptureGetGainSBuf cardServiceName Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_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) +{ + 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(); + if (sBuf == NULL) { + LOG_FUN_ERR("CaptureGetGainStu Failed to obtain sBuf"); + return HDF_FAILURE; + } + reply = AudioCapturebtainHdfSBuf(); + if (reply == NULL) { + LOG_FUN_ERR("Failed to obtain reply"); + AudioCaptureBufReplyRecycle(sBuf, NULL); + return HDF_FAILURE; + } + ret = AudioCtlCaptureGetGainSBuf(sBuf, handleData); + if (ret < 0) { + LOG_FUN_ERR("Failed to Get Gain sBuf!"); + AudioCaptureBufReplyRecycle(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); + if (ret != HDF_SUCCESS) { + LOG_FUN_ERR("GetGainStu Dispatch Fail!"); + AudioCaptureBufReplyRecycle(sBuf, reply); + return HDF_FAILURE; + } + struct AudioCtlCaptureElemValue muteValueStu; + memset_s(&muteValueStu, sizeof(struct AudioCtlCaptureElemValue), 0, sizeof(struct AudioCtlCaptureElemValue)); + if (!HdfSbufReadInt32(reply, &muteValueStu.value[0])) { + LOG_FUN_ERR("Failed to GetGain sBuf!"); + AudioCaptureBufReplyRecycle(sBuf, reply); + return HDF_FAILURE; + } + handleData->captureMode.ctlParam.audioGain.gain = muteValueStu.value[0]; + AudioCaptureBufReplyRecycle(sBuf, reply); + return ret; +} + +int32_t AudioCtlCaptureSceneSelectSBuf(struct HdfSBuf *sBuf, + struct AudioHwCaptureParam *handleData, + int32_t deviceIndex) +{ + if (handleData == NULL || sBuf == NULL) { + LOG_FUN_ERR("CaptureSceneSelectSBuf handleData or sBufs is NULL!"); + return HDF_FAILURE; + } + if (deviceIndex < 0 || deviceIndex > PATHPLAN_COUNT - 1) { + 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) { + 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 = + 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])) { + LOG_FUN_ERR("CaptureSceneSelectSBuf Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(sBuf, g_elemCaptureValue.id.iface)) { + LOG_FUN_ERR("CaptureSceneSelectSBuf iface Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemCaptureValue.id.cardServiceName)) { + LOG_FUN_ERR("CaptureSceneSelectSBuf cardServiceName Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_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) +{ + 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(); + 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); + return HDF_FAILURE; + } + for (index = 0; index < deviceNum; index++) { + HdfSbufFlush(sBuf); + if (AudioCtlCaptureSceneSelectSBuf(sBuf, handleData, index) < 0) { + LOG_FUN_ERR("AudioCtlRenderSceneSelectSBuf Failed!"); + AudioCaptureBufReplyRecycle(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); + 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); + return HDF_FAILURE; + } + } + AudioCaptureBufReplyRecycle(sBuf, NULL); + return HDF_SUCCESS; +} + +int32_t AudioCtlCaptureGetGainThresholdSBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData) +{ + if (handleData == NULL || sBuf == NULL) { + LOG_FUN_ERR("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) { + 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)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemCaptureInfo.id.cardServiceName)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemCaptureInfo.id.itemName)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCtlCaptureGetGainThreshold(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("paras is NULL!"); + return HDF_FAILURE; + } + struct HdfIoService *service = NULL; + struct HdfSBuf *reply = NULL; + struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + if (sBuf == NULL) { + LOG_FUN_ERR("Failed to obtain sBuf"); + return HDF_FAILURE; + } + reply = AudioCapturebtainHdfSBuf(); + if (reply == NULL) { + LOG_FUN_ERR("Failed to obtain reply"); + AudioCaptureBufReplyRecycle(sBuf, NULL); + return HDF_FAILURE; + } + ret = AudioCtlCaptureGetGainThresholdSBuf(sBuf, handleData); + if (ret < 0) { + LOG_FUN_ERR("Failed to Get Threshold sBuf!"); + AudioCaptureBufReplyRecycle(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); + if (ret != HDF_SUCCESS) { + AudioCaptureBufReplyRecycle(sBuf, reply); + return HDF_FAILURE; + } + struct AudioCtrlCaptureElemInfo gainThreshold; + memset_s(&gainThreshold, sizeof(struct AudioCtrlCaptureElemInfo), 0, sizeof(struct AudioCtrlCaptureElemInfo)); + if (!HdfSbufReadInt32(reply, &gainThreshold.type)) { + LOG_FUN_ERR("Failed to HdfSbufReadBuffer!"); + AudioCaptureBufReplyRecycle(sBuf, reply); + return HDF_FAILURE; + } + if (!HdfSbufReadInt32(reply, &gainThreshold.max)) { + LOG_FUN_ERR("Failed to HdfSbufReadBuffer!"); + AudioCaptureBufReplyRecycle(sBuf, reply); + return HDF_FAILURE; + } + handleData->captureMode.ctlParam.audioGain.gainMax = gainThreshold.max; + handleData->captureMode.ctlParam.audioGain.gainMin = 0; + AudioCaptureBufReplyRecycle(sBuf, reply); + return ret; +} + +int32_t AudioCtlCaptureGetVolThresholdSBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData) +{ + if (handleData == NULL || sBuf == NULL) { + LOG_FUN_ERR("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) { + LOG_FUN_ERR("CaptureGetGainThresholdSBuf 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)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemCaptureInfo.id.cardServiceName)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemCaptureInfo.id.itemName)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCtlCaptureGetVolThreshold(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(); + if (sBuf == NULL) { + LOG_FUN_ERR("Failed to obtain sBuf"); + return HDF_FAILURE; + } + struct HdfSBuf *reply = AudioCapturebtainHdfSBuf(); + if (reply == NULL) { + LOG_FUN_ERR("Failed to obtain reply"); + AudioCaptureBufReplyRecycle(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); + 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); + 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); + return HDF_FAILURE; + } + if (!HdfSbufReadInt32(reply, &volThreshold.max)) { + AudioCaptureBufReplyRecycle(sBuf, reply); + return HDF_FAILURE; + } + if (!HdfSbufReadInt32(reply, &volThreshold.min)) { + AudioCaptureBufReplyRecycle(sBuf, reply); + return HDF_FAILURE; + } + handleData->captureMode.ctlParam.volThreshold.volMax = volThreshold.max; + handleData->captureMode.ctlParam.volThreshold.volMin = volThreshold.min; + AudioCaptureBufReplyRecycle(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; + } + switch (cmdId) { + /* setPara: */ + case AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE: + ret = AudioCtlCaptureSetVolume(handle, cmdId, handleData); + break; + case AUDIODRV_CTL_IOCTL_MUTE_WRITE_CAPTURE: + ret = AudioCtlCaptureSetMuteStu(handle, cmdId, handleData); + break; + case AUDIODRV_CTL_IOCTL_MUTE_READ_CAPTURE: + ret = AudioCtlCaptureGetMuteStu(handle, cmdId, handleData); + break; + /* getPara: */ + case AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE: + ret = AudioCtlCaptureGetVolume(handle, cmdId, handleData); + break; + case AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE: + ret = AudioCtlCaptureSetGainStu(handle, cmdId, handleData); + break; + case AUDIODRV_CTL_IOCTL_GAIN_READ_CAPTURE: + ret = AudioCtlCaptureGetGainStu(handle, cmdId, handleData); + break; + case AUDIODRV_CTL_IOCTL_SCENESELECT_CAPTURE: + ret = AudioCtlCaptureSceneSelect(handle, cmdId, handleData); + break; + case AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_CAPTURE: + ret = AudioCtlCaptureGetGainThreshold(handle, cmdId, handleData); + break; + case AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE: + ret = AudioCtlCaptureGetVolThreshold(handle, cmdId, handleData); + break; + default: + LOG_FUN_ERR("Ctl Mode not support!"); + ret = HDF_FAILURE; + break; + } + return ret; +} + +int32_t AudioOutputCaptureHwParams(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 HdfIoService *service = NULL; + struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + if (sBuf == NULL) { + LOG_FUN_ERR("Failed to obtain sBuf"); + return HDF_FAILURE; + } + if (SetHwParamsCapture(handleData) < 0) { + AudioCaptureBufReplyRecycle(sBuf, NULL); + return HDF_FAILURE; + } + if (ParamsSbufWriteBufferCapture(sBuf) < 0) { + AudioCaptureBufReplyRecycle(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); + return HDF_FAILURE; + } + int32_t 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); + 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 + if (service == NULL || reply == NULL) { + LOG_FUN_ERR("paras is NULL!"); + return HDF_FAILURE; + } + do { + ret = service->dispatcher->Dispatch(&service->object, cmdId, NULL, reply); + if (ret != HDF_SUCCESS) { + LOG_FUN_ERR("Failed to send service call!"); + HdfSBufRecycle(reply); + return ret; + } + if (!HdfSbufReadUint32(reply, &buffStatus)) { + LOG_FUN_ERR("Failed to Get buffStatus!"); + HdfSBufRecycle(reply); + return HDF_FAILURE; + } + if (buffStatus == CIR_BUFF_EMPTY) { + LOG_PARA_INFO("Cir buff empty wait 50ms"); + tryNumReply--; + HdfSbufFlush(reply); + usleep(AUDIO_WAIT_MSEC); // wait 10ms + continue; + } + break; + } while (tryNumReply > 0); + if (tryNumReply <= 0) { + HdfSBufRecycle(reply); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioOutputCaptureRead(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; + char *frame = NULL; + struct HdfIoService *service = NULL; + if (handle == NULL || handle->object == NULL || handleData == NULL) { + LOG_FUN_ERR("paras is NULL!"); + return HDF_FAILURE; + } + struct HdfSBuf *reply = HdfSBufTypedObtainCapacity(SBUF_RAW, replySize); + if (reply == 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(NULL, reply); + return HDF_FAILURE; + } + int32_t ret = AudioOutputCaptureReadFrame(service, cmdId, reply); + if (ret != 0) { + LOG_FUN_ERR("AudioOutputCaptureReadFrame is Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufReadBuffer(reply, (const void **)&frame, &dataSize)) { + HdfSBufRecycle(reply); + return HDF_FAILURE; + } + if (dataSize > FRAME_DATA || handleData->frameCaptureMode.buffer == NULL) { + LOG_FUN_ERR("Buffer is NULL or DataSize overflow!"); + HdfSBufRecycle(reply); + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(reply, &frameCount)) { + LOG_FUN_ERR("Failed to Get buffStatus!"); + HdfSBufRecycle(reply); + return HDF_FAILURE; + } + memcpy_s(handleData->frameCaptureMode.buffer, FRAME_DATA, frame, dataSize); + handleData->frameCaptureMode.bufferSize = dataSize; + handleData->frameCaptureMode.bufferFrameSize = frameCount; + HdfSBufRecycle(reply); + return HDF_SUCCESS; +} + +int32_t AudioOutputCaptureStartPrepare(struct DevHandleCapture *handle, + int cmdId, struct AudioHwCaptureParam *handleData) +{ + LOG_FUN_INFO(); + int32_t ret; + struct HdfIoService *service = NULL; + if (handle == NULL || handle->object == NULL || handleData == NULL) { + LOG_FUN_ERR("paras is 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!"); + return HDF_FAILURE; + } + ret = service->dispatcher->Dispatch(&service->object, cmdId, NULL, NULL); + if (ret != HDF_SUCCESS) { + LOG_FUN_ERR("Failed to send service call!"); + return ret; + } + return HDF_SUCCESS; +} + +int32_t AudioOutputCaptureStop(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData) +{ + LOG_FUN_INFO(); + int32_t ret; + struct HdfIoService *service = NULL; + if (handle == NULL || handle->object == NULL || handleData == NULL) { + LOG_FUN_ERR("paras is 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!"); + return HDF_FAILURE; + } + ret = service->dispatcher->Dispatch(&service->object, cmdId, NULL, NULL); + if (ret != HDF_SUCCESS) { + LOG_FUN_ERR("Failed to send service call!"); + return ret; + } + return HDF_SUCCESS; +} + +int32_t AudioInterfaceLibOutputCapture(struct DevHandleCapture *handle, int cmdId, + struct AudioHwCaptureParam *handleData) +{ + LOG_FUN_INFO(); + if (handle == NULL) { + LOG_FUN_ERR("Input handle is NULL!"); + return HDF_FAILURE; + } + if (handle->object == NULL || handleData == NULL) { + return HDF_FAILURE; + } + int32_t ret; + switch (cmdId) { + case AUDIO_DRV_PCM_IOCTL_HW_PARAMS: + ret = AudioOutputCaptureHwParams(handle, cmdId, handleData); + break; + case AUDIO_DRV_PCM_IOCTL_READ: + ret = AudioOutputCaptureRead(handle, cmdId, handleData); + break; + case AUDIO_DRV_PCM_IOCTRL_START_CAPTURE: + case AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE: + ret = AudioOutputCaptureStartPrepare(handle, cmdId, handleData); + break; + case AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE: + ret = AudioOutputCaptureStop(handle, cmdId, handleData); + break; + case AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE: + ret = AudioCtlCaptureSetPauseStu(handle, cmdId, handleData); + break; + default: + LOG_FUN_ERR("Output Mode not support!"); + ret = HDF_FAILURE; + break; + } + return ret; +} + +struct HdfIoService *HdfIoServiceBindName(const char *serviceName) +{ + if (serviceName == NULL) { + LOG_FUN_ERR("service name NULL!"); + return NULL; + } + if (strcmp(serviceName, "hdf_audio_control") == 0) { + return (HdfIoServiceBind("hdf_audio_control")); + } + if (strcmp(serviceName, "hdf_audio_capture") == 0) { + return (HdfIoServiceBind("hdf_audio_capture")); + } + LOG_FUN_ERR("service name not support!"); + return NULL; +} + +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; + } + char *serviceName = (char *)calloc(1, NAME_LEN); + if (serviceName == NULL) { + LOG_FUN_ERR("Failed to OsalMemCalloc serviceName"); + AudioMemFree((void **)&handle); + return NULL; + } + int ret = snprintf_s(serviceName, NAME_LEN - 1, SERVIC_NAME_MAX_LEN + 1, "hdf_audio_%s", name); + if (ret < 0) { + LOG_FUN_ERR("Failed to snprintf_s"); + AudioMemFree((void **)&serviceName); + AudioMemFree((void **)&handle); + return NULL; + } + struct HdfIoService *service = HdfIoServiceBindName(serviceName); + if (service == NULL) { + LOG_FUN_ERR("Failed to get service!"); + AudioMemFree((void **)&serviceName); + AudioMemFree((void **)&handle); + return NULL; + } + LOG_PARA_INFO("serviceName = %s", serviceName); + AudioMemFree((void **)&serviceName); + handle->object = service; + return handle->object; +} + +/* CreatCapture for Bind handle */ +struct DevHandleCapture *AudioBindServiceCapture(const char *name) +{ + LOG_FUN_INFO(); + struct DevHandleCapture *handle = NULL; + if (name == NULL) { + LOG_FUN_ERR("service name NULL!"); + return NULL; + } + handle = (struct DevHandleCapture *)calloc(1, sizeof(struct DevHandleCapture)); + if (handle == NULL) { + LOG_FUN_ERR("Failed to OsalMemCalloc handle"); + return NULL; + } + handle->object = AudioBindServiceCaptureObject(handle, name); + if (handle->object == NULL) { + LOG_FUN_ERR("handle->object is NULL!"); + return NULL; + } + LOG_PARA_INFO("BIND SERVICE SUCCESS!"); + return handle; +} + +void AudioCloseServiceCapture(struct DevHandleCapture *handle) +{ + LOG_FUN_INFO(); + if (handle == NULL || handle->object == NULL) { + LOG_FUN_ERR("handle or handle->object is NULL"); + return; + } + struct HdfIoService *service = (struct HdfIoService *)handle->object; + HdfIoServiceRecycle(service); + AudioMemFree((void **)&handle); + return; +} + +int32_t AudioInterfaceLibModeCapture(struct DevHandleCapture * const handle, + struct AudioHwCaptureParam * const handleData, int cmdId) +{ + LOG_FUN_INFO(); + if (handle == NULL || handle->object == NULL || handleData == NULL) { + LOG_FUN_ERR("paras is NULL!"); + return HDF_FAILURE; + } + switch (cmdId) { + case AUDIO_DRV_PCM_IOCTL_HW_PARAMS: + case AUDIO_DRV_PCM_IOCTL_READ: + case AUDIO_DRV_PCM_IOCTRL_START_CAPTURE: + case AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE: + case AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE: + case AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE: + return (AudioInterfaceLibOutputCapture(handle, cmdId, handleData)); + case AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE: + case AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE: + case AUDIODRV_CTL_IOCTL_MUTE_WRITE_CAPTURE: + case AUDIODRV_CTL_IOCTL_MUTE_READ_CAPTURE: + case AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE: + case AUDIODRV_CTL_IOCTL_GAIN_READ_CAPTURE: + case AUDIODRV_CTL_IOCTL_SCENESELECT_CAPTURE: + case AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_CAPTURE: + case AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE: + return (AudioInterfaceLibCtlCapture(handle, cmdId, handleData)); + default: + LOG_FUN_ERR("Mode Error!"); + break; + } + return HDF_ERR_NOT_SUPPORT; +} + diff --git a/audio/supportlibs/adm_adapter/src/audio_interface_lib_render.c b/audio/supportlibs/adm_adapter/src/audio_interface_lib_render.c new file mode 100755 index 0000000000000000000000000000000000000000..2a939004e6511e5d92aa9c2b350f7f2682f24e62 --- /dev/null +++ b/audio/supportlibs/adm_adapter/src/audio_interface_lib_render.c @@ -0,0 +1,1562 @@ +/* + * 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_interface_lib_render.h" + +#define AUDIODRV_CTL_ELEM_IFACE_DAC 0 +#define AUDIODRV_CTL_ELEM_IFACE_GAIN 2 +#define AUDIODRV_CTL_ELEM_IFACE_MIX 3 +#define AUDIO_SBUF_EXTEND 16 +#define AUDIO_MIN_DEVICENUM 1 +/* Out Put Render */ +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; + +#define AUDIODRV_CTL_ELEM_IFACE_MIXER ((int32_t)2) /* virtual mixer device */ +#define AUDIODRV_CTL_ELEM_TYPE_INTEGER ((int32_t)2) /* integer type */ +#define AUDIODRV_CTL_ELEM_IFACE_PGA ((int32_t)5) /* PGA device */ +#define AUDIODRV_CTL_ELEM_IFACE_ACODEC ((int32_t)4) /* Acodec device */ +#define AUDIODRV_CTL_ELEM_IFACE_AIAO ((int32_t)6) + +#define AUDIODRV_CTL_ACODEC_ENABLE 1 +#define AUDIODRV_CTL_ACODEC_DISABLE 0 +#define AUDIODRV_CTL_EXTERN_CODEC_STR "External Codec Enable" +#define AUDIODRV_CTL_INTERNAL_CODEC_STR "Internally Codec Enable" + +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] = { + [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) { + LOG_FUN_ERR("card is Error!"); + return HDF_FAILURE; + } + 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.format = handleData->frameRenderMode.attrs.format; + g_hwParams.period = handleData->frameRenderMode.attrs.period; + g_hwParams.frameSize = handleData->frameRenderMode.attrs.frameSize; + g_hwParams.isBigEndian = handleData->frameRenderMode.attrs.isBigEndian; + g_hwParams.isSignedData = handleData->frameRenderMode.attrs.isSignedData; + g_hwParams.startThreshold = handleData->frameRenderMode.attrs.startThreshold; + g_hwParams.stopThreshold = handleData->frameRenderMode.attrs.stopThreshold; + g_hwParams.silenceThreshold = handleData->frameRenderMode.attrs.silenceThreshold; + return HDF_SUCCESS; +} + +int32_t AudioCtlRenderSetVolumeSBuf(struct HdfSBuf *sBuf, 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) { + 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])) { + LOG_FUN_ERR("RenderSetVolumeSBuf Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(sBuf, g_elemValue.id.iface)) { + LOG_FUN_ERR("RenderSetVolumeSBuf iface Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemValue.id.cardServiceName)) { + LOG_FUN_ERR("RenderSetVolumeSBuf cardServiceName Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_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) +{ + 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) { + 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)) { + LOG_FUN_ERR("RenderGetVolumeSBuf iface Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemValue.id.cardServiceName)) { + LOG_FUN_ERR("RenderGetVolumeSBuf cardServiceName Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_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 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(); + if (sBuf == NULL) { + LOG_FUN_ERR("Failed to obtain sBuf"); + return HDF_FAILURE; + } + ret = AudioCtlRenderSetVolumeSBuf(sBuf, handleData); + if (ret < 0) { + LOG_FUN_ERR("Failed to Set Volume sBuf!"); + AudioRenderBufReplyRecycle(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); + if (ret != HDF_SUCCESS) { + AudioRenderBufReplyRecycle(sBuf, NULL); + return HDF_FAILURE; + } + AudioRenderBufReplyRecycle(sBuf, NULL); + return ret; +} + +int32_t AudioCtlRenderGetVolume(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(); + if (sBuf == NULL) { + LOG_FUN_ERR("Failed to obtain sBuf"); + return HDF_FAILURE; + } + reply = AudioRenderObtainHdfSBuf(); + if (reply == NULL) { + LOG_FUN_ERR("Failed to obtain reply"); + AudioRenderBufReplyRecycle(sBuf, NULL); + return HDF_FAILURE; + } + ret = AudioCtlRenderGetVolumeSBuf(sBuf, handleData); + if (ret < 0) { + LOG_FUN_ERR("Failed to Get Volume sBuf!"); + AudioRenderBufReplyRecycle(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); + if (ret != HDF_SUCCESS) { + AudioRenderBufReplyRecycle(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("Failed to Get Volume sBuf!"); + AudioRenderBufReplyRecycle(sBuf, reply); + return HDF_FAILURE; + } + handleData->renderMode.ctlParam.volume = elemValue.value[0]; + AudioRenderBufReplyRecycle(sBuf, reply); + return ret; +} + +int32_t AudioCtlRenderSetPauseBuf(struct HdfSBuf *sBuf, 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) { + 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])) { + LOG_FUN_ERR("RenderSetPauseBuf pause Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(sBuf, g_elemValue.id.iface)) { + LOG_FUN_ERR("RenderSetPauseBuf iface Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemValue.id.cardServiceName)) { + LOG_FUN_ERR("RenderSetPauseBuf cardServiceName Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_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 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(); + if (sBuf == NULL) { + LOG_FUN_ERR("RenderSetPauseStu Failed to obtain sBuf"); + return HDF_FAILURE; + } + ret = AudioCtlRenderSetPauseBuf(sBuf, handleData); + if (ret < 0) { + LOG_FUN_ERR("RenderSetPauseStu Failed to Set Pause sBuf!"); + AudioRenderBufReplyRecycle(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); + return HDF_FAILURE; + } + 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); + return ret; +} + +int32_t AudioCtlRenderSetMuteBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData) +{ + if (handleData == NULL || sBuf == NULL) { + LOG_FUN_ERR("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("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])) { + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(sBuf, g_elemValue.id.iface)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemValue.id.cardServiceName)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemValue.id.itemName)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCtlRenderSetMuteStu(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("paras is NULL!"); + return HDF_FAILURE; + } + struct HdfIoService *service = NULL; + struct HdfSBuf *reply = NULL; + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + if (sBuf == NULL) { + LOG_FUN_ERR("Failed to obtain sBuf"); + return HDF_FAILURE; + } + ret = AudioCtlRenderSetMuteBuf(sBuf, handleData); + if (ret < 0) { + LOG_FUN_ERR("Failed to Set Mute sBuf!"); + AudioRenderBufReplyRecycle(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("Service is NULL!"); + AudioRenderBufReplyRecycle(sBuf, NULL); + return HDF_FAILURE; + } + ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, reply); + if (ret != HDF_SUCCESS) { + LOG_FUN_ERR("Failed to send service call!"); + AudioRenderBufReplyRecycle(sBuf, NULL); + return ret; + } + AudioRenderBufReplyRecycle(sBuf, NULL); + return ret; +} + +int32_t AudioCtlRenderGetMuteSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData) +{ + if (handleData == NULL || sBuf == NULL) { + LOG_FUN_ERR("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("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)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemValue.id.cardServiceName)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemValue.id.itemName)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCtlRenderGetMuteStu(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("paras is NULL!"); + return HDF_FAILURE; + } + struct HdfIoService *service = NULL; + struct HdfSBuf *reply = NULL; + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + if (sBuf == NULL) { + LOG_FUN_ERR("Failed to obtain sBuf"); + return HDF_FAILURE; + } + reply = AudioRenderObtainHdfSBuf(); + if (reply == NULL) { + LOG_FUN_ERR("Failed to obtain reply"); + AudioRenderBufReplyRecycle(sBuf, NULL); + return HDF_FAILURE; + } + ret = AudioCtlRenderGetMuteSBuf(sBuf, handleData); + if (ret < 0) { + LOG_FUN_ERR("Failed to Get Mute sBuf!"); + AudioRenderBufReplyRecycle(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); + if (ret != HDF_SUCCESS) { + AudioRenderBufReplyRecycle(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("Failed to Get Volume sBuf!"); + AudioRenderBufReplyRecycle(sBuf, reply); + return HDF_FAILURE; + } + handleData->renderMode.ctlParam.mute = muteValueStu.value[0]; + AudioRenderBufReplyRecycle(sBuf, reply); + return ret; +} + +int32_t AudioCtlRenderSetGainBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData) +{ + if (handleData == NULL || sBuf == NULL) { + LOG_FUN_ERR("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("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])) { + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(sBuf, g_elemValue.id.iface)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemValue.id.cardServiceName)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemValue.id.itemName)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCtlRenderSetGainStu(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("paras is NULL!"); + return HDF_FAILURE; + } + struct HdfIoService *service = NULL; + struct HdfSBuf *reply = NULL; + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + if (sBuf == NULL) { + LOG_FUN_ERR("Failed to obtain sBuf"); + return HDF_FAILURE; + } + ret = AudioCtlRenderSetGainBuf(sBuf, handleData); + if (ret < 0) { + LOG_FUN_ERR("Failed to Set Gain sBuf!"); + AudioRenderBufReplyRecycle(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("Service is NULL!"); + AudioRenderBufReplyRecycle(sBuf, NULL); + return HDF_FAILURE; + } + ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, reply); + if (ret != HDF_SUCCESS) { + LOG_FUN_ERR("Failed to send service call!"); + AudioRenderBufReplyRecycle(sBuf, NULL); + return HDF_FAILURE; + } + AudioRenderBufReplyRecycle(sBuf, NULL); + return ret; +} + +int32_t AudioCtlRenderGetGainSBuf(struct HdfSBuf *sBuf, 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) { + 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)) { + LOG_FUN_ERR("RenderGetGainSBuf iface Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemValue.id.cardServiceName)) { + LOG_FUN_ERR("RenderGetGainSBuf cardServiceName Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_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 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(); + if (sBuf == NULL) { + LOG_FUN_ERR("RenderGetGainStu Failed to obtain sBuf"); + return HDF_FAILURE; + } + reply = AudioRenderObtainHdfSBuf(); + if (reply == NULL) { + LOG_FUN_ERR("RenderGetGainStu Failed to obtain reply"); + AudioRenderBufReplyRecycle(sBuf, NULL); + return HDF_FAILURE; + } + ret = AudioCtlRenderGetGainSBuf(sBuf, handleData); + if (ret < 0) { + LOG_FUN_ERR("RenderGetGainStu ailed to Get Gain sBuf!"); + AudioRenderBufReplyRecycle(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); + if (ret != HDF_SUCCESS) { + LOG_FUN_ERR("Dispatch Fail!"); + AudioRenderBufReplyRecycle(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); + return HDF_FAILURE; + } + handleData->renderMode.ctlParam.audioGain.gain = gainValueStu.value[0]; + AudioRenderBufReplyRecycle(sBuf, reply); + return ret; +} + +int32_t AudioCtlRenderSceneSelectSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData, int32_t deviceIndex) +{ + LOG_FUN_INFO(); + if (handleData == NULL || sBuf == NULL) { + LOG_FUN_ERR("RenderSceneSelectSBuf handleData or sBuf is NULL!"); + return HDF_FAILURE; + } + if (deviceIndex < 0 || deviceIndex > PATHPLAN_COUNT - 1) { + 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) { + 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 = + handleData->renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[deviceIndex].deviceSwitch; + g_elemValue.value[0] = + handleData->renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[deviceIndex].value; + if (!HdfSbufWriteInt32(sBuf, g_elemValue.value[0])) { + LOG_FUN_ERR("RenderSceneSelectSBuf Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(sBuf, g_elemValue.id.iface)) { + LOG_FUN_ERR("RenderSceneSelectSBuf iface Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemValue.id.cardServiceName)) { + LOG_FUN_ERR("RenderSceneSelectSBuf cardServiceName Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_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) +{ + LOG_FUN_INFO(); + int32_t index; + if (handle == NULL || handle->object == NULL || handleData == NULL) { + LOG_FUN_ERR("RenderSceneSelect paras is NULL!"); + return HDF_FAILURE; + } + struct HdfIoService *service = NULL; + struct HdfSBuf *reply = NULL; + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + 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); + return HDF_FAILURE; + } + for (index = 0; index < deviceNum; index++) { + HdfSbufFlush(sBuf); + if (AudioCtlRenderSceneSelectSBuf(sBuf, handleData, index) < 0) { + LOG_FUN_ERR("AudioCtlRenderSceneSelectSBuf Failed!"); + AudioRenderBufReplyRecycle(sBuf, NULL); + return HDF_FAILURE; + } + if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { + LOG_FUN_ERR("Service is NULL!"); + AudioRenderBufReplyRecycle(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); + return HDF_FAILURE; + } + } + AudioRenderBufReplyRecycle(sBuf, NULL); + return HDF_SUCCESS; +} + +int32_t AudioCtlRenderGetVolThresholdSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData) +{ + if (handleData == NULL || sBuf == NULL) { + LOG_FUN_ERR("The parameter is empty!"); + 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) { + LOG_FUN_ERR("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)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemInfo.id.cardServiceName)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemInfo.id.itemName)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCtlRenderSceneGetGainThresholdSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData) +{ + if (handleData == NULL || sBuf == NULL) { + LOG_FUN_ERR("The parameter is empty!"); + 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) { + LOG_FUN_ERR("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)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemInfo.id.cardServiceName)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemInfo.id.itemName)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCtlRenderSceneGetGainThreshold(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("paras is NULL!"); + return HDF_FAILURE; + } + struct HdfIoService *service = NULL; + struct HdfSBuf *reply = NULL; + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + if (sBuf == NULL) { + LOG_FUN_ERR("Failed to obtain sBuf"); + return HDF_FAILURE; + } + reply = AudioRenderObtainHdfSBuf(); + if (reply == NULL) { + LOG_FUN_ERR("reply is NULL"); + AudioRenderBufReplyRecycle(sBuf, NULL); + return HDF_FAILURE; + } + ret = AudioCtlRenderSceneGetGainThresholdSBuf(sBuf, handleData); + if (ret < 0) { + LOG_FUN_ERR("Get Threshold sBuf Fail!"); + AudioRenderBufReplyRecycle(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); + if (ret != HDF_SUCCESS) { + AudioRenderBufReplyRecycle(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("Failed to Get Volume sBuf!"); + AudioRenderBufReplyRecycle(sBuf, reply); + return HDF_FAILURE; + } + if (!HdfSbufReadInt32(reply, &gainThreshold.max)) { + LOG_FUN_ERR("Failed to Get Volume sBuf!"); + AudioRenderBufReplyRecycle(sBuf, reply); + return HDF_FAILURE; + } + handleData->renderMode.ctlParam.audioGain.gainMax = gainThreshold.max; + handleData->renderMode.ctlParam.audioGain.gainMin = 0; + AudioRenderBufReplyRecycle(sBuf, reply); + return ret; +} + +int32_t AudioCtlRenderGetVolThreshold(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(); + if (sBuf == NULL) { + LOG_FUN_ERR("Failed to obtain sBuf"); + return HDF_FAILURE; + } + struct HdfSBuf *reply = AudioRenderObtainHdfSBuf(); + if (reply == NULL) { + LOG_FUN_ERR("reply is NULL"); + AudioRenderBufReplyRecycle(sBuf, NULL); + return HDF_FAILURE; + } + int32_t ret = AudioCtlRenderGetVolThresholdSBuf(sBuf, handleData); + if (ret < 0) { + LOG_FUN_ERR("Get Threshold sBuf Fail!"); + AudioRenderBufReplyRecycle(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); + if (ret != HDF_SUCCESS) { + AudioRenderBufReplyRecycle(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); + return HDF_FAILURE; + } + handleData->renderMode.ctlParam.volThreshold.volMax = volThreshold.max; + handleData->renderMode.ctlParam.volThreshold.volMin = volThreshold.min; + AudioRenderBufReplyRecycle(sBuf, reply); + return ret; +} + +int32_t AudioCtlRenderSetChannelModeBuf(struct HdfSBuf *sBuf, 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) { + LOG_FUN_ERR("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])) { + LOG_FUN_ERR("RenderSetChannelModeBuf mode Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(sBuf, g_elemValue.id.iface)) { + LOG_FUN_ERR("RenderSetChannelModeBuf iface Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemValue.id.cardServiceName)) { + LOG_FUN_ERR("RenderSetChannelModeBuf cardServiceName Write Fail!"); + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_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 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(); + if (sBuf == NULL) { + LOG_FUN_ERR("RenderSetChannelMode Failed to obtain sBuf"); + return HDF_FAILURE; + } + ret = AudioCtlRenderSetChannelModeBuf(sBuf, handleData); + if (ret < 0) { + LOG_FUN_ERR("RenderSetChannelMode Failed to Set ChannelMode sBuf!"); + AudioRenderBufReplyRecycle(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); + return HDF_FAILURE; + } + 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); + return ret; +} + +int32_t AudioCtlRenderGetChannelModeSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData) +{ + if (handleData == NULL || sBuf == NULL) { + LOG_FUN_ERR("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) { + LOG_FUN_ERR("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)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemValue.id.cardServiceName)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemValue.id.itemName)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCtlRenderGetChannelMode(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(); + if (sBuf == NULL) { + LOG_FUN_ERR("RenderGetChannelMode Failed to obtain sBuf"); + return HDF_FAILURE; + } + reply = AudioRenderObtainHdfSBuf(); + if (reply == NULL) { + LOG_FUN_ERR("RenderGetChannelMode Failed to obtain reply"); + AudioRenderBufReplyRecycle(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); + 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); + if (ret != HDF_SUCCESS) { + AudioRenderBufReplyRecycle(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); + return HDF_FAILURE; + } + handleData->frameRenderMode.mode = (enum AudioChannelMode)elemValue.value[0]; + AudioRenderBufReplyRecycle(sBuf, reply); + return ret; +} + +int32_t AudioCtlRenderSetAcodecSBuf(struct HdfSBuf *sBuf, const char *codec, int enable) +{ + if (sBuf == NULL) { + 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])) { + return HDF_FAILURE; + } + if (!HdfSbufWriteInt32(sBuf, g_elemValue.id.iface)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemValue.id.cardServiceName)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_elemValue.id.itemName)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCtlRenderChangeInAcodec(struct HdfIoService *service, + const char *codecName, + struct HdfSBuf *sBuf, + int32_t status, + int cmdId) +{ + LOG_FUN_INFO(); + if (service == NULL || sBuf == NULL) { + LOG_FUN_ERR("service or sBuf is NULL!"); + return HDF_FAILURE; + } + if (AudioCtlRenderSetAcodecSBuf(sBuf, codecName, status)) { + return HDF_FAILURE; + } + cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE - CTRL_NUM; + return (AudioServiceRenderDispatch(service, cmdId, sBuf, NULL)); +} + +int32_t AudioCtlRenderSetAcodecMode(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 HdfIoService *service = NULL; + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + if (sBuf == NULL) { + LOG_FUN_ERR("Failed to obtain sBuf"); + return HDF_FAILURE; + } + service = (struct HdfIoService *)handle->object; + if (cmdId == AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN) { + LOG_PARA_INFO("****Acodec is In****"); + /* disable External Codec */ + if (AudioCtlRenderChangeInAcodec(service, AUDIODRV_CTL_EXTERN_CODEC_STR, + sBuf, AUDIODRV_CTL_ACODEC_DISABLE, cmdId)) { + AudioRenderBufReplyRecycle(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); + return HDF_FAILURE; + } + } else if (cmdId == AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_OUT) { + LOG_PARA_INFO("****Acodec is Out****"); + /* disable Internally Codec */ + if (AudioCtlRenderChangeInAcodec(service, AUDIODRV_CTL_INTERNAL_CODEC_STR, + sBuf, AUDIODRV_CTL_ACODEC_DISABLE, cmdId)) { + AudioRenderBufReplyRecycle(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); + return HDF_FAILURE; + } + } else { + return HDF_FAILURE; + } + AudioRenderBufReplyRecycle(sBuf, NULL); + return HDF_SUCCESS; +} + +int32_t AudioInterfaceLibCtlRender(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; + } + if (cmdId < AUDIODRV_CTL_IOCTL_ELEM_INFO || cmdId > AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ) { + LOG_FUN_ERR("cmdId Not Supported!"); + return HDF_FAILURE; + } + switch (cmdId) { + case AUDIODRV_CTL_IOCTL_ELEM_READ: + return (AudioCtlRenderGetVolume(handle, cmdId, handleData)); + case AUDIODRV_CTL_IOCTL_ELEM_WRITE: + return (AudioCtlRenderSetVolume(handle, cmdId, handleData)); + case AUDIODRV_CTL_IOCTL_MUTE_READ: + return (AudioCtlRenderGetMuteStu(handle, cmdId, handleData)); + case AUDIODRV_CTL_IOCTL_MUTE_WRITE: + return (AudioCtlRenderSetMuteStu(handle, cmdId, handleData)); + case AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ: + return (AudioCtlRenderGetChannelMode(handle, cmdId, handleData)); + case AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE: + return (AudioCtlRenderSetChannelMode(handle, cmdId, handleData)); + case AUDIODRV_CTL_IOCTL_GAIN_WRITE: + return (AudioCtlRenderSetGainStu(handle, cmdId, handleData)); + case AUDIODRV_CTL_IOCTL_GAIN_READ: + return (AudioCtlRenderGetGainStu(handle, cmdId, handleData)); + case AUDIODRV_CTL_IOCTL_SCENESELECT_WRITE: + return (AudioCtlRenderSceneSelect(handle, cmdId, handleData)); + case AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ: + return (AudioCtlRenderSceneGetGainThreshold(handle, cmdId, handleData)); + case AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN: + case AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_OUT: + return (AudioCtlRenderSetAcodecMode(handle, cmdId, handleData)); + case AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ: + return (AudioCtlRenderGetVolThreshold(handle, cmdId, handleData)); + default: + LOG_FUN_ERR("Output Mode not support!"); + break; + } + return HDF_FAILURE; +} + +int32_t ParamsSbufWriteBuffer(struct HdfSBuf *sBuf) +{ + if (!HdfSbufWriteUint32(sBuf, (uint32_t)g_hwParams.streamType)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, g_hwParams.channels)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, g_hwParams.rate)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, g_hwParams.periodSize)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, g_hwParams.periodCount)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, (uint32_t)(g_hwParams.format))) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, g_hwParams.cardServiceName)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, g_hwParams.period)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, g_hwParams.frameSize)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, (uint32_t)(g_hwParams.isBigEndian))) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, (uint32_t)(g_hwParams.isSignedData))) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, g_hwParams.startThreshold)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, g_hwParams.stopThreshold)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, g_hwParams.silenceThreshold)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t FrameSbufWriteBuffer(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData) +{ + LOG_FUN_INFO(); + if (sBuf == NULL || handleData == NULL) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, (uint32_t)(handleData->frameRenderMode.bufferFrameSize))) { + return HDF_FAILURE; + } + if (!HdfSbufWriteBuffer(sBuf, handleData->frameRenderMode.buffer, handleData->frameRenderMode.bufferSize)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioOutputRenderHwParams(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +{ + LOG_FUN_INFO(); + if (handle == NULL || handle->object == NULL || handleData == NULL) { + return HDF_FAILURE; + } + int32_t ret; + struct HdfIoService *service = NULL; + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + if (sBuf == NULL) { + return HDF_FAILURE; + } + if (SetHwParams(handleData) < 0) { + AudioRenderBufReplyRecycle(sBuf, NULL); + return HDF_FAILURE; + } + if (ParamsSbufWriteBuffer(sBuf)) { + AudioRenderBufReplyRecycle(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); + return HDF_FAILURE; + } + 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; +} + +int32_t AudioOutputRenderWriteFrame(struct HdfIoService *service, + int cmdId, + struct HdfSBuf *sBuf, + struct HdfSBuf *reply) +{ + LOG_FUN_INFO(); + int32_t ret; + uint32_t buffStatus = 0; + int32_t tryNum = 50; // try send sBuf count + if (service == NULL || sBuf == NULL || reply == 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); + return ret; + } + if (!HdfSbufReadUint32(reply, &buffStatus)) { + LOG_FUN_ERR("Failed to Get buffStatus!"); + AudioRenderBufReplyRecycle(sBuf, reply); + return HDF_FAILURE; + } + if (buffStatus == CIR_BUFF_FULL) { + LOG_PARA_INFO("Cir buff fulled wait 10ms"); + tryNum--; + usleep(10000); // wait 10ms + continue; + } + break; + } while (tryNum > 0); + AudioRenderBufReplyRecycle(sBuf, reply); + if (tryNum > 0) { + return HDF_SUCCESS; + } else { + LOG_FUN_ERR("Out of tryNum!"); + return HDF_FAILURE; + } +} + +int32_t AudioOutputRenderWrite(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +{ + LOG_FUN_INFO(); + if (handle == NULL || handle->object == NULL || handleData == NULL) { + return HDF_FAILURE; + } + struct HdfIoService *service = NULL; + size_t sbufSize = handleData->frameRenderMode.bufferSize + AUDIO_SBUF_EXTEND; + struct HdfSBuf *sBuf = HdfSBufTypedObtainCapacity(SBUF_RAW, sbufSize); + if (sBuf == NULL) { + LOG_FUN_ERR("Get sBuf Fail"); + return HDF_FAILURE; + } + struct HdfSBuf *reply = AudioRenderObtainHdfSBuf(); + if (reply == NULL) { + LOG_FUN_ERR("reply is empty"); + HdfSBufRecycle(sBuf); + return HDF_FAILURE; + } + if (FrameSbufWriteBuffer(sBuf, handleData)) { + AudioRenderBufReplyRecycle(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); + return HDF_FAILURE; + } + int32_t ret = AudioOutputRenderWriteFrame(service, cmdId, sBuf, reply); + if (ret != 0) { + LOG_FUN_ERR("AudioOutputRenderWriteFrame is Fail!"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioOutputRenderStartPrepare(struct DevHandle *handle, int cmdId, 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("Service is NULL!"); + return HDF_FAILURE; + } + ret = service->dispatcher->Dispatch(&service->object, cmdId, NULL, NULL); + if (ret != HDF_SUCCESS) { + LOG_FUN_ERR("Failed to send service call!"); + return ret; + } + return HDF_SUCCESS; +} + +int32_t AudioOutputRenderStop(struct DevHandle *handle, int cmdId, 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("Service is NULL!"); + return HDF_FAILURE; + } + ret = service->dispatcher->Dispatch(&service->object, cmdId, NULL, NULL); + if (ret != HDF_SUCCESS) { + LOG_FUN_ERR("Failed to send service call!"); + return ret; + } + return HDF_SUCCESS; +} + +int32_t AudioInterfaceLibOutputRender(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +{ + LOG_FUN_INFO(); + if (handle == NULL) { + LOG_FUN_ERR("Input handle is NULL!"); + return HDF_FAILURE; + } + if (handle->object == NULL || handleData == NULL) { + return HDF_FAILURE; + } + int32_t ret; + switch (cmdId) { + 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)); + + default: + LOG_FUN_ERR("Output Mode not support!"); + ret = HDF_FAILURE; + break; + } + return ret; +} + +struct HdfIoService *HdfIoServiceBindName(const char *serviceName) +{ + if (serviceName == NULL) { + LOG_FUN_ERR("service name NULL!"); + return NULL; + } + if (strcmp(serviceName, "hdf_audio_control") == 0) { + return (HdfIoServiceBind("hdf_audio_control")); + } + if (strcmp(serviceName, "hdf_audio_render") == 0) { + return (HdfIoServiceBind("hdf_audio_render")); + } + LOG_FUN_ERR("service name not support!"); + return NULL; +} + +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; + } + char *serviceName = (char *)calloc(1, NAME_LEN); + if (serviceName == NULL) { + LOG_FUN_ERR("Failed to OsalMemCalloc serviceName"); + return HDF_FAILURE; + } + int ret = snprintf_s(serviceName, NAME_LEN - 1, SERVIC_NAME_MAX_LEN + 1, "hdf_audio_%s", name); + if (ret < 0) { + LOG_FUN_ERR("Failed to snprintf_s"); + AudioMemFree((void **)&serviceName); + return HDF_FAILURE; + } + struct HdfIoService *service = HdfIoServiceBindName(serviceName); + if (service == NULL) { + LOG_FUN_ERR("Failed to get service!"); + AudioMemFree((void **)&serviceName); + return HDF_FAILURE; + } + LOG_PARA_INFO("serviceName = %s", serviceName); + AudioMemFree((void **)&serviceName); + handle->object = service; + return HDF_SUCCESS; +} + +/* 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!"); + return NULL; + } + handle = (struct DevHandle *)calloc(1, sizeof(struct DevHandle)); + if (handle == NULL) { + LOG_FUN_ERR("Failed to OsalMemCalloc handle"); + return NULL; + } + int32_t ret = AudioBindServiceRenderObject(handle, name); + if (ret != HDF_SUCCESS) { + LOG_FUN_ERR("handle->object is NULL!"); + AudioMemFree((void **)&handle); + return NULL; + } + LOG_PARA_INFO("BIND SERVICE SUCCESS!"); + return handle; +} + +void AudioCloseServiceRender(struct DevHandle *handle) +{ + LOG_FUN_INFO(); + if (handle == NULL || handle->object == NULL) { + LOG_FUN_ERR("handle or handle->object is NULL"); + return; + } + struct HdfIoService *service = (struct HdfIoService *)handle->object; + HdfIoServiceRecycle(service); + AudioMemFree((void **)&handle); + return; +} + +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; + } + switch (cmdId) { + case AUDIO_DRV_PCM_IOCTL_HW_PARAMS: + case AUDIO_DRV_PCM_IOCTL_WRITE: + case AUDIO_DRV_PCM_IOCTRL_STOP: + case AUDIO_DRV_PCM_IOCTRL_START: + case AUDIO_DRV_PCM_IOCTL_PREPARE: + case AUDIODRV_CTL_IOCTL_PAUSE_WRITE: + return (AudioInterfaceLibOutputRender(handle, cmdId, handleData)); + case AUDIODRV_CTL_IOCTL_ELEM_WRITE: + case AUDIODRV_CTL_IOCTL_ELEM_READ: + case AUDIODRV_CTL_IOCTL_MUTE_WRITE: + case AUDIODRV_CTL_IOCTL_MUTE_READ: + case AUDIODRV_CTL_IOCTL_GAIN_WRITE: + case AUDIODRV_CTL_IOCTL_GAIN_READ: + case AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE: + case AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ: + case AUDIODRV_CTL_IOCTL_SCENESELECT_WRITE: + case AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ: + case AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN: + case AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_OUT: + case AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ: + return (AudioInterfaceLibCtlRender(handle, cmdId, handleData)); + default: + LOG_FUN_ERR("Mode Error!"); + break; + } + return HDF_ERR_NOT_SUPPORT; +} + diff --git a/audio/test/resource/hdi/ohos_test.xml b/audio/test/resource/hdi/ohos_test.xml new file mode 100755 index 0000000000000000000000000000000000000000..4e5f609389ff4fc5e403eb99ceb65ab4063c101c --- /dev/null +++ b/audio/test/resource/hdi/ohos_test.xml @@ -0,0 +1,20 @@ + + + + + + + diff --git a/audio/test/systemtest/BUILD.gn b/audio/test/systemtest/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..b9b506989e3930b6ed22c4de8e493033ef55ae36 --- /dev/null +++ b/audio/test/systemtest/BUILD.gn @@ -0,0 +1,31 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//drivers/adapter/uhdf2/uhdf.gni") + +#################################group######################################### +group("systemtest") { + if(is_standard_system) { + testonly = true + deps = [] + + deps += [ + "adm_interface_lib:lib", + "audio_function:function", + "hdi:hdi", + "adm:adm", + ] + } +} +############################################################################### diff --git a/audio/test/systemtest/adm/BUILD.gn b/audio/test/systemtest/adm/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..d105384fb8808c2972510293d1203f36e5d884df --- /dev/null +++ b/audio/test/systemtest/adm/BUILD.gn @@ -0,0 +1,24 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//drivers/adapter/uhdf2/uhdf.gni") + +###########################end########################### +group("adm") { + testonly = true + deps = [] + deps += [ + "audio_adm_interface:AudioAdmInterfaceTest", + ] +} diff --git a/audio/test/systemtest/adm/audio_adm_interface/BUILD.gn b/audio/test/systemtest/adm/audio_adm_interface/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..5ba2b320d58ddc7de060bfe2b784a272ae10ac43 --- /dev/null +++ b/audio/test/systemtest/adm/audio_adm_interface/BUILD.gn @@ -0,0 +1,67 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//drivers/adapter/uhdf2/uhdf.gni") + +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" + ] + + 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", + ] +} +###########################end########################### + diff --git a/audio/test/systemtest/adm/audio_adm_interface/include/audio_adm_interface_test.h b/audio/test/systemtest/adm/audio_adm_interface/include/audio_adm_interface_test.h new file mode 100755 index 0000000000000000000000000000000000000000..d4146ddabe766b90dacc6586b57015cbc55b0934 --- /dev/null +++ b/audio/test/systemtest/adm/audio_adm_interface/include/audio_adm_interface_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_ADM_INTERFACE_TEST_H +#define AUDIO_ADM_INTERFACE_TEST_H + +#endif 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 new file mode 100755 index 0000000000000000000000000000000000000000..3b4404944f241e8b420d617695b2305724594ba7 --- /dev/null +++ b/audio/test/systemtest/adm/audio_adm_interface/src/audio_adm_interface_test.cpp @@ -0,0 +1,2343 @@ +/* + * 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 adm interface + * + * @since 1.0 + * @version 1.0 + */ +#include "audio_adm_common.h" +#include "audio_adm_interface_test.h" + +using namespace std; +using namespace testing::ext; +using namespace HMOS::Audio; + +namespace { +const int CONTROL_DISP_METHOD_CMD_ILLEGAL = 5; +const int STREAM_DISP_METHOD_CMD_ILLEGAL = 20; +const int CHANEL_MODE_ILLEGAL = 9; +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: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +void AudioAdmInterfaceTest::SetUpTestCase(void) {}; + +void AudioAdmInterfaceTest::TearDownTestCase(void) {}; + +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.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.author: liweiming +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlDispatch_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct HdfIoService *service = nullptr; + struct HdfSBuf *writeBuf = nullptr; + struct HdfSBuf *writeReply = nullptr; + + struct AudioCtlElemValue writeElemValue = { + .id.cardServiceName = "hdf_audio_codec_dev0", + .id.iface = AUDIODRV_CTL_ELEM_IFACE_GAIN, + .id.itemName = "Mic Left Gain", + .value[0] = 5, + }; + + 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, CONTROL_DISP_METHOD_CMD_ILLEGAL, writeBuf, writeReply); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(writeBuf); + HdfIoServiceRecycle(service); +} +/** +* @tc.name Test the ADM ctrl data analysis function via setting the incoming parameter object is nullptr +* @tc.number SUB_Audio_ControlDispatch_0002 +* @tc.desc Test the ADM ctrl data analysis function,return -1 when setting the incoming parameter object is nullptr +* @tc.author: liweiming +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlDispatch_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct HdfIoService *service = nullptr; + struct HdfSBuf *writeBuf = nullptr; + struct HdfSBuf *writeReply = nullptr; + struct HdfObject *objectNull = nullptr; + struct AudioCtlElemValue writeElemValue = { + .id.cardServiceName = "hdf_audio_codec_dev0", + .id.iface = AUDIODRV_CTL_ELEM_IFACE_GAIN, + .id.itemName = "Mic Left Gain", + .value[0] = 5, + }; + + 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(objectNull, AUDIODRV_CTL_IOCTL_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.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.author: liweiming +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamDispatch_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 = 32, .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, STREAM_DISP_METHOD_CMD_ILLEGAL, sBuf, reply); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(sBuf); + HdfIoServiceRecycle(service); +} +/** +* @tc.name Test the ADM stream data analysis function via setting the incoming parameter object is nullptr +* @tc.number SUB_Audio_StreamDispatch_0002 +* @tc.desc Test the ADM stream data analysis function,return -1 when setting the incoming parameter object is nullptr +* @tc.author: liweiming +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamDispatch_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct HdfIoService *service = nullptr; + struct HdfSBuf *sBuf = nullptr; + struct HdfSBuf *reply = nullptr; + struct HdfObject *objectNull = 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_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(objectNull, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, sBuf, reply); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(sBuf); + HdfIoServiceRecycle(service); +} +/** +* @tc.name Test the ADM ctrl function via setting gain is in the range +* @tc.number SUB_Audio_ControlHostElemWrite_Read_0001 +* @tc.desc Test the ADM ctrl function,return 0 when setting gain's value is in the range(value=5) +* @tc.author: liweiming +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_Read_0001, TestSize.Level1) +{ + 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 = { + .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); + 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); +} +/** +* @tc.name Test the ADM ctrl function via setting gain is min value +* @tc.number SUB_Audio_ControlHostElemWrite_Read_0002 +* @tc.desc Test the ADM ctrl function,return 0 when setting gain's value is min value +* @tc.author: liweiming +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_Read_0002, TestSize.Level1) +{ + int32_t ret = -1; + int32_t expectMinValue = 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 = { + .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); + 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); + 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); +} +/** +* @tc.name Test the ADM ctrl function via setting gain is max value +* @tc.number SUB_Audio_ControlHostElemWrite_Read_0003 +* @tc.desc Test the ADM ctrl function,return 0 when setting gain's value is max value +* @tc.author: liweiming +*/ +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 = { + .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); + 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(expectMaxValue, readElemValue.value[0]); + + HdfSBufRecycle(writeBuf); + HdfSBufRecycle(readBuf); + HdfSBufRecycle(readReply); + HdfIoServiceRecycle(service); +} +/** +* @tc.name Test the ADM ctrl function via setting gain is out of the range +* @tc.number SUB_Audio_ControlHostElemWrite_Read_0004 +* @tc.desc Test the ADM ctrl function,return -1 when setting gain's value is out of the range(value=16) +* @tc.author: liweiming +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_Read_0004, TestSize.Level1) +{ + int32_t ret = -1; + struct HdfIoService *service = nullptr; + struct HdfSBuf *writeBuf = nullptr; + struct HdfSBuf *writeReply = nullptr; + struct AudioCtlElemValue writeElemValue = { + .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); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(writeBuf); + HdfIoServiceRecycle(service); +} +/** +* @tc.name Test the ADM ctrl function via setting channelmode is "AUDIO_CHANNEL_NORMAL" +* @tc.number SUB_Audio_ControlHostElemWrite_read_0005 +* @tc.desc Test the ADM ctrl function,return 0 when setting channelmode is "AUDIO_CHANNEL_NORMAL" +* @tc.author: liweiming +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0005, TestSize.Level1) +{ + 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 = { + .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); + 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); +} +/** +* @tc.name Test the ADM ctrl function via setting channelmode is "AUDIO_CHANNEL_BOTH_LEFT" +* @tc.number SUB_Audio_ControlHostElemWrite_read_0006 +* @tc.desc Test the ADM ctrl function,return 0 when setting channelmode is "AUDIO_CHANNEL_BOTH_LEFT" +* @tc.author: liweiming +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0006, TestSize.Level1) +{ + 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 = { + .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); + 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); +} +/** +* @tc.name Test the ADM ctrl function via setting channelmode is "AUDIO_CHANNEL_BOTH_RIGHT" +* @tc.number SUB_Audio_ControlHostElemWrite_read_0007 +* @tc.desc Test the ADM ctrl function,return 0 when setting channelmode is "AUDIO_CHANNEL_BOTH_RIGHT" +* @tc.author: liweiming +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0007, TestSize.Level1) +{ + 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 = { + .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); + 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); +} +/** +* @tc.name Test the ADM ctrl function via setting channelmode is "AUDIO_CHANNEL_EXCHANGE" +* @tc.number SUB_Audio_ControlHostElemWrite_read_0008 +* @tc.desc Test the ADM ctrl function,return 0 when setting channelmode is "AUDIO_CHANNEL_EXCHANGE" +* @tc.author: liweiming +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0008, TestSize.Level1) +{ + 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 = { + .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); + 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); +} +/** +* @tc.name Test the ADM ctrl function via setting channelmode is "AUDIO_CHANNEL_MIX" +* @tc.number SUB_Audio_ControlHostElemWrite_read_0009 +* @tc.desc Test the ADM ctrl function,return 0 when setting channelmode is "AUDIO_CHANNEL_MIX" +* @tc.author: liweiming +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0009, TestSize.Level1) +{ + 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 = { + .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); + 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); +} +/** +* @tc.name Test the ADM ctrl function via setting channelmode is "AUDIO_CHANNEL_LEFT_MUTE" +* @tc.number SUB_Audio_ControlHostElemWrite_read_0010 +* @tc.desc Test the ADM ctrl function,return 0 when setting channelmode is "AUDIO_CHANNEL_LEFT_MUTE" +* @tc.author: liweiming +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0010, TestSize.Level1) +{ + 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 = { + .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); + 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); +} +/** +* @tc.name Test the ADM ctrl function via setting channelmode is "AUDIO_CHANNEL_RIGHT_MUTE" +* @tc.number SUB_Audio_ControlHostElemWrite_read_00011 +* @tc.desc Test the ADM ctrl function,return 0 when setting channelmode is "AUDIO_CHANNEL_RIGHT_MUTE" +* @tc.author: liweiming +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0011, TestSize.Level1) +{ + 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 = { + .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); + 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); +} +/** +* @tc.name Test the ADM ctrl function via setting channelmode is "AUDIO_CHANNEL_BOTH_MUTE" +* @tc.number SUB_Audio_ControlHostElemWrite_read_00012 +* @tc.desc Test the ADM ctrl function,return 0 when setting channelmode is "AUDIO_CHANNEL_BOTH_MUTE" +* @tc.author: liweiming +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0012, TestSize.Level1) +{ + 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 = { + .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); + 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); + 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); +} +/** +* @tc.name Test the ADM ctrl function via setting channelmode is "CHANEL_MODE_ILLEGAL" +* @tc.number SUB_Audio_ControlHostElemWrite_read_00013 +* @tc.desc Test the ADM ctrl function,return 0 when setting channelmode is "CHANEL_MODE_ILLEGAL" +* @tc.author: liweiming +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0013, TestSize.Level1) +{ + int32_t ret = -1; + struct HdfIoService *service = nullptr; + struct HdfSBuf *writeBuf = nullptr; + struct HdfSBuf *writeReply = nullptr; + struct AudioCtlElemValue writeElemValue = { + .id.cardServiceName = "hdf_audio_codec_dev0", + .id.iface = AUDIODRV_CTL_ELEM_IFACE_AIAO, + .id.itemName = "Render Channel Mode", + .value[0] = CHANEL_MODE_ILLEGAL, + }; + 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); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(writeBuf); + HdfIoServiceRecycle(service); +} +/** +* @tc.name Test the ADM ctrl function via getting gainthreshold +* @tc.number SUB_Audio_ControlHostElemWrite_Read_00014 +* @tc.desc Test the ADM ctrl function,return 0 when getting gainthreshold +* @tc.author: liweiming +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_Read_0014, TestSize.Level1) +{ + int32_t ret = -1; + int32_t expectMinValue = MIN_GAIN_VALUE; + int32_t expectMaxValue = MAX_GAIN_VALUE; + struct HdfIoService *service = nullptr; + struct HdfSBuf *readBuf = nullptr; + struct HdfSBuf *readReply = nullptr; + struct AudioCtlElemId id = { + .cardServiceName = "hdf_audio_codec_dev0", + .iface = AUDIODRV_CTL_ELEM_IFACE_GAIN, + .itemName = "Mic Left Gain", + }; + struct AudioCtlElemValue readElemValue = {}; + service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); + ASSERT_NE(nullptr, service); + ASSERT_NE(nullptr, service->dispatcher); + + readReply = HdfSBufObtainDefaultSize(); + if (readReply == nullptr) { + HdfIoServiceRecycle(service); + ASSERT_NE(nullptr, readReply); + } + readBuf = HdfSBufObtainDefaultSize(); + if (readBuf == nullptr) { + HdfSBufRecycle(readReply); + HdfIoServiceRecycle(service); + ASSERT_NE(nullptr, readBuf); + } + ret = WriteIdToBuf(readBuf, id); + 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]); + HdfSbufReadInt32(readReply, &readElemValue.value[1]); + EXPECT_EQ(expectMinValue, readElemValue.value[1]); + + HdfSBufRecycle(readBuf); + HdfSBufRecycle(readReply); + HdfIoServiceRecycle(service); +} +/** +* @tc.name Test the ADM control data which is writing normal value of volume and reading voulme. +* @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.author: zhouyongxiao +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0015, TestSize.Level1) +{ + int32_t ret = -1; + int32_t readElemExpectValue = 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); + 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(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.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.author: zhouyongxiao +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0016, TestSize.Level1) +{ + int32_t ret = -1; + int32_t readElemExpectMaxValue = 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] = 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); + 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(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.author: zhouyongxiao +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0017, TestSize.Level1) +{ + int32_t ret = -1; + int32_t readElemExpectMinValue = 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] = 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); + 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(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.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 + }; + + 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); + 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.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 + }; + + 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); + 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.author: zhouyongxiao +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_ControlHostElemWrite_read_0020, 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] = 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); + 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(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.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, + }; + 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); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(writeBuf); + HdfSBufRecycle(readBuf); + HdfSBufRecycle(readReply); + HdfIoServiceRecycle(service); +} +/** +* @tc.name Test the ADM render stream data,cmdid is AUDIO_DRV_PCM_IOCTRL_HW_PARAMS +* that format is AUDIO_FORMAT_PCM_8_BIT. +* @tc.number SUB_Audio_StreamHostHwParams_0001 +* @tc.desc Test the ADM render stream data which is issuing hardware parameters that +* format is AUDIO_FORMAT_PCM_8_BITã€channels is 2ã€cardServiceName is hdf_audio_codec_dev0. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0001, 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 = 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); + 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 AUDIO_FORMAT_PCM_16_BIT. +* @tc.number SUB_Audio_StreamHostHwParams_0002 +* @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_codec_dev0. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0002, 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 = 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); + 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 AUDIO_FORMAT_PCM_24_BIT. +* @tc.number SUB_Audio_StreamHostHwParams_0003 +* @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_0003, 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 = 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); + 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 AUDIO_FORMAT_PCM_32_BIT. +* @tc.number SUB_Audio_StreamHostHwParams_0004 +* @tc.desc Test the ADM render stream data which is issuing hardware parameters that +* format is AUDIO_FORMAT_PCM_32_BIT ã€channels is 2ã€cardServiceName is hdf_audio_codec_dev0. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0004, 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 = 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); + 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 AUDIO_FORMAT_AAC_MAIN. +* @tc.number SUB_Audio_StreamHostHwParams_0005 +* @tc.desc Test the ADM render stream data which is issuing hardware parameters that +* format is AUDIO_FORMAT_AAC_MAIN ã€channels is 2ã€cardServiceName is hdf_audio_codec_dev0. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0005, 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 = 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); + 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 AUDIO_FORMAT_AAC_LC. +* @tc.number SUB_Audio_StreamHostHwParams_0006 +* @tc.desc Test the ADM render stream data which is issuing hardware parameters that +* format is AUDIO_FORMAT_AAC_LC ã€channels is 2ã€cardServiceName is hdf_audio_codec_dev0. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0006, 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 = 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); + 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 AUDIO_FORMAT_AAC_LD. +* @tc.number SUB_Audio_StreamHostHwParams_0007 +* @tc.desc Test the ADM render stream data which is issuing hardware parameters that +* format is AUDIO_FORMAT_AAC_LD ã€channels is 2ã€cardServiceName is hdf_audio_codec_dev0. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0007, 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 = 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); + 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 AUDIO_FORMAT_AAC_ELD. +* @tc.number SUB_Audio_StreamHostHwParams_0008 +* @tc.desc Test the ADM render stream data which is issuing hardware parameters that +* format is AUDIO_FORMAT_AAC_ELD ã€channels is 2ã€cardServiceName is hdf_audio_codec_dev0. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0008, 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 = 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); + 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 AUDIO_FORMAT_AAC_HE_V1. +* @tc.number SUB_Audio_StreamHostHwParams_0009 +* @tc.desc Test the ADM render stream data which is issuing hardware parameters that +* format is AUDIO_FORMAT_AAC_HE_V1 ã€channels is 2ã€cardServiceName is hdf_audio_codec_dev0. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0009, 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 = 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); + 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 AUDIO_FORMAT_AAC_HE_V2. +* @tc.number SUB_Audio_StreamHostHwParams_0010 +* @tc.desc Test the ADM render stream data which is issuing hardware parameters that +* format is AUDIO_FORMAT_AAC_HE_V2 ã€channels is 2ã€cardServiceName is hdf_audio_codec_dev0. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostHwParams_0010, 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 = 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); + 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.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) +{ + 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); + 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.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) +{ + 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); + 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.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) +{ + 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); + 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.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) +{ + 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); + 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.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) +{ + 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); + 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.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) +{ + 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); + 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.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) +{ + 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); + 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.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) +{ + 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); + 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.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) +{ + 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); + 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.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) +{ + 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); + 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.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) +{ + 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); + HdfIoServiceRecycle(service); +} +/** +* @tc.name Test the ADM stream data which is sending play data stream. +* @tc.number SUB_Audio_StreamHostWrite_0001 +* @tc.desc Test the ADM control data,cmdid is AUDIO_DRV_PCM_IOCTRL_WRITE. +* @tc.author: zhouyongxiao +*/ +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); + EXPECT_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); + HdfSBufRecycle(sBufT); +} +/** +* @tc.name Test the ADM stream data which is recording data stream. +* @tc.number SUB_Audio_StreamHostRead_0001 +* @tc.desc Test the ADM control data,cmdid is AUDIO_DRV_PCM_IOCTRL_READ. +* @tc.author: zhouyongxiao +*/ +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; + uint32_t readSize = 0; + struct AudioXferi transfer; + 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); + 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); + EXPECT_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); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = HdfSbufReadBuffer(reply, (const void **) & (transfer.buf), &readSize); + EXPECT_NE(transfer.buf, nullptr); + EXPECT_NE(readSize, (uint32_t)0); + HdfSBufRecycle(reply); + HdfSBufRecycle(writeBuf); + HdfIoServiceRecycle(service); +} +/** +* @tc.name Test the ADM stream function via calling prepare function(render service) +* @tc.number SUB_Audio_StreamHostRenderPrepare_0001 +* @tc.desc Test the ADM stream function,return 0 when calling prepare function(render service) +* @tc.author: liweiming +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostRenderPrepare_0001, TestSize.Level1) +{ + 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); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PREPARE, sBuf, reply); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + HdfIoServiceRecycle(service); +} + +/** +* @tc.name Test the ADM stream function via calling prepare function(capture service) +* @tc.number SUB_Audio_StreamHostCapturePrepare_0001 +* @tc.desc Test the ADM stream function,return 0 when calling prepare function(capture service) +* @tc.author: liweiming +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostCapturePrepare_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); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PREPARE, sBuf, reply); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + HdfIoServiceRecycle(service); +} +/** +* @tc.name Test the ADM stream function via calling start function(render service) +* @tc.number SUB_StreamHostRenderStart_0001 +* @tc.desc Test the ADM stream function,return 0 when calling start function(render service) +* @tc.author: liweiming +*/ +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 { + .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); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_START, sBuf, reply); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + HdfIoServiceRecycle(service); +} +/** +* @tc.name Test the ADM stream function via calling start function(capture service) +* @tc.number SUB_StreamHostCaptureStart_0001 +* @tc.desc Test the ADM stream function,return 0 when calling start function(capture service) +* @tc.author: liweiming +*/ +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); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_START, sBuf, reply); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + HdfIoServiceRecycle(service); +} +/** +* @tc.name Test the ADM ctrl function via calling stop function(render service) +* @tc.number SUB_Audio_StreamHostRenderStop_0001 +* @tc.desc Test the ADM ctrl function,return 0 when calling stop function(render service) +* @tc.author: liweiming +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostRenderStop_0001, TestSize.Level1) +{ + 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); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, sBuf, reply); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + HdfIoServiceRecycle(service); +} +/** +* @tc.name Test the ADM ctrl function via calling stop function(capture service) +* @tc.number SUB_Audio_StreamHostCaptureStop_0001 +* @tc.desc Test the ADM ctrl function,return 0 when calling stop function(capture service) +* @tc.author: liweiming +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostCaptureStop_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); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_STOP, sBuf, reply); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + HdfIoServiceRecycle(service); +} +/** +* @tc.name Test the ADM ctrl function via calling pause function(render service) +* @tc.number SUB_Audio_StreamHostRenderPause_0001 +* @tc.desc Test the ADM ctrl function,return 0 when calling pause function(render service) +* @tc.author: liweiming +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostRenderPause_0001, TestSize.Level1) +{ + 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); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PAUSE, sBuf, reply); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + HdfIoServiceRecycle(service); +} +/** +* @tc.name Test the ADM ctrl function via calling pause function(capture service) +* @tc.number SUB_Audio_StreamHostCapturePause_0001 +* @tc.desc Test the ADM ctrl function,return 0 when calling pause function(capture service) +* @tc.author: liweiming +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostCapturePause_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); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PAUSE, sBuf, reply); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + HdfIoServiceRecycle(service); +} +/** +* @tc.name Test the ADM ctrl function via calling pause function(render service) +* @tc.number SUB_Audio_StreamHostRenderResume_0001 +* @tc.desc Test the ADM ctrl function,return 0 when calling pause function(render service) +* @tc.author: liweiming +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostRenderResume_0001, TestSize.Level1) +{ + 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); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_RESUME, sBuf, reply); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + HdfIoServiceRecycle(service); +} +/** +* @tc.name Test the ADM ctrl function via calling pause function(capture service) +* @tc.number SUB_Audio_StreamHostCaptureResume_0001 +* @tc.desc Test the ADM ctrl function,return 0 when calling pause function(capture service) +* @tc.author: liweiming +*/ +HWTEST_F(AudioAdmInterfaceTest, SUB_Audio_StreamHostCaptureResume_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); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_RESUME, sBuf, reply); + 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 new file mode 100755 index 0000000000000000000000000000000000000000..8411bdef0dc17673847a248bf00de5678d0a4ca2 --- /dev/null +++ b/audio/test/systemtest/adm_interface_lib/BUILD.gn @@ -0,0 +1,25 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//drivers/adapter/uhdf2/uhdf.gni") + +###########################end########################### +group("lib") { + testonly = true + deps = [] + deps += [ + "render:AudioLibRenderTest", + "capture:AudioLibCaptureTest", + ] +} \ 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 new file mode 100755 index 0000000000000000000000000000000000000000..9b51862e109c9ea93ee19ba1a10735e428d72e7c --- /dev/null +++ b/audio/test/systemtest/adm_interface_lib/capture/BUILD.gn @@ -0,0 +1,59 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//drivers/adapter/uhdf2/uhdf.gni") + +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" + ] + + 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", + ] +} +###########################end########################### \ No newline at end of file diff --git a/audio/test/systemtest/adm_interface_lib/capture/include/audio_libcapture_test.h b/audio/test/systemtest/adm_interface_lib/capture/include/audio_libcapture_test.h new file mode 100755 index 0000000000000000000000000000000000000000..88db3495913bacdeb1fa2d5cfefa6bb110bf95ab --- /dev/null +++ b/audio/test/systemtest/adm_interface_lib/capture/include/audio_libcapture_test.h @@ -0,0 +1,21 @@ +/* + * 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_LIBCAPTURE_TEST_H +#define AUDIO_LIBCAPTURE_TEST_H + +#include "audio_interface_lib_capture.h" + +#endif 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 new file mode 100755 index 0000000000000000000000000000000000000000..7a84eb2af94bdce83cd6adf7717d581b2353b091 --- /dev/null +++ b/audio/test/systemtest/adm_interface_lib/capture/src/audio_libcapture_test.cpp @@ -0,0 +1,1054 @@ +/* + * 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-related APIs, including custom data types and functions for loading drivers, + * accessing a driver ADM interface lib, and captureing audios + * + * @since 1.0 + * @version 1.0 + */ + +/** + * @file audio_lib_common.h + * + * @brief Declares APIs for operations related to the audio ADM interface lib. + * + * @since 1.0 + * @version 1.0 + */ +#include "audio_lib_common.h" +#include "audio_libcapture_test.h" + +using namespace std; +using namespace testing::ext; +using namespace HMOS::Audio; + +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"; + +class AudioLibCaptureTest : public testing::Test { +public: + static void SetUpTestCase(void); + 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; +}; + +void AudioLibCaptureTest::SetUpTestCase(void) +{ +} + +void AudioLibCaptureTest::TearDownTestCase(void) +{ +} + +void AudioLibCaptureTest::SetUp(void) +{ + char resolvedPath[] = "//system/lib/libhdi_audio_interface_lib_capture.z.so"; + PtrHandle = dlopen(resolvedPath, RTLD_LAZY); + if (PtrHandle == nullptr) { + return; + } + BindServiceCaptureSo = (struct DevHandle* (*)(const char *))dlsym(PtrHandle, "AudioBindServiceCapture"); + InterfaceLibOutputCapture = (int32_t (*)(struct DevHandle *, int, + struct AudioHwCaptureParam *))dlsym(PtrHandle, "AudioInterfaceLibOutputCapture"); + InterfaceLibCtlCapture = (int32_t (*)(struct DevHandle *, int, + struct AudioHwCaptureParam *))dlsym(PtrHandle, "AudioInterfaceLibCtlCapture"); + CloseServiceCaptureSo = (void (*)(struct DevHandle *))dlsym(PtrHandle, "AudioCloseServiceCapture"); + if (BindServiceCaptureSo == nullptr || CloseServiceCaptureSo == nullptr || + InterfaceLibCtlCapture == nullptr || InterfaceLibOutputCapture == nullptr) { + dlclose(PtrHandle); + return; + } +} + +void AudioLibCaptureTest::TearDown(void) +{ + if (PtrHandle != nullptr) { + dlclose(PtrHandle); + PtrHandle = nullptr; + } + if (BindServiceCaptureSo != nullptr) { + BindServiceCaptureSo = nullptr; + } else if (CloseServiceCaptureSo != nullptr) { + CloseServiceCaptureSo = nullptr; + } else if (InterfaceLibOutputCapture != nullptr) { + InterfaceLibOutputCapture = nullptr; + } else { + InterfaceLibCtlCapture = nullptr; + } +} + +/** +* @tc.name Test AudioBindServiceCapture API via legal input +* @tc.number SUB_Audio_InterfaceLibBindServiceCapture_0001 +* @tc.desc Test AudioBindServiceCapture interface,return 0 is call successfully +* @tc.author: wangkang +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibBindServiceCapture_0001, TestSize.Level1) +{ + struct DevHandle *handle = nullptr; + handle = BindServiceCaptureSo(BIND_CONTROL.c_str()); + EXPECT_NE(nullptr, handle); + CloseServiceCaptureSo(handle); +} +/** +* @tc.name Test AudioBindServiceCapture API via invalid input. +* @tc.number SUB_Audio_InterfaceLibBindServiceCapture_0002 +* @tc.desc test Binding failed Service which invalid service Name is rendeo. +* @tc.author: wangkang +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibBindServicecapture_0002, TestSize.Level1) +{ + struct DevHandle *handle = nullptr; + handle = BindServiceCaptureSo(BIND_NAME_ERROR.c_str()); + if (handle != nullptr) { + CloseServiceCaptureSo(handle); + ASSERT_EQ(nullptr, handle); + } + EXPECT_EQ(nullptr, handle); +} +/** +* @tc.name Test AudioBindServiceCapture API via setting the incoming parameter handle is empty. +* @tc.number SUB_Audio_InterfaceLibBindServiceCapture_0003 +* @tc.desc test Binding failed Service, nullptr pointer passed in. +* @tc.author: wangkang +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibBindServiceCapture_0003, TestSize.Level1) +{ + struct DevHandle *handle = {}; + char *bindNameNull = nullptr; + handle = BindServiceCaptureSo(bindNameNull); + if (handle != nullptr) { + CloseServiceCaptureSo(handle); + ASSERT_EQ(nullptr, handle); + } + EXPECT_EQ(nullptr, handle); +} +/** +* @tc.name test BindServiceCaptureSo API via name lens is 25. +* @tc.number SUB_Audio_InterfaceLibBindServiceCapture_0004 +* @tc.desc test Binding failed Service, Log printing 'service name not support!' and 'Failed to get service!'. +* @tc.author: wangkang +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibBindServiceCapture_0004, TestSize.Level1) +{ + struct DevHandle *handle = nullptr; + string bindNameLen = "capturecaptureededededede"; + handle = BindServiceCaptureSo(bindNameLen.c_str()); + if (handle != nullptr) { + CloseServiceCaptureSo(handle); + ASSERT_EQ(nullptr, handle); + } + EXPECT_EQ(nullptr, handle); +} +/** +* @tc.name test BindServiceCaptureSo API via name lens is 26. +* @tc.number SUB_Audio_InterfaceLibBindServiceCapture_0005 +* @tc.desc test Binding failed Service, Log printing 'Failed to snprintf_s'. +* @tc.author: wangkang +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibBindServiceCapture_0005, TestSize.Level1) +{ + struct DevHandle *handle = nullptr; + string bindNameLen = "capturecaptureedededededer"; + handle = BindServiceCaptureSo(bindNameLen.c_str()); + if (handle != nullptr) { + CloseServiceCaptureSo(handle); + ASSERT_EQ(nullptr, handle); + } + EXPECT_EQ(nullptr, handle); +} +/** +* @tc.name test InterfaceLibCtlCapture API via writing mute value that include 1 and 0 and reading mute value. +* @tc.number SUB_Audio_InterfaceLibCtlCapture_MuteWrite_Read_0001 +* @tc.desc test InterfaceLibCtlCapture ,cmdId is AUDIODRV_CTL_IOCTL_MUTE_WRITE_CAPTURE and +* AUDIODRV_CTL_IOCTL_MUTE_READ_CAPTURE. +* @tc.author: wangkang +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_MuteWrite_Read_0001, TestSize.Level1) +{ + int32_t ret = -1; + bool muteValue = 1; + 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); + 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); + hwCapture->captureParam.captureMode.ctlParam.mute = 1; + 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(expectedValue, muteValue); + free(hwCapture); + CloseServiceCaptureSo(handle); +} +/** +* @tc.name test InterfaceLibCtlCapture API via writing mute value that is 2 and read mute value. +* @tc.number SUB_Audio_InterfaceLibCtlCapture_MuteWrite_Read_0002 +* @tc.desc test InterfaceLibCtlCapture ,cmdId is AUDIODRV_CTL_IOCTL_MUTE_WRITE_CAPTURE and +* AUDIODRV_CTL_IOCTL_MUTE_READ_CAPTURE. +* @tc.author: wangkang +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_MuteWrite_Read_0002, TestSize.Level1) +{ + int32_t ret = -1; + bool muteValue = 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); + hwCapture->captureParam.captureMode.ctlParam.mute = 2; + 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(expectedValue, muteValue); + free(hwCapture); + CloseServiceCaptureSo(handle); +} +/** +* @tc.name test InterfaceLibCtlCapture API via writing volume value. +* @tc.number SUB_Audio_InterfaceLibCtlCapture_VolumeWrite_Read_0001 +* @tc.desc test InterfaceLibCtlCapture ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE and +* AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE. +* @tc.author: wangkang +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_VolumeWrite_Read_0001, TestSize.Level1) +{ + int32_t ret = -1; + float volumeValue; + float expectedValue1 = 86; + float expectedValue2 = 1; + 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 = 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-1; + 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(expectedValue1, volumeValue); + + hwCapture->captureParam.captureMode.ctlParam.volume = volumeThresholdValueMin+1; + 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(expectedValue2, volumeValue); + free(hwCapture); + CloseServiceCaptureSo(handle); +} +/** +* @tc.name test InterfaceLibCtlCapture API via writing volume value. +* @tc.number SUB_Audio_InterfaceLibCtlCapture_VolumeWrite_Read_0002 +* @tc.desc test InterfaceLibCtlCapture ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE and +* AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE. +* @tc.author: wangkang +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_VolumeWrite_Read_0002, TestSize.Level1) +{ + int32_t ret = -1; + float volumeValue; + 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 = 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; + 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; + 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); + free(hwCapture); + CloseServiceCaptureSo(handle); +} +/** +* @tc.name test InterfaceLibCtlCapture API via writing volume value. +* @tc.number SUB_Audio_InterfaceLibCtlCapture_VolumeWrite_Read_0003 +* @tc.desc test InterfaceLibCtlCapture ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE and +* AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE. +* @tc.author: wangkang +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_VolumeWrite_Read_0003, TestSize.Level1) +{ + int32_t ret = -1; + 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 = 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+1; + ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_FAILURE, ret); + hwCapture->captureParam.captureMode.ctlParam.volume = volumeThresholdValueMin-1; + ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_FAILURE, ret); + free(hwCapture); + CloseServiceCaptureSo(handle); +} +/** +* @tc.name test InterfaceLibCtlCapture API via writing GetGainthreshold value of Hardware equipment. +* @tc.number SUB_Audio_InterfaceLibCtlCapture_GetVolthresholdRead_0001 +* @tc.desc test InterfaceLibCtlCapture ,cmdId is AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE. +* @tc.author: liutian +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_GetVolthresholdRead_0001, TestSize.Level1) +{ + int32_t ret = -1; + float volumeThresholdValueMax = 0; + float volumeThresholdValueMin = 0; + 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); + + 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); + EXPECT_EQ(expMix, volumeThresholdValueMin); + CloseServiceCaptureSo(handle); + free(hwCapture); +} +/** +* @tc.name test InterfaceLibCtlCapture API via selecting scene. +* @tc.number SUB_Audio_InterfaceLib_CtlCapture_SelectScene_0001 +* @tc.desc test InterfaceLibCtlCapture,cmdId is AUDIODRV_CTL_IOCTL_SCENESELECT_CAPTURE. +* @tc.author: wangkang +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_SelectScene_0001, TestSize.Level1) +{ + 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 AudioSceneDescriptor scene = { + .scene.id = 0, + .desc.pins = PIN_IN_HS_MIC, + }; + hwCapture->captureParam.captureMode.hwInfo.pathSelect.deviceInfo.deviceNum = 1; + ret = strcpy_s(hwCapture->captureParam.captureMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[0].deviceSwitch, + PATHPLAN_COUNT, "LPGA MIC Switch"); + hwCapture->captureParam.captureMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[0].value = 0; + hwCapture->captureParam.frameCaptureMode.attrs.type = (enum AudioCategory)(scene.scene.id); + hwCapture->captureParam.captureMode.hwInfo.deviceDescript.pins = scene.desc.pins; + + ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_SCENESELECT_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + + CloseServiceCaptureSo(handle); + free(hwCapture); +} +/** +* @tc.name test InterfaceLibCtlCapture API via writing normal value of gain and reading gain value. +* @tc.number SUB_Audio_InterfaceLibCtlCapture_GainWrite_Read_0001 +* @tc.desc test InterfaceLibCtlCapture,cmdId is AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE and +* AUDIODRV_CTL_IOCTL_GAIN_READ_CAPTURE. +* @tc.author: wangkang +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_GainWrite_Read_0001, 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); + + ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + gainThresholdValueMax = hwCapture->captureParam.captureMode.ctlParam.audioGain.gainMax; + gainThresholdValueMin = hwCapture->captureParam.captureMode.ctlParam.audioGain.gainMin; + ret = InitHwCaptureMode(hwCapture->captureParam.captureMode); + EXPECT_EQ(HDF_SUCCESS, ret); + + hwCapture->captureParam.captureMode.ctlParam.audioGain.gain = gainThresholdValueMax - 1; + ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_GAIN_READ_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + gainValue = hwCapture->captureParam.captureMode.ctlParam.audioGain.gain; + EXPECT_EQ(gainThresholdValueMax - 1, gainValue); + hwCapture->captureParam.captureMode.ctlParam.audioGain.gain = gainThresholdValueMin + 1; + ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_GAIN_READ_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + gainValue = hwCapture->captureParam.captureMode.ctlParam.audioGain.gain; + EXPECT_EQ(gainThresholdValueMin + 1, gainValue); + hwCapture->captureParam.captureMode.ctlParam.audioGain.gain = 2.3; + ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_GAIN_READ_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + gainValue = hwCapture->captureParam.captureMode.ctlParam.audioGain.gain; + EXPECT_EQ(2, gainValue); + CloseServiceCaptureSo(handle); + free(hwCapture); +} +/** +* @tc.name test InterfaceLibCtlCapture API via writing boundary value of gain and reading gain value. +* @tc.number SUB_Audio_InterfaceLibCtlCapture_GainWrite_Read_0002 +* @tc.desc test InterfaceLibCtlCapture,cmdId is AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE and +* AUDIODRV_CTL_IOCTL_GAIN_READ_CAPTURE. +* @tc.author: wangkang +*/ +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); + + ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + gainThresholdValueMax = hwCapture->captureParam.captureMode.ctlParam.audioGain.gainMax; + gainThresholdValueMin = hwCapture->captureParam.captureMode.ctlParam.audioGain.gainMin; + ret = InitHwCaptureMode(hwCapture->captureParam.captureMode); + EXPECT_EQ(HDF_SUCCESS, ret); + + hwCapture->captureParam.captureMode.ctlParam.audioGain.gain = gainThresholdValueMax; + ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_GAIN_READ_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + gainValue = hwCapture->captureParam.captureMode.ctlParam.audioGain.gain; + EXPECT_EQ(gainThresholdValueMax, gainValue); + hwCapture->captureParam.captureMode.ctlParam.audioGain.gain = gainThresholdValueMin; + ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_GAIN_READ_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + gainValue = hwCapture->captureParam.captureMode.ctlParam.audioGain.gain; + EXPECT_EQ(gainThresholdValueMin, gainValue); + CloseServiceCaptureSo(handle); + free(hwCapture); +} +/** +* @tc.name test InterfaceLibCtlCapture API via writing invalid value of gain. +* @tc.number SUB_Audio_InterfaceLibCtlCapture_GainWrite_Read_0003 +* @tc.desc test InterfaceLibCtlCapture ,return -1,If the threshold is invalid. +* @tc.author: wangkang +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_GainWrite_Read_0003, TestSize.Level1) +{ + int32_t ret = -1; + 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 = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + gainThresholdValueMax = hwCapture->captureParam.captureMode.ctlParam.audioGain.gainMax; + gainThresholdValueMin = hwCapture->captureParam.captureMode.ctlParam.audioGain.gainMin; + ret = InitHwCaptureMode(hwCapture->captureParam.captureMode); + EXPECT_EQ(HDF_SUCCESS, ret); + hwCapture->captureParam.captureMode.ctlParam.audioGain.gain = gainThresholdValueMax + 1; + ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_FAILURE, ret); + hwCapture->captureParam.captureMode.ctlParam.audioGain.gain = gainThresholdValueMin - 1; + ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_FAILURE, ret); + CloseServiceCaptureSo(handle); + free(hwCapture); +} +/** +* @tc.name test InterfaceLibCtlCapture API via writing GetGainthreshold value. +* @tc.number SUB_Audio_InterfaceLibCtlCapture_GetGainthresholdRead_0001 +* @tc.desc test InterfaceLibCtlCapture ,cmdId is AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_CAPTURE(23). +* @tc.author: liutian +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_GetGainthresholdRead_0001, TestSize.Level1) +{ + int32_t ret = -1; + float gainThresholdValueMax, gainThresholdValueMin; + 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); + + ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + gainThresholdValueMax = hwCapture->captureParam.captureMode.ctlParam.audioGain.gainMax; + gainThresholdValueMin = hwCapture->captureParam.captureMode.ctlParam.audioGain.gainMin; + EXPECT_LT(expMax, gainThresholdValueMax); + EXPECT_EQ(expMix, gainThresholdValueMin); + CloseServiceCaptureSo(handle); + free(hwCapture); +} +/** +* @tc.name test InterfaceLibCtlCapture API via inputting cmdid invalid. +* @tc.number SUB_Audio_InterfaceLibCtlCapture_Abnormal_0001 +* @tc.desc test InterfaceLibCtlCapture, cmdId is invalid eg 30,so return -1. +* @tc.author: liutian +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_Abnormal_0001, TestSize.Level1) +{ + 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); + ret = InterfaceLibCtlCapture(handle, 30, &hwCapture->captureParam); + if (ret == 0) { + CloseServiceCaptureSo(handle); + free(hwCapture); + ASSERT_EQ(HDF_FAILURE, ret); + } + EXPECT_EQ(HDF_FAILURE, ret); + CloseServiceCaptureSo(handle); + free(hwCapture); +} +/** +* @tc.name test InterfaceLibCtlCapture API via inputting handleData invalid. +* @tc.number SUB_Audio_InterfaceLibCtlCapture_Abnormal_0002 +* @tc.desc test InterfaceLibCtlCapture, handleData is invalid,so return -1. +* @tc.author: liutian +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_Abnormal_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct DevHandle *handle = nullptr; + struct AudioHwCaptureParam *handleData = nullptr; + handle = BindServiceCaptureSo(BIND_CONTROL.c_str()); + ASSERT_NE(nullptr, handle); + ret = InterfaceLibCtlCapture(handle, AUDIO_DRV_PCM_IOCTL_READ, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + CloseServiceCaptureSo(handle); +} +/** +* @tc.name test InterfaceLibCtlCapture API via don't binding control service. +* @tc.number SUB_Audio_InterfaceLibCtlCapture_Abnormal_0003 +* @tc.desc test Audio lib Interface CtlCapture, but there isn't binding control service,so Interface return -1. +* @tc.author: liutian +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibCtlCapture_Abnormal_0003, 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 = InitHwCaptureMode(hwCapture->captureParam.captureMode); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlCapture(handle, AUDIO_DRV_PCM_IOCTL_READ, &hwCapture->captureParam); + EXPECT_EQ(HDF_FAILURE, ret); + CloseServiceCaptureSo(handle); + free(hwCapture); +} +/** +* @tc.name test InterfaceLibOutputCapture API via cmdid is AUDIO_DRV_PCM_IOCTL_HW_PARAMS. +* @tc.number SUB_Audio_InterfaceLibOutputCapture_HwParams_0001 +* @tc.desc Test AudioOutputcapture interface,return 0 is call successfully. +* @tc.author: liutian +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_HwParams_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); + + ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + CloseServiceCaptureSo(handle); + free(hwCapture); +} +/** +* @tc.name test InterfaceLibOutputCapture API via cmdid is AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE. +* @tc.number SUB_Audio_InterfaceLib_OutputCapture_Prepare_0001 +* @tc.desc test InterfaceLibOutputCapture,cmdId is AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE. +* @tc.author: liutian +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_Prepare_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); + + ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + CloseServiceCaptureSo(handle); + free(hwCapture); +} +/** +* @tc.name test InterfaceLibOutputCapture API via cmdid is AUDIO_DRV_PCM_IOCTRL_START_CAPTURE. +* @tc.number SUB_Audio_InterfaceLib_OutputCapture_Start_0001 +* @tc.desc test InterfaceLibOutputCapture,cmdId is AUDIO_DRV_PCM_IOCTRL_START_CAPTURE. +* @tc.author: liutian +*/ +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); + + ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + 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); + CloseServiceCaptureSo(handle); + free(hwCapture); +} +/** +* @tc.name Test AudioOutputcapture API via cmdid is AUDIO_DRV_PCM_IOCTL_READ. + and AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE. +* @tc.number SUB_Audio_InterfaceLibOutputCapture_Read_Stop_0001 +* @tc.desc test InterfaceLibOutputCapture,cmdId is AUDIO_DRV_PCM_IOCTL_READ and AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE. +* @tc.author: liutian +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_Read_Stop_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); + + ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + 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.frameCaptureMode.buffer = (char *)calloc(1, 1024); + if (hwCapture->captureParam.frameCaptureMode.buffer == nullptr) { + CloseServiceCaptureSo(handle); + free(hwCapture); + ASSERT_NE(nullptr, hwCapture->captureParam.frameCaptureMode.buffer); + } + ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_READ, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + CloseServiceCaptureSo(handle); + free(hwCapture->captureParam.frameCaptureMode.buffer); + free(hwCapture); +} +/** +* @tc.name Test AudioOutputcapture API data flow and control flow are serial. +* @tc.number SUB_Audio_InterfaceLibOutputCapture_0001 +* @tc.desc test Audio lib Interface CtlCapture and OutputCapture,Data stream and control stream send successful. +* @tc.author: liutian +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_0001, TestSize.Level1) +{ + 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); + handle2 = BindServiceCaptureSo(BIND_CAPTURE.c_str()); + if (handle2 == nullptr) { + CloseServiceCaptureSo(handle1); + free(hwCapture); + ASSERT_NE(nullptr, handle2); + } + ret = InitHwCaptureFramepara(hwCapture->captureParam.frameCaptureMode); + 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); + if (hwCapture->captureParam.frameCaptureMode.buffer == nullptr) { + CloseServiceCaptureSo(handle1); + CloseServiceCaptureSo(handle2); + free(hwCapture); + ASSERT_NE(nullptr, hwCapture->captureParam.frameCaptureMode.buffer); + } + ret = InterfaceLibOutputCapture(handle2, AUDIO_DRV_PCM_IOCTL_READ, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputCapture(handle2, AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + CloseServiceCaptureSo(handle1); + CloseServiceCaptureSo(handle2); + free(hwCapture->captureParam.frameCaptureMode.buffer); + free(hwCapture); +} +/** +* @tc.name test InterfaceLibOutputCapture API via pause. +* @tc.number SUB_Audio_InterfaceLibctlcapture_Pause_0001 +* @tc.desc test InterfaceLibOutputCapture,cmdId is AUDIODRV_CTL_IOCTL_PAUSE_WRITE. +* @tc.author: wangkang +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_Pause_0001, TestSize.Level1) +{ + 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); + 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.pause = 1; + ret = InterfaceLibOutputCapture(handle, AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + CloseServiceCaptureSo(handle); + free(hwCapture); +} +/** +* @tc.name test InterfaceLibOutputCapture API via resume. +* @tc.number SUB_Audio_InterfaceLibctlcapture_Resume_0001 +* @tc.desc test InterfaceLibOutputCapture,cmdId is AUDIODRV_CTL_IOCTL_PAUSE_WRITE. +* @tc.author: wangkang +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_Resume_0001, TestSize.Level1) +{ + 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); + 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.pause = 0; + ret = InterfaceLibOutputCapture(handle, AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE, &hwCapture->captureParam); + EXPECT_EQ(HDF_SUCCESS, ret); + CloseServiceCaptureSo(handle); + free(hwCapture); +} +/** +* @tc.name Test InterfaceLibOutputCapture API via setting the cmdId(30) is invalid +* @tc.number SUB_Audio_InterfaceLibOutputCapture_Abnormal_0001 +* @tc.desc test OutputCapture interface, return -1 if the cmdId is invalid. +* @tc.author: liutian +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_Abnormal_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 = InterfaceLibOutputCapture(handle, 30, &hwCapture->captureParam); + EXPECT_EQ(HDF_FAILURE, ret); + CloseServiceCaptureSo(handle); + free(hwCapture); +} +/** +* @tc.name Test Outputcapture API via setting the incoming parameter handleData is empty +* @tc.number SUB_Audio_InterfaceLibOutputCapture_Abnormal_0002 +* @tc.desc Test Outputcapture interface, return -1 if the incoming parameter handleData is empty. +* @tc.author: liutian +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_Abnormal_0002, TestSize.Level1) +{ + 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); + ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_READ, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + CloseServiceCaptureSo(handle); + free(hwCapture); +} +/** +* @tc.name Test Outputcapture API via don't binding render service. +* @tc.number SUB_Audio_InterfaceLibOutputCapture_Abnormal_0003 +* @tc.desc Test Outputcapture interface, return -1. +* @tc.author: liutian +*/ +HWTEST_F(AudioLibCaptureTest, SUB_Audio_InterfaceLibOutputCapture_Abnormal_0003, TestSize.Level1) +{ + 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 = InitHwCaptureFramepara(hwCapture->captureParam.frameCaptureMode); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwCapture->captureParam); + EXPECT_EQ(HDF_FAILURE, ret); + CloseServiceCaptureSo(handle); + free(hwCapture); +} +} \ 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 new file mode 100755 index 0000000000000000000000000000000000000000..c963e1fb8253ca3d00fa5b22e7007f6f812268d5 --- /dev/null +++ b/audio/test/systemtest/adm_interface_lib/render/BUILD.gn @@ -0,0 +1,59 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//drivers/adapter/uhdf2/uhdf.gni") + +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" + ] + + 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", + ] +} +###########################end########################### \ No newline at end of file diff --git a/audio/test/systemtest/adm_interface_lib/render/include/audio_librender_test.h b/audio/test/systemtest/adm_interface_lib/render/include/audio_librender_test.h new file mode 100755 index 0000000000000000000000000000000000000000..8a927415ad550b639dccf198860dba918f5929bc --- /dev/null +++ b/audio/test/systemtest/adm_interface_lib/render/include/audio_librender_test.h @@ -0,0 +1,21 @@ +/* + * 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_LIBRENDER_TEST_H +#define AUDIO_LIBRENDER_TEST_H + +#include "audio_interface_lib_render.h" + +#endif 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 new file mode 100755 index 0000000000000000000000000000000000000000..cd76c24407b37ecd9ffef97922125a2dfcdeaebe --- /dev/null +++ b/audio/test/systemtest/adm_interface_lib/render/src/audio_librender_test.cpp @@ -0,0 +1,1530 @@ +/* + * 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-related APIs, including custom data types and functions for loading drivers, + * accessing a driver ADM interface lib,and rendering audios + * + * @since 1.0 + * @version 1.0 + */ + +/** + * @file audio_lib_common.h + * + * @brief Declares APIs for operations related to the audio ADM interface lib. + * + * @since 1.0 + * @version 1.0 + */ +#include "audio_lib_common.h" +#include "audio_librender_test.h" + +using namespace std; +using namespace testing::ext; +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 ADAPTER_NAME_USB = "usb"; +const string ADAPTER_NAME3 = "internal"; + +class AudioLibRenderTest : public testing::Test { +public: + static void SetUpTestCase(void); + 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; + 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, + struct AudioHeadInfo wavHeadInfo, struct AudioHwRender *hwRender) const; + uint32_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; +}; + +void AudioLibRenderTest::SetUpTestCase(void) +{ +} + +void AudioLibRenderTest::TearDownTestCase(void) +{ +} + +void AudioLibRenderTest::SetUp(void) +{ + char resolvedPath[] = "//system/lib/libhdi_audio_interface_lib_render.z.so"; + PtrHandle = dlopen(resolvedPath, 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 AudioLibRenderTest::TearDown(void) +{ + if (PtrHandle != nullptr) { + dlclose(PtrHandle); + PtrHandle = nullptr; + } + if (BindServiceRenderSo != nullptr) { + BindServiceRenderSo = nullptr; + } else if (CloseServiceRenderSo != nullptr) { + CloseServiceRenderSo = nullptr; + } else if (InterfaceLibOutputRender != nullptr) { + InterfaceLibOutputRender = nullptr; + } else { + InterfaceLibCtlRender = 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; + }; +} + +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; + } +} + +uint32_t AudioLibRenderTest::PcmBytesToFrames(const struct AudioFrameRenderMode &frameRenderMode, uint64_t bytes) const +{ + return bytes / (frameRenderMode.attrs.channelCount * (FormatToBits(frameRenderMode.attrs.format) >> 3)); +} + +/** + * @brief Reading audio file frame. + * + * @param file audio file path + * @param AudioSampleAttributes + * @param struct AudioHeadInfo wavHeadInfo + * @param struct AudioHwRender *hwRender + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise. + */ +uint32_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; + bufferSize = PcmFramesToBytes(attrs); + char *frame = nullptr; + frame = (char *)calloc(1, bufferSize); + if (frame == nullptr) { + return HDF_FAILURE; + } + replyBytes = (uint64_t *)calloc(1, bufferSize); + if (replyBytes == nullptr) { + free(frame); + 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); + return HDF_SUCCESS; +} + +uint32_t AudioLibRenderTest::LibStartAndStream(const std::string path, struct AudioSampleAttributes attrs, + struct DevHandle *handle, struct AudioHwRender *hwRender, struct AudioHeadInfo wavHeadInfo) const +{ + int ret = -1; + 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)) { + return HDF_FAILURE; + } + char absPath[PATH_MAX] = {0}; + if (realpath(path.c_str(), absPath) == nullptr) { + return HDF_FAILURE; + } + FILE *file = fopen(absPath, "rb"); + if (file == nullptr) { + return HDF_FAILURE; + } + if (WavHeadAnalysis(wavHeadInfo, file, attrs)) { + fclose(file); + return HDF_FAILURE; + } + ret = FrameLibStart(file, attrs, wavHeadInfo, hwRender); + if (ret < 0) { + fclose(file); + return HDF_FAILURE; + } + ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_WRITE, &hwRender->renderParam); + if (ret < 0) { + fclose(file); + return HDF_FAILURE; + } + fclose(file); + return HDF_SUCCESS; +} + +uint32_t AudioLibRenderTest::InitHwRender(struct AudioHwRender *hwRender, struct AudioSampleAttributes attrs, + const std::string adapterNameCase) const +{ + int ret = -1; + if (hwRender == nullptr) { + return HDF_FAILURE; + } + if (InitHwRenderMode(hwRender->renderParam.renderMode) or + 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; + } + if (InitAttrs(attrs)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} +/** +* @tc.name test BindServiceRenderSo API via legal input. +* @tc.number SUB_Audio_InterfaceLib_BindServiceRender_0001 +* @tc.desc test Binding succeeded Service which service Name is control_service and close Service. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLib_BindServiceRender_0001, TestSize.Level1) +{ + struct DevHandle *handle = nullptr; + handle = BindServiceRenderSo(BIND_CONTROL.c_str()); + ASSERT_NE(nullptr, handle); + CloseServiceRenderSo(handle); +} +/** +* @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.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLib_BindServiceRender_0002, TestSize.Level1) +{ + struct DevHandle *handle = nullptr; + handle = BindServiceRenderSo(BIND_NAME_ERROR.c_str()); + if (handle != nullptr) { + CloseServiceRenderSo(handle); + ASSERT_EQ(nullptr, handle); + } + EXPECT_EQ(nullptr, handle); +} +/** +* @tc.name test BindServiceRenderSo API via nullptr input. +* @tc.number SUB_Audio_InterfaceLib_BindServiceRender_0003 +* @tc.desc test Binding failed Service, nullptr pointer passed in. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLib_BindServiceRender_0003, TestSize.Level1) +{ + struct DevHandle *handle = nullptr; + char *bindNameNull = nullptr; + handle = BindServiceRenderSo(bindNameNull); + if (handle != nullptr) { + CloseServiceRenderSo(handle); + ASSERT_EQ(nullptr, handle); + } + EXPECT_EQ(nullptr, handle); +} +/** +* @tc.name test BindServiceRenderSo API via binding service name lens is 25. +* @tc.number SUB_Audio_InterfaceLib_BindServiceRender_0004 +* @tc.desc test Binding failed Service, Log printing 'service name not support!' and 'Failed to get service!'. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLib_BindServiceRender_0004, TestSize.Level1) +{ + struct DevHandle *handle = nullptr; + string bindNameLen = "renderrenderedededededede"; + handle = BindServiceRenderSo(bindNameLen.c_str()); + if (handle != nullptr) { + CloseServiceRenderSo(handle); + ASSERT_EQ(nullptr, handle); + } + EXPECT_EQ(nullptr, handle); +} +/** +* @tc.name test BindServiceRenderSo API via binding service name lens is 26. +* @tc.number SUB_Audio_InterfaceLib_BindServiceRender_0005 +* @tc.desc test Binding failed Service, Log printing 'Failed to snprintf_s'. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLib_BindServiceRender_0005, TestSize.Level1) +{ + struct DevHandle *handle = nullptr; + string bindNameLen = "renderrenderededededededer"; + handle = BindServiceRenderSo(bindNameLen.c_str()); + if (handle != nullptr) { + CloseServiceRenderSo(handle); + ASSERT_EQ(nullptr, handle); + } + EXPECT_EQ(nullptr, handle); +} +/** +* @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.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) +{ + 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_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_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 = 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(41, volumevalue); + + hwRender->renderParam.renderMode.ctlParam.volume = 127.9; + 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 AcodecIn is boundary value and reading +* this value. +* @tc.number SUB_Audio_InterfaceLibCtlRender_Volum_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) +{ + 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_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; + 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); + + hwRender->renderParam.renderMode.ctlParam.volume = 127.9; + 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); + } + 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; + 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); + + 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); +} +/** +* @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.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) +{ + 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); + 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 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. +* @tc.number SUB_Audio_InterfaceLibCtlRender_GetVolthresholdRead_0002 +* @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_GetVolthresholdRead_0002, TestSize.Level1) +{ + int32_t ret = -1; + float volumeThresholdValueMax = 0; + float volumeThresholdValueMin = 0; + float expMax = 127; + float expMix = 40; + 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; + EXPECT_EQ(expMax, volumeThresholdValueMax); + EXPECT_EQ(expMix, volumeThresholdValueMin); + CloseServiceRenderSo(handle); + free(hwRender); +} +/** +* @tc.name test InterfaceLibCtlRender API via writing ChannelMode value is normal value and reading this value. +* @tc.number SUB_Audio_InterfaceLibCtlRender_ChannelMode_Write_Read_0001 +* @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE +* and AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_ChannelMode_Write_Read_0001, TestSize.Level1) +{ + 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) { + CloseServiceRenderSo(handle); + ASSERT_NE(nullptr, handle); + } + 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()); + 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); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ, &impl->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + channelModeExc = impl->renderParam.frameRenderMode.mode; + EXPECT_EQ(AUDIO_CHANNEL_BOTH_RIGHT, channelModeExc); + + impl->renderParam.frameRenderMode.mode = AUDIO_CHANNEL_RIGHT_MUTE; + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE, &impl->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ, &impl->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + channelModeExc = impl->renderParam.frameRenderMode.mode; + EXPECT_EQ(AUDIO_CHANNEL_RIGHT_MUTE, channelModeExc); + + CloseServiceRenderSo(handle); + free(impl); +} +/** +* @tc.name test InterfaceLibCtlRender API via writing ChannelMode value is boundary value and reading this value. +* @tc.number SUB_Audio_InterfaceLibCtlRender_ChannelMode_Write_Read_0002 +* @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE +* and AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_ChannelMode_Write_Read_0002, TestSize.Level1) +{ + 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) { + CloseServiceRenderSo(handle); + ASSERT_NE(nullptr, handle); + } + 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()); + 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); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ, &impl->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + channelModeExc = impl->renderParam.frameRenderMode.mode; + EXPECT_EQ(AUDIO_CHANNEL_NORMAL, channelModeExc); + + impl->renderParam.frameRenderMode.mode = AUDIO_CHANNEL_BOTH_MUTE; + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE, &impl->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ, &impl->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + channelModeExc = impl->renderParam.frameRenderMode.mode; + EXPECT_EQ(AUDIO_CHANNEL_BOTH_MUTE, channelModeExc); + + CloseServiceRenderSo(handle); + free(impl); +} +/** +* @tc.name test InterfaceLibCtlRender API via writing mute value that include 1 and 0 and reading mute value. +* @tc.number SUB_Audio_InterfaceLibCtlRender_MuteWrite_Read_0001 +* @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_MUTE_WRITE and AUDIODRV_CTL_IOCTL_MUTE_READ. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_MuteWrite_Read_0001, TestSize.Level1) +{ + int32_t ret = -1; + bool muteValue = 1; + 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); + 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(wishValue, muteValue); + hwRender->renderParam.renderMode.ctlParam.mute = 1; + 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); + CloseServiceRenderSo(handle); + free(hwRender); +} +/** +* @tc.name test InterfaceLibCtlRender API via writing mute value that include 2 and reading mute value. +* @tc.number SUB_Audio_InterfaceLibCtlRender_MuteWrite_Read_0002 +* @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_MUTE_WRITE and AUDIODRV_CTL_IOCTL_MUTE_READ. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_MuteWrite_Read_0002, TestSize.Level1) +{ + int32_t ret = -1; + bool mutevalue = 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); + hwRender->renderParam.renderMode.ctlParam.mute = 2; + 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); + CloseServiceRenderSo(handle); + free(hwRender); +} +/** +* @tc.name test InterfaceLibCtlRender API via selecting scene. +* @tc.number SUB_Audio_InterfaceLib_CtlRender_SelectScene_0001 +* @tc.desc test InterfaceLibCtlRender,cmdId is AUDIODRV_CTL_IOCTL_SCENESELECT_WRITE. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLib_CtlRender_SelectScene_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_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 AudioSceneDescriptor scene = { + .scene.id = 0, + .desc.pins = PIN_OUT_HEADSET, + }; + hwRender->renderParam.renderMode.hwInfo.pathSelect.deviceInfo.deviceNum = 1; + ret = strcpy_s(hwRender->renderParam.renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[0].deviceSwitch, + PATHPLAN_COUNT, "Dacl enable"); + hwRender->renderParam.renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[0].value = 0; + hwRender->renderParam.frameRenderMode.attrs.type = (enum AudioCategory)(scene.scene.id); + hwRender->renderParam.renderMode.hwInfo.deviceDescript.pins = scene.desc.pins; + + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_SCENESELECT_WRITE, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + + CloseServiceRenderSo(handle); + free(hwRender); +} +/** +* @tc.name test InterfaceLibCtlRender API via writing normal gain value. +* @tc.number SUB_Audio_InterfaceLibCtlRender_GainWrite_Read_0001 +* @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_GAIN_WRITE and AUDIODRV_CTL_IOCTL_GAIN_READ. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_GainWrite_Read_0001, TestSize.Level1) +{ + 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); + } + 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); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_READ, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + gainValue = hwRender->renderParam.renderMode.ctlParam.audioGain.gain; + EXPECT_EQ(gainThresholdValueMax - 1, gainValue); + hwRender->renderParam.renderMode.ctlParam.audioGain.gain = gainThresholdValueMin + 1; + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_READ, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + gainValue = hwRender->renderParam.renderMode.ctlParam.audioGain.gain; + EXPECT_EQ(gainThresholdValueMin + 1, gainValue); + hwRender->renderParam.renderMode.ctlParam.audioGain.gain = 2.3; + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_READ, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + gainValue = hwRender->renderParam.renderMode.ctlParam.audioGain.gain; + EXPECT_EQ(2, gainValue); + CloseServiceRenderSo(handle); + free(hwRender); +} +/** +* @tc.name test InterfaceLibCtlRender API via writing boundary value of gain and reading gain value. +* @tc.number SUB_Audio_InterfaceLibCtlRender_GainWrite_Read_0002 +* @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_GAIN_WRITE and AUDIODRV_CTL_IOCTL_GAIN_READ. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_GainWrite_Read_0002, TestSize.Level1) +{ + 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); + } + 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 = gainThresholdValueMin; + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_READ, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + gainValue = hwRender->renderParam.renderMode.ctlParam.audioGain.gain; + EXPECT_EQ(gainThresholdValueMin, gainValue); + hwRender->renderParam.renderMode.ctlParam.audioGain.gain = gainThresholdValueMax; + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_READ, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + gainValue = hwRender->renderParam.renderMode.ctlParam.audioGain.gain; + EXPECT_EQ(gainThresholdValueMax, gainValue); + CloseServiceRenderSo(handle); + free(hwRender); +} +/** +* @tc.name test InterfaceLibCtlRender API via writing gain invalid value. +* @tc.number SUB_Audio_InterfaceLibCtlRender_GainWrite_Read_0003 +* @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_GAIN_WRITE and AUDIODRV_CTL_IOCTL_GAIN_READ. +* @tc.author: zhouyongxiao +*/ +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); + } + 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_FAILURE, ret); + hwRender->renderParam.renderMode.ctlParam.audioGain.gain = gainThresholdValueMin - 1; + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam); + EXPECT_EQ(HDF_FAILURE, ret); + CloseServiceRenderSo(handle); + free(hwRender); +} +/** +* @tc.name test InterfaceLibCtlRender API via getting gainthreshold value. +* @tc.number SUB_Audio_InterfaceLibCtlRender_GetGainthresholdRead_0001 +* @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_GetGainthresholdRead_0001, TestSize.Level1) +{ + int32_t ret = -1; + float gainThresholdValueMax, gainThresholdValueMin; + 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); + } + 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); + CloseServiceRenderSo(handle); + free(hwRender); +} +/** +* @tc.name test InterfaceLibCtlRender API via using Acodec_ChangeIn. +* @tc.number SUB_Audio_InterfaceLibCtlRender_Acodec_ChangeIn_0001 +* @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_Acodec_ChangeIn_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_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); + 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); +} +/** +* @tc.name test InterfaceLibCtlRender API via inputting invalid cmdid. +* @tc.number SUB_Audio_InterfaceLibCtlRender_Abnormal_0001 +* @tc.desc test InterfaceLibCtlRender, cmdId is invalid eg 50,so return -1. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_Abnormal_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); + ret = strcpy_s(hwRender->renderParam.renderMode.hwInfo.adapterName, + NAME_LEN, ADAPTER_NAME_USB.c_str()); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlRender(handle, 50, &hwRender->renderParam); + if (ret == 0) { + CloseServiceRenderSo(handle); + free(hwRender); + ASSERT_EQ(HDF_FAILURE, ret); + } + EXPECT_EQ(HDF_FAILURE, ret); + CloseServiceRenderSo(handle); + free(hwRender); +} +/** +* @tc.name test InterfaceLibCtlRender API via inputting handleData invalid. +* @tc.number SUB_Audio_InterfaceLibCtlRender_Abnormal_0002 +* @tc.desc test InterfaceLibCtlRender, handleData is nullptr,so return -1. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_Abnormal_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct DevHandle *handle = nullptr; + struct AudioHwRenderParam *handleData = nullptr; + handle = BindServiceRenderSo(BIND_CONTROL.c_str()); + ASSERT_NE(nullptr, handle); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, handleData); + if (ret == 0) { + CloseServiceRenderSo(handle); + ASSERT_EQ(HDF_FAILURE, ret); + } + EXPECT_EQ(HDF_FAILURE, ret); + CloseServiceRenderSo(handle); +} +/** +* @tc.name test InterfaceLibCtlRender API via don't binding control service. +* @tc.number SUB_Audio_InterfaceLibCtlRender_Abnormal_0003 +* @tc.desc test Audio lib Interface CtlRender, but there isn't binding control service,so Interface return -1. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_Abnormal_0003, TestSize.Level1) +{ + 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 = InitHwRenderMode(hwRender->renderParam.renderMode); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam); + EXPECT_EQ(HDF_FAILURE, ret); + CloseServiceRenderSo(handle); + free(hwRender); +} +/** +* @tc.name test InterfaceLibOutputRender API via cmdid is AUDIO_DRV_PCM_IOCTL_HW_PARAMS. +* @tc.number SUB_Audio_InterfaceLibOutputRender_HwParams_0001 +* @tc.desc test Audio lib Interface OutputRender.return 0 if the Interface call successful. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_HwParams_0001, TestSize.Level1) +{ + 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); + ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + CloseServiceRenderSo(handle); + free(hwRender); +} +/** +* @tc.name test InterfaceLibOutputRender API via cmdid is AUDIO_DRV_PCM_IOCTL_PREPARE. +* @tc.number SUB_Audio_InterfaceLibOutputRender_Prepare_0001 +* @tc.desc test Audio lib Interface OutputRender.return 0 if the Interface call successful. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Prepare_0001, TestSize.Level1) +{ + 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); + 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); +} +/** +* @tc.name test InterfaceLibOutputRender API via cmdid is AUDIO_DRV_PCM_IOCTRL_START. +* @tc.number SUB_Audio_InterfaceLibOutputRender_Start_0001 +* @tc.desc test Audio lib Interface OutputRender.return 0 if the Interface call successful. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Start_0001, TestSize.Level1) +{ + 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); + 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); + ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_START, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + CloseServiceRenderSo(handle); + free(hwRender); +} +/** +* @tc.name test InterfaceLibOutputRender API via cmdid is AUDIO_DRV_PCM_IOCTL_WRITE and AUDIO_DRV_PCM_IOCTRL_STOP. +* @tc.number SUB_Audio_InterfaceLibOutputRender_Write_Stop_0001 +* @tc.desc test Audio lib Interface OutputRender and Normal data flow distribution. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Write_Stop_0001, TestSize.Level1) +{ + 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); + 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); + ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_START, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + char absPath[PATH_MAX] = {0}; + if (realpath(AUDIO_FILE_PATH.c_str(), absPath) == nullptr) { + cout << "path is not exist!" << endl; + free(hwRender); + CloseServiceRenderSo(handle); + ASSERT_NE(nullptr, absPath); + } + FILE *file = fopen(absPath, "rb"); + if (file == nullptr) { + cout << "failed to open!" << endl; + free(hwRender); + CloseServiceRenderSo(handle); + ASSERT_NE(nullptr, file); + } + if (WavHeadAnalysis(wavHeadInfo, file, attrs) < 0) { + free(hwRender); + fclose(file); + CloseServiceRenderSo(handle); + ASSERT_EQ(HDF_SUCCESS, ret); + } + ret = FrameLibStart(file, 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); + fclose(file); +} +/** +* @tc.name test InterfaceLibCtlRender and InterfaceLibOutputRender API via Serial + transmission of data flow and control flow. +* @tc.number SUB_Audio_InterfaceLibOutputRender_Write_0001 +* @tc.desc test Audio lib Interface CtlRender and OutputRender, Data stream and control stream send successful. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Write_0001, TestSize.Level1) +{ + int32_t ret = -1; + float muteValue = 1; + 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); + handlec = BindServiceRenderSo(BIND_CONTROL.c_str()); + if (handlec == nullptr) { + CloseServiceRenderSo(handler); + 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); + ret = InterfaceLibCtlRender(handlec, AUDIODRV_CTL_IOCTL_MUTE_READ, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + expectedValue = hwRender->renderParam.renderMode.ctlParam.mute; + EXPECT_EQ(expectedValue, muteValue); + ret = LibStartAndStream(AUDIO_FILE_PATH, attrs, handler, hwRender, wavHeadInfo); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputRender(handler, AUDIO_DRV_PCM_IOCTRL_STOP, &hwRender->renderParam); + EXPECT_EQ(HDF_SUCCESS, ret); + CloseServiceRenderSo(handler); + CloseServiceRenderSo(handlec); + free(hwRender); +} +/** +* @tc.name test InterfaceLibOutputRender API via pause. +* @tc.number SUB_Audio_InterfaceLibCtlRender_Pause_0001 +* @tc.desc test InterfaceLibOutputRender,cmdId is AUDIODRV_CTL_IOCTL_PAUSE_WRITE. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Pause_0001, TestSize.Level1) +{ + 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); + 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); +} +/** +* @tc.name test InterfaceLibOutputRender API via resuming. +* @tc.number SUB_Audio_InterfaceLib_CtlRender_Resume_0001 +* @tc.desc test InterfaceLibOutputRender,cmdId is AUDIODRV_CTL_IOCTL_PAUSE_WRITE. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Resume_0001, TestSize.Level1) +{ + 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); + 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); +} +/** +* @tc.name test InterfaceLibOutputRender API via setting the cmdId is invalid. +* @tc.number SUB_Audio_InterfaceLibOutputRender__Abnormal_0001 +* @tc.desc test Audio lib Interface OutputRender via cmdid is invalid and cmdid is 30,so Interface return -1. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Abnormal_0001, TestSize.Level1) +{ + 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); + ret = InterfaceLibOutputRender(handle, 30, &hwRender->renderParam); + EXPECT_EQ(HDF_FAILURE, ret); + CloseServiceRenderSo(handle); + free(hwRender); +} +/** +* @tc.name test InterfaceLibOutputRender API via inputting handleData is nullptr. +* @tc.number SUB_Audio_InterfaceLibOutputRender_Abnormal_0002 +* @tc.desc test Audio lib Interface OutputRender, handleData is nullptr. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Abnormal_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct DevHandle *handle = nullptr; + struct AudioHwRenderParam *handleData = nullptr; + handle = BindServiceRenderSo(BIND_RENDER.c_str()); + ASSERT_NE(nullptr, handle); + ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_WRITE, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + CloseServiceRenderSo(handle); +} +/** +* @tc.name test InterfaceLibOutputRender via don't binding render service. +* @tc.number SUB_Audio_InterfaceLibOutputRender_Abnormal_0003 +* @tc.desc test Audio lib Interface OutputRender, but there isn't binding render service,so Interface return -1. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Abnormal_0003, 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 = InitRenderFramepara(hwRender->renderParam.frameRenderMode); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam); + EXPECT_EQ(HDF_FAILURE, ret); + CloseServiceRenderSo(handle); + free(hwRender); +} +} \ No newline at end of file diff --git a/audio/test/systemtest/audio_function/BUILD.gn b/audio/test/systemtest/audio_function/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..e82b3e35f8b47a2fd4d3ab9e71ce1270b4f2be6e --- /dev/null +++ b/audio/test/systemtest/audio_function/BUILD.gn @@ -0,0 +1,25 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//drivers/adapter/uhdf2/uhdf.gni") + +###########################end########################### +group("function") { + testonly = true + deps = [] + deps += [ + "audio_server:AudioServerFunctionTest", + "audio_pathroute:AudioPathRouteTest", + ] +} diff --git a/audio/test/systemtest/audio_function/audio_pathroute/BUILD.gn b/audio/test/systemtest/audio_function/audio_pathroute/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..297a928a47f687297a53a0b07c17f3d203db1ab6 --- /dev/null +++ b/audio/test/systemtest/audio_function/audio_pathroute/BUILD.gn @@ -0,0 +1,66 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//drivers/adapter/uhdf2/uhdf.gni") + +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" + ] + + 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", + ] +} +###########################end########################### \ No newline at end of file diff --git a/audio/test/systemtest/audio_function/audio_pathroute/include/audio_pathroute_test.h b/audio/test/systemtest/audio_function/audio_pathroute/include/audio_pathroute_test.h new file mode 100755 index 0000000000000000000000000000000000000000..b682839ecfb2627d06dbfe4676e030d87d153ced --- /dev/null +++ b/audio/test/systemtest/audio_function/audio_pathroute/include/audio_pathroute_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_PATHROUTE_TEST_H +#define AUDIO_PATHROUTE_TEST_H + +#endif 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 new file mode 100755 index 0000000000000000000000000000000000000000..5e4d8df84a1320280ff8f492750a1596e7fad139 --- /dev/null +++ b/audio/test/systemtest/audio_function/audio_pathroute/src/audio_pathroute_test.cpp @@ -0,0 +1,443 @@ +/* + * 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 route path function + * + * @since 1.0 + * @version 1.0 + */ + +#include "audio_hdi_common.h" +#include "audio_pathroute_test.h" + +using namespace std; +using namespace testing::ext; +using namespace HMOS::Audio; + +namespace { +const string ADAPTER_USB = "usb"; +const string ADAPTER_INTERNAL = "internal"; +const int REGISTER_STATUS_ON = 1; +const int REGISTER_STATUS_OFF = 0; +static struct AudioCtlElemValue g_elemValues[4] = { + { + .id.cardServiceName = "hdf_audio_codec_dev0", + .id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC, + .id.itemName = "Dacl enable", + .value[0] = 0, + }, { + .id.cardServiceName = "hdf_audio_codec_dev0", + .id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC, + .id.itemName = "Dacr enable", + .value[0] = 0, + }, { + .id.cardServiceName = "hdf_audio_codec_dev0", + .id.iface = AUDIODRV_CTL_ELEM_IFACE_PGA, + .id.itemName = "LPGA MIC Switch", + .value[0] = 0, + }, { + .id.cardServiceName = "hdf_audio_codec_dev0", + .id.iface = AUDIODRV_CTL_ELEM_IFACE_PGA, + .id.itemName = "RPGA MIC Switch", + .value[0] = 0, + } +}; +class AudioPathRouteTest : public testing::Test { +public: + static void SetUpTestCase(void); + 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; +}; + +void AudioPathRouteTest::SetUpTestCase(void) {} + +void AudioPathRouteTest::TearDownTestCase(void) {} + +void AudioPathRouteTest::SetUp(void) +{ + char resolvedPath[] = "//system/lib/libhdi_audio.z.so"; + handleSo = dlopen(resolvedPath, RTLD_LAZY); + if (handleSo == nullptr) { + return; + } + GetAudioManager = (struct AudioManager* (*)())(dlsym(handleSo, "GetAudioManagerFuncs")); + if (GetAudioManager == nullptr) { + return; + } +} + +void AudioPathRouteTest::TearDown(void) +{ + if (handleSo != nullptr) { + dlclose(handleSo); + handleSo = nullptr; + } + if (GetAudioManager != nullptr) { + GetAudioManager = nullptr; + } +} + +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; +} + +/** +* @tc.name Test the audio path route selection funtion of palyback scene +* @tc.number SUB_Audio_AudioPathRoute_0001 +* @tc.desc The audio path route can be opened sucessfuly,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; + 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); + 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.number SUB_Audio_AudioPathRoute_0002 +* @tc.desc The audio path route can be opened sucessfuly,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; + 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); + 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, + }; + ret = render->scene.SelectScene(AudioHandle(render), &scene); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = CheckRegisterStatus(g_elemValues[0].id, g_elemValues[1].id, REGISTER_STATUS_OFF, REGISTER_STATUS_OFF); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test the audio path route selection funtion 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 + 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 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); + 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, &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); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test the audio path route selection funtion of recording scene +* @tc.number SUB_Audio_AudioPathRoute_0004 +* @tc.desc The audio path route can be opened sucessfuly,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); + 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.number SUB_Audio_AudioPathRoute_0005 +* @tc.desc The audio path route can be opened sucessfuly,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; + 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); + 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, + }; + ret = capture->scene.SelectScene(AudioHandle(capture), &scene); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = CheckRegisterStatus(g_elemValues[2].id, g_elemValues[3].id, REGISTER_STATUS_OFF, REGISTER_STATUS_OFF); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test the audio path route selection funtion 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 + 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]); + ASSERT_EQ(HDF_SUCCESS, ret); + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_INTERNAL, &adapter, capturePort); + 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, &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); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test the audio path route selection funtion 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.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; + struct AudioRender *render = nullptr; + ret = PowerOff(g_elemValues[0], g_elemValues[1]); + 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); + 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); + 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); + EXPECT_EQ(HDF_SUCCESS, ret); + captureAdapter->DestroyCapture(captureAdapter, capture); + manager.UnloadAdapter(&manager, captureAdapter); + renderAdapter->DestroyRender(renderAdapter, render); + manager.UnloadAdapter(&manager, renderAdapter); +} +} \ No newline at end of file diff --git a/audio/test/systemtest/audio_function/audio_server/BUILD.gn b/audio/test/systemtest/audio_function/audio_server/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..eb9dbf36f5db181a85e6fb4a09ac4b857f5f05db --- /dev/null +++ b/audio/test/systemtest/audio_function/audio_server/BUILD.gn @@ -0,0 +1,56 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//drivers/adapter/uhdf2/uhdf.gni") + +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/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", + ] +} +###########################end########################### \ No newline at end of file diff --git a/audio/test/systemtest/audio_function/audio_server/include/audio_server_function_test.h b/audio/test/systemtest/audio_function/audio_server/include/audio_server_function_test.h new file mode 100755 index 0000000000000000000000000000000000000000..71afac6ebbc2663bc556594599667a29b5788c3c --- /dev/null +++ b/audio/test/systemtest/audio_function/audio_server/include/audio_server_function_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_SERVER_FUNCTION_TEST_H +#define AUDIO_SERVER_FUNCTION_TEST_H + +#endif 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 new file mode 100755 index 0000000000000000000000000000000000000000..cf5ad83d7b3b99108cb96fbf1fc47a525684a592 --- /dev/null +++ b/audio/test/systemtest/audio_function/audio_server/src/audio_server_function_test.cpp @@ -0,0 +1,1572 @@ +/* + * 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_hdi_common.h" +#include "audio_server_function_test.h" + +using namespace std; +using namespace testing::ext; +using namespace HMOS::Audio; + +namespace { +const string AUDIO_FILE = "//bin/14031.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 uint32_t CHANNELCOUNTEXOECT = 2; +const uint32_t SAMPLERATEEXOECT = 32000; + +class AudioServerFunctionTest : public testing::Test { +public: + static void SetUpTestCase(void); + 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); + uint32_t FrameSizeExpect(const struct AudioSampleAttributes attrs); +}; + +using THREAD_FUNC = void *(*)(void *); + +void AudioServerFunctionTest::SetUpTestCase(void) {} + +void AudioServerFunctionTest::TearDownTestCase(void) {} + +void AudioServerFunctionTest::SetUp(void) +{ + char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; + handleSo = dlopen(resolvedPath, RTLD_LAZY); + if (handleSo == nullptr) { + return; + } + GetAudioManager = (struct AudioManager* (*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); + if (GetAudioManager == nullptr) { + return; + } +} + +void AudioServerFunctionTest::TearDown(void) +{ + 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; +}; + +int32_t AudioServerFunctionTest::GetLoadAdapter(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(); + } + 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 (realpath(audiopara.path, absPath) == nullptr) { + 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; +} + +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); + if (ret < 0) { + return HDF_FAILURE; + } + ret = InitDevDesc(devDesc, (&audiopara.audioPort)->portId, audiopara.pins); + if (ret < 0) { + return HDF_FAILURE; + } + 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) { + return HDF_FAILURE; + } + + FILE *file = fopen(audiopara.path, "wb+"); + if (file == nullptr) { + audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); + return HDF_FAILURE; + } + ret = StartRecord(audiopara.capture, file, audiopara.fileSize); + if (ret < 0) { + 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); + return sizeExpect; +} + +/** +* @tc.name Playing an audio file +* @tc.number SUB_Audio_Function_Render_Test_0001 +* @tc.desc test StartRender interface,The audio file is played successfully. +* @tc.author: wangkang +*/ +HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0001, TestSize.Level1) +{ + int32_t ret = -1; + 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); + 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 = (int32_t)result; + EXPECT_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 Set audio file volume +* @tc.number SUB_Audio_Function_Render_Test_0002 +* @tc.desc test Render function,set volume when the audio file is playing. +* @tc.author: wangkang +*/ +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, + .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); + ret = audiopara.render->volume.SetMute(audiopara.render, muteFalse); + EXPECT_EQ(HDF_SUCCESS, ret); + sleep(3); + 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]); + 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 = (int32_t)result; + EXPECT_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 Mute audio files +* @tc.number SUB_Audio_Function_Render_Test_0003 +* @tc.desc test Render function,set mute when the audio file is playing. +* @tc.author: wangkang +*/ +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, + .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); + ret = audiopara.render->volume.SetVolume(audiopara.render, volume); + 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); + 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); + + void *result = nullptr; + pthread_join(tids, &result); + ret = (int32_t)result; + EXPECT_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 Pause ¡¢Resume and Stop audio file +* @tc.number SUB_Audio_Function_Render_Test_0004 +* @tc.desc test Render function,call pause,resume and stop interface when the audio file is playing. +* @tc.author: wangkang +*/ +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, + .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); + ret = audiopara.render->control.Pause((AudioHandle)(audiopara.render)); + EXPECT_EQ(HDF_SUCCESS, ret); + sleep(3); + ret = audiopara.render->control.Resume((AudioHandle)(audiopara.render)); + EXPECT_EQ(HDF_SUCCESS, ret); + + void *result = nullptr; + pthread_join(tids, &result); + ret = (int32_t)result; + EXPECT_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 audio gainthreshold and set gain value +* @tc.number SUB_Audio_Function_Render_Test_0005 +* @tc.desc test Render function,Call interface GetGainThreshold,SetGain and GetGain when playing. +* @tc.author: wangkang +*/ +HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0005, TestSize.Level1) +{ + int32_t ret = -1; + 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); + 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 = audiopara.render->volume.GetGainThreshold(audiopara.render, &gainMin, &gainMax); + EXPECT_EQ(HDF_SUCCESS, ret); + + 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); + 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 = (int32_t)result; + EXPECT_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 set volume after the audio file is Paused and set mute after the audio file is resumed +* @tc.number SUB_Audio_Function_Render_Test_0006 +* @tc.desc test Render function,set volume after pause and set mute after resume during playing. +* @tc.author: tiansuli +*/ +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, + .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); + ret = audiopara.render->control.Pause((AudioHandle)(audiopara.render)); + EXPECT_EQ(HDF_SUCCESS, ret); + sleep(3); + 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->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); + void *result = nullptr; + pthread_join(tids, &result); + ret = (int32_t)result; + EXPECT_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 set mute after the audio file is Paused and set volume after the audio file is resumed +* @tc.number SUB_Audio_Function_Render_Test_0007 +* @tc.desc test Render function,set mute after pause and set volume after resume during playing. +* @tc.author: tiansuli +*/ +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, + .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); + ret = audiopara.render->control.Pause((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); + sleep(3); + ret = audiopara.render->control.Resume((AudioHandle)(audiopara.render)); + EXPECT_EQ(HDF_SUCCESS, ret); + sleep(3); + ret = audiopara.render->volume.SetVolume(audiopara.render, volumeMax); + EXPECT_EQ(HDF_SUCCESS, ret); + + void *result = nullptr; + pthread_join(tids, &result); + ret = (int32_t)result; + EXPECT_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 Current ChannelId during playing. +* @tc.number SUB_Audio_Function_Render_Test_0008 +* @tc.desc test StartRender interface,The audio file is played out normally and Get Current ChannelId as expected. +* @tc.author: zhouyongxiao +*/ +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, + .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); + ret = audiopara.render->SetRenderSpeed(audiopara.render, speed); + EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); + ret = audiopara.render->GetRenderSpeed(audiopara.render, &speed); + EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); + ret = audiopara.render->attr.GetCurrentChannelId(audiopara.render, &channelId); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(channelId, channelIdValue); + + void *result = nullptr; + pthread_join(tids, &result); + ret = (int32_t)result; + EXPECT_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 Size during playing +* @tc.number SUB_Audio_Function_Render_Test_0009 +* @tc.desc test StartRender interface,The audio file is played out normally and Get Frame Sizeas expected. +* @tc.author: zhouyongxiao +*/ +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, + .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); + ret = audiopara.render->attr.GetFrameSize(audiopara.render, &size); + EXPECT_EQ(HDF_SUCCESS, ret); + sizeExpect = FrameSizeExpect(audiopara.attrs); + EXPECT_EQ(size, sizeExpect); + + void *result = nullptr; + pthread_join(tids, &result); + ret = (int32_t)result; + EXPECT_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 during playing +* @tc.number SUB_Audio_Function_Render_Test_0010 +* @tc.desc test StartRender interface,The audio file is played out normally and Get Frame Count as expected. +* @tc.author: zhouyongxiao +*/ +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, + .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); + 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 = (int32_t)result; + EXPECT_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 +* @tc.number SUB_Audio_Function_Render_Test_0011 +* @tc.desc test render functio by Get render position when playing audio file. +* @tc.author: wangkang +*/ +HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0011, 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 = 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(3); + 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; + EXPECT_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 Check Scene Capability during playing +* @tc.number SUB_Audio_Function_Render_Test_0012 +* @tc.desc test StartRender interface,The audio file is played out normally and Check Scene Capability as expected. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Render_Test_0012, TestSize.Level1) +{ + int32_t ret = -1; + bool supported = false; + struct AudioSceneDescriptor scenes = {}; + struct PrepareAudioPara audiopara = { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.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); + 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); + 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 = (int32_t)result; + EXPECT_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 when audio file playing SetSampleAttributes +* @tc.number SUB_Audio_Function_Render_Test_0013 +* @tc.desc test StartRender interface,After setting SetSampleAttributes, +* the playback will reset SetSampleAttributes. +* @tc.author: wangkang +*/ +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, + .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); + audiopara.attrs.type = AUDIO_IN_MEDIA; + audiopara.attrs.interleaved = false; + 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; + EXPECT_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 Record audio file +* @tc.number SUB_Audio_Function_Capture_Test_0001 +* @tc.desc test capture function, The audio file is recorded successfully. +* @tc.author: liutian +*/ +HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE + }; + + ret = GetLoadAdapter(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)); + EXPECT_EQ(HDF_SUCCESS, ret); + audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); + audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter); +} +/** +* @tc.name Pause,resume and stop when recording. +* @tc.number SUB_Audio_Function_Capture_Test_0002 +* @tc.desc test capture function,Pause,resume and stop when recording. +* @tc.author: liutian +*/ +HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct PrepareAudioPara audiopara = { + .portType = PORT_IN, .adapterName = ADAPTER_NAME3.c_str(), .self = this, .pins = PIN_IN_MIC, + .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE + }; + + ret = GetLoadAdapter(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); + } + sleep(3); + CaptureFrameStatus(0); + sleep(1); + ret = audiopara.capture->control.Pause((AudioHandle)(audiopara.capture)); + EXPECT_EQ(HDF_SUCCESS, ret); + sleep(3); + ret = audiopara.capture->control.Resume((AudioHandle)(audiopara.capture)); + EXPECT_EQ(HDF_SUCCESS, ret); + CaptureFrameStatus(1); + + void *result = nullptr; + pthread_join(tids, &result); + ret = (intptr_t)result; + EXPECT_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 Set volume when recording audio file +* @tc.number SUB_Audio_Function_Capture_Test_0003 +* @tc.desc Test capture function,set volume when recording audio file. +* @tc.author: liutian +*/ +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, + .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE + }; + + ret = GetLoadAdapter(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(3); + ret = audiopara.capture->volume.SetVolume((AudioHandle)(audiopara.capture), val); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.capture->volume.GetVolume((AudioHandle)(audiopara.capture), &getVal); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_FLOAT_EQ(val, getVal); + + void *result = nullptr; + pthread_join(tids, &result); + ret = (intptr_t)result; + EXPECT_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 Set Mute when recording audio file +* @tc.number SUB_Audio_Function_Capture_Test_0004 +* @tc.desc Test capture function, Set mute when recording audio file. +* @tc.author: liutian +*/ +HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0004, TestSize.Level1) +{ + 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, + .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE + }; + + ret = GetLoadAdapter(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(3); + ret = audiopara.capture->volume.SetMute((AudioHandle)(audiopara.capture), mute); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.capture->volume.GetMute((AudioHandle)(audiopara.capture), &isMute); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_TRUE(isMute); + isMute = false; + sleep(3); + ret = audiopara.capture->volume.SetMute((AudioHandle)(audiopara.capture), isMute); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.capture->volume.GetMute((AudioHandle)(audiopara.capture), &isMute); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_FALSE(isMute); + + void *result = nullptr; + pthread_join(tids, &result); + ret = (intptr_t)result; + EXPECT_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 Set Gain when recording audio file +* @tc.number SUB_Audio_Function_Capture_Test_0005 +* @tc.desc Test capture function, Set gain when recording audio file. +* @tc.author: liutian +*/ +HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0005, TestSize.Level1) +{ + 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, + .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE + }; + + ret = GetLoadAdapter(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); + } + + sleep(3); + ret = para.capture->volume.GetGainThreshold(para.capture, &gainMin, &gainMax); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = para.capture->volume.SetGain((AudioHandle)(para.capture), gainMax - 1); + EXPECT_EQ(HDF_SUCCESS, ret); + gainValue = gainMax - 1; + ret = para.capture->volume.GetGain((AudioHandle)(para.capture), &gain); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_FLOAT_EQ(gainValue, gain); + sleep(3); + ret = para.capture->volume.SetGain((AudioHandle)(para.capture), gainMin + 1); + EXPECT_EQ(HDF_SUCCESS, ret); + gainValue = gainMin + 1; + ret = para.capture->volume.GetGain((AudioHandle)(para.capture), &gain); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_FLOAT_EQ(gainValue, gain); + + void *result = nullptr; + pthread_join(tids, &result); + ret = (intptr_t)result; + EXPECT_EQ(HDF_SUCCESS, ret); + 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); +} +/** +* @tc.name Set SampleAttributes during recording. +* @tc.number SUB_Audio_Function_Capture_Test_0006 +* @tc.desc test capture function,the sampleattributes were setted success,and the audio file is recorded successfully. +* @tc.author: liutian +*/ +HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0006, TestSize.Level1) +{ + 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, + .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE + }; + + ret = GetLoadAdapter(audiopara); + ASSERT_EQ(HDF_SUCCESS, ret); + 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); + } + + sleep(3); + CaptureFrameStatus(0); + usleep(300000); + ret = audiopara.capture->attr.SetSampleAttributes(audiopara.capture, &attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + usleep(300000); + CaptureFrameStatus(1); + sleep(3); + ret = audiopara.capture->attr.GetSampleAttributes(audiopara.capture, &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(SAMPLERATEEXOECT, attrsValue.sampleRate); + EXPECT_EQ(CHANNELCOUNTEXOECT, attrsValue.channelCount); + + void *result = nullptr; + pthread_join(tids, &result); + ret = (intptr_t)result; + EXPECT_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 Get CurrentChannel Id during recording. +* @tc.number SUB_Audio_Function_Capture_Test_0007 +* @tc.desc test capture function,the CurrentChannel Id were get success,and the audio file is recorded successfully. +* @tc.author: tiansuli +*/ +HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0007, TestSize.Level1) +{ + 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, + .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE + }; + + ret = GetLoadAdapter(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(3); + 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; + EXPECT_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 Get Frame Size during recording. +* @tc.number SUB_Audio_Function_Capture_Test_0008 +* @tc.desc test capture function, the Frame Size were get success,and the audio file is recorded successfully. +* @tc.author: tiansuli +*/ +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, + .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE + }; + + ret = GetLoadAdapter(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(3); + ret = audiopara.capture->attr.GetFrameSize(audiopara.capture, &size); + EXPECT_EQ(HDF_SUCCESS, ret); + sizeExpect = FrameSizeExpect(audiopara.attrs); + EXPECT_EQ(size, sizeExpect); + + void *result = nullptr; + pthread_join(tids, &result); + ret = (intptr_t)result; + EXPECT_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 Get Frame Count during recording. +* @tc.number SUB_Audio_Function_Capture_Test_0009 +* @tc.desc test capture function, the Frame Count were get success,and the audio file is recorded successfully. +* @tc.author: tiansuli +*/ +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, + .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE + }; + + ret = GetLoadAdapter(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(3); + 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; + EXPECT_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 Get Gain during recording. +* @tc.number SUB_Audio_Function_Capture_Test_0010 +* @tc.desc test capture function, the Gain were get success,and the audio file is recorded successfully. +* @tc.author: tiansuli +*/ +HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0010, TestSize.Level1) +{ + 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, + .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE + }; + + ret = GetLoadAdapter(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(3); + ret = audiopara.capture->volume.GetGainThreshold((AudioHandle)(audiopara.capture), &min, &max); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(min, GAIN_MIN); + EXPECT_EQ(max, GAIN_MAX); + + void *result = nullptr; + pthread_join(tids, &result); + ret = (intptr_t)result; + EXPECT_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 Check Scene Capability during recording. +* @tc.number SUB_Audio_Function_Capture_Test_0011 +* @tc.desc test capture function, the Check Scene Capability success,and the audio file is recorded successfully. +* @tc.author: tiansuli +*/ +HWTEST_F(AudioServerFunctionTest, SUB_Audio_Function_Capture_Test_0011, TestSize.Level1) +{ + 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, + .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE + }; + + ret = GetLoadAdapter(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(3); + 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; + EXPECT_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); + 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; + EXPECT_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); + 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); + } + + void *result = nullptr; + pthread_join(tids, &result); + ret = (intptr_t)result; + EXPECT_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); + 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); + + void *result = nullptr; + pthread_join(tids, &result); + ret = (intptr_t)result; + EXPECT_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(3); + 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; + EXPECT_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); + 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; + EXPECT_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); + 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; + EXPECT_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); +} +} \ 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 new file mode 100755 index 0000000000000000000000000000000000000000..7c9b7059ce71b633810a393aeacee35a829a86a2 --- /dev/null +++ b/audio/test/systemtest/common/adm_common/include/audio_adm_common.h @@ -0,0 +1,178 @@ +/** + * 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 Defines audio ADM test-related APIs, including data types and functions for writting data +to buffer + * + * @since 1.0 + * @version 1.0 + */ + +/** + * @file audio_adm_common.h + * + * @brief Declares APIs for operations related to the audio ADM testing. + * + * @since 1.0 + * @version 1.0 + */ + +#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" + +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, + AUDIO_DRV_PCM_IOCTRL_RENDER_PREPARE, + AUDIO_DRV_PCM_IOCTRL_CAPTURE_PREPARE, + AUDIO_DRV_PCM_IOCTRL_WRITE, + AUDIO_DRV_PCM_IOCTRL_READ, + AUDIO_DRV_PCM_IOCTRL_RENDER_START, + AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, + AUDIO_DRV_PCM_IOCTRL_CAPTURE_START, + AUDIO_DRV_PCM_IOCTRL_CAPTURE_STOP, + AUDIO_DRV_PCM_IOCTRL_RENDER_PAUSE, + AUDIO_DRV_PCM_IOCTRL_CAPTURE_PAUSE, + AUDIO_DRV_PCM_IOCTRL_RENDER_RESUME, + AUDIO_DRV_PCM_IOCTRL_CAPTURE_RESUME, + AUDIO_DRV_PCM_IOCTRL_BUTT, +}; + +struct AudioPcmHwParams { + enum AudioStreamType streamType; + uint32_t channels; + uint32_t rate; + uint32_t periodSize; + uint32_t periodCount; + enum AudioFormat format; + const char *cardServiceName; + uint32_t period; + uint32_t frameSize; + bool isBigEndian; + bool isSignedData; + uint32_t startThreshold; + uint32_t stopThreshold; + 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); + +uint32_t FormatToBits(enum AudioFormat format); + +uint32_t PcmBytesToFrames(const struct AudioFrameRenderMode& frameRenderMode, uint64_t bytes); + +int32_t WriteFrameToSBuf(struct HdfSBuf *&sBufT, char *buf, unsigned long bufsize, + unsigned long frameSize, const std::string path); + +int32_t ObtainBuf(struct HdfSBuf *&writeBuf, struct HdfSBuf *&readBuf, struct HdfSBuf *&readReply); +} +} +#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 new file mode 100755 index 0000000000000000000000000000000000000000..bfd88c7b6165d685072c5b97b443d92e2513d3f3 --- /dev/null +++ b/audio/test/systemtest/common/adm_common/src/audio_adm_common.cpp @@ -0,0 +1,303 @@ +/* + * 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 Defines audio ADM test-related APIs, including data types and functions for writting data +to buffer. + * + * @since 1.0 + * @version 1.0 + */ + +/** + * @file audio_adm_common.h + * + * @brief Declares APIs for operations related to the audio ADM testing. + * + * @since 1.0 + * @version 1.0 + */ + +#include "audio_adm_common.h" + +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) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, hwParams.streamType)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, hwParams.channels)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, hwParams.rate)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, hwParams.periodSize)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, hwParams.periodCount)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, (uint32_t)(hwParams.format))) { + return HDF_FAILURE; + } + if (!HdfSbufWriteString(sBuf, hwParams.cardServiceName)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, hwParams.isBigEndian)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, hwParams.isSignedData)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, hwParams.startThreshold)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, hwParams.stopThreshold)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, hwParams.silenceThreshold)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, hwParams.period)) { + return HDF_FAILURE; + } + if (!HdfSbufWriteUint32(sBuf, hwParams.frameSize)) { + return HDF_FAILURE; + } + 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 ret = -1; + int readSize = 0; + int bufferSize = 0; + int remainingDataSize = 0; + struct AudioSampleAttributes attrs = {}; + struct AudioHeadInfo headInfo = {}; + ret = InitAttrs(attrs); + if (ret < 0) { + return HDF_FAILURE; + } + char absPath[PATH_MAX] = {0}; + if (realpath(path.c_str(), absPath) == nullptr) { + 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; + } + bufferSize = PcmFramesToBytes(attrs); + frame = (char *)calloc(1, bufferSize); + if (frame == nullptr) { + fclose(file); + return HDF_FAILURE; + } + remainingDataSize = headInfo.dataSize; + readSize = (remainingDataSize) > (bufferSize) ? (bufferSize) : (remainingDataSize); + numRead = fread(frame, 1, readSize, file); + if (numRead < 0) { + fclose(file); + return HDF_FAILURE; + } + frameSize = numRead / (attrs.channelCount * (FormatToBits(attrs.format) >> Move_Right)); + 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 ret = -1; + sBufT = HdfSBufObtainDefaultSize(); + if (sBufT == NULL) { + return HDF_FAILURE; + } + + ret = AdmRenderFramePrepare(path, buf, bufsize, frameSize); + if (ret < 0) { + return HDF_FAILURE; + } + + if (!HdfSbufWriteUint32(sBufT, (uint32_t)(frameSize))) { + return HDF_FAILURE; + } + if (!HdfSbufWriteBuffer(sBufT, buf, bufsize)) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t ObtainBuf(struct HdfSBuf *&writeBuf, struct HdfSBuf *&readBuf, struct HdfSBuf *&readReply) +{ + writeBuf = HdfSBufObtainDefaultSize(); + if (writeBuf == nullptr) { + return HDF_FAILURE; + } + readBuf = HdfSBufObtainDefaultSize(); + if (readBuf == nullptr) { + HdfSBufRecycle(writeBuf); + return HDF_FAILURE; + } + readReply = HdfSBufObtainDefaultSize(); + if (readReply == nullptr) { + HdfSBufRecycle(writeBuf); + HdfSBufRecycle(readBuf); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} +} +} \ No newline at end of file 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 new file mode 100755 index 0000000000000000000000000000000000000000..8ecdd2f35c470a2b2bbf90e695a77ef43bba1ca0 --- /dev/null +++ b/audio/test/systemtest/common/hdi_common/include/audio_hdi_common.h @@ -0,0 +1,140 @@ +/** + * 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 Defines audio-related APIs, including custom data types and functions for loading drivers, + * accessing a driver adapter, and rendering and capturing audios. + * + * @since 1.0 + * @version 1.0 + */ + +/** + * @file audio_adapter.h + * + * @brief Declares APIs for operations related to the audio adapter. + * + * @since 1.0 + * @version 1.0 + */ + +#ifndef AUDIO_HDI_COMMON_H +#define AUDIO_HDI_COMMON_H + +#include +#include "audio_adapter.h" +#include "audio_internal.h" +#include "audio_types.h" +#include "hdf_io_service_if.h" +#include "hdf_sbuf.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 INT_32_MAX = 0x7fffffff; +const uint32_t INDEX_END = 555; +const int MOVE_LEFT_NUM = 8; +const int CHANNELCOUNT = 2; +const int SAMPLERATE = 48000; +const int DEEP_BUFFER_RENDER_PERIOD_SIZE = 4096; +const float GAIN_MIN = 0; +const float GAIN_MAX = 15; +const uint64_t INITIAL_VALUE = 0; +const int BUFFER_LENTH = 1024 * 16; +const uint64_t MEGABYTE = 1024; +const int FRAME_SIZE = 1024; +const std::string HDF_CONTROL_SERVICE = "hdf_audio_control"; +const int AUDIODRV_CTL_ELEM_IFACE_DAC = 0; /* virtual dac device */ +const int AUDIODRV_CTL_ELEM_IFACE_PGA = 5; +enum ControlDispMethodCmd { + AUDIODRV_CTRL_IOCTRL_ELEM_INFO, + AUDIODRV_CTRL_IOCTRL_ELEM_READ, + AUDIODRV_CTRL_IOCTRL_ELEM_WRITE, + AUDIODRV_CTRL_IOCTRL_ELEM_BUTT, +}; + +enum AudioPCMBit { + PCM_8_BIT = 8, + PCM_16_BIT = 16, + PCM_24_BIT = 24, + PCM_32_BIT = 32, +}; + +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 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 InitDevDesc(struct AudioDeviceDescriptor& devDesc, const uint32_t portId, enum AudioPortPin pins); + +int32_t SwitchAdapter(struct AudioAdapterDescriptor *descs, const std::string adapterNameCase, + enum AudioPortDirection portFlag, struct AudioPort& audioPort, int size); + +uint32_t PcmFormatToBits(enum AudioFormat format); + +uint32_t PcmFramesToBytes(const struct AudioSampleAttributes attrs); + +int32_t WavHeadAnalysis(struct AudioHeadInfo& wavHeadInfo, FILE *file, struct AudioSampleAttributes& attrs); + +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); + +void CaptureFrameStatus(int status); + +int32_t StartRecord(struct AudioCapture *capture, FILE *file, uint64_t filesize); + +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); +} +} +#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 new file mode 100755 index 0000000000000000000000000000000000000000..00f2025653be7fdc5eeb4389f617fe5bb9ca425e --- /dev/null +++ b/audio/test/systemtest/common/hdi_common/src/audio_hdi_common.cpp @@ -0,0 +1,488 @@ +/** + * 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 Defines audio-related APIs, including custom data types and functions for loading drivers, + * accessing a driver adapter, and rendering and capturing audios. + * + * @since 1.0 + * @version 1.0 + */ + +/** + * @file audio_adapter.h + * + * @brief Declares APIs for operations related to the audio adapter. + * + * @since 1.0 + * @version 1.0 + */ + +#include "audio_hdi_common.h" + +using namespace std; + +static int turnOff = 0; +static int g_captureState = 1; +namespace HMOS { +namespace Audio { +int32_t InitAttrs(struct AudioSampleAttributes& attrs) +{ + attrs.format = AUDIO_FORMAT_PCM_16_BIT; + attrs.channelCount = CHANNELCOUNT; + attrs.sampleRate = SAMPLERATE; + attrs.interleaved = 0; + attrs.type = AUDIO_IN_MEDIA; + attrs.period = DEEP_BUFFER_RENDER_PERIOD_SIZE; + attrs.frameSize = PCM_16_BIT * CHANNELCOUNT / MOVE_LEFT_NUM; + attrs.isBigEndian = false; + 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; + 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; +} + +int32_t InitDevDesc(struct AudioDeviceDescriptor& devDesc, const uint32_t portId, enum AudioPortPin pins) +{ + devDesc.portId = portId; + devDesc.pins = pins; + devDesc.desc = nullptr; + return HDF_SUCCESS; +} + +int32_t SwitchAdapter(struct AudioAdapterDescriptor *descs, const std::string adapterNameCase, + enum AudioPortDirection portFlag, struct AudioPort& audioPort, int size) +{ + if (descs == nullptr) { + return HDF_FAILURE; + } + int count = size; + for (int index = 0; index < count; index++) { + struct AudioAdapterDescriptor *desc = &descs[index]; + if (strcmp(desc->adapterName, adapterNameCase.c_str())) { + continue; + } + for (uint32_t port = 0; ((desc != nullptr) && (port < desc->portNum)); port++) { + if (desc->ports[port].dir == portFlag) { + audioPort = desc->ports[port]; + return index; + } + } + } + return HDF_FAILURE; +} + +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; + }; +} + +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); + return ret; +} + +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; +} + +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; + uint64_t replyBytes = 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; + } + remainingDataSize = wavHeadInfo.dataSize; + bufferSize = PcmFramesToBytes(attrs); + if (bufferSize <= 0) { + return HDF_FAILURE; + } + char *frame = nullptr; + frame = (char *)calloc(1, bufferSize); + if (frame == nullptr) { + return HDF_FAILURE; + } + signal(SIGINT, StreamClose); + do { + readSize = (remainingDataSize) > (bufferSize) ? (bufferSize) : (remainingDataSize); + numRead = fread(frame, 1, readSize, file); + if (numRead > 0) { + ret = render->RenderFrame(render, frame, numRead, &replyBytes); + if (ret < 0) { + if (ret == -1) { + continue; + } + free(frame); + return HDF_FAILURE; + } + remainingDataSize -= numRead; + } + } while (!turnOff && numRead > 0 && remainingDataSize > 0); + free(frame); + return HDF_SUCCESS; +} + +int32_t FrameStartCapture(struct AudioCapture *capture, FILE *file, const struct AudioSampleAttributes attrs) +{ + int32_t ret = 0; + int bufferSize = 0; + uint64_t replyBytes = 0; + uint64_t requestBytes = 0; + if (capture == nullptr || capture->control.Start == nullptr || capture->CaptureFrame == nullptr) { + return HDF_FAILURE; + } + ret = capture->control.Start((AudioHandle)capture); + if (ret < 0) { + return HDF_FAILURE; + } + bufferSize = PcmFramesToBytes(attrs); + char *frame = nullptr; + frame = (char *)calloc(1, bufferSize); + if (frame == nullptr) { + return HDF_FAILURE; + } + requestBytes = bufferSize; + ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes); + if (ret < 0) { + free(frame); + return HDF_FAILURE; + } + fwrite(frame, requestBytes, 1, file); + free(frame); + return HDF_SUCCESS; +} + +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; + struct AudioSampleAttributes attrs = {}; + struct AudioHeadInfo headInfo = {}; + ret = InitAttrs(attrs); + if (ret < 0) { + return HDF_FAILURE; + } + char absPath[PATH_MAX] = {0}; + if (realpath(path.c_str(), absPath) == nullptr) { + 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; + } + bufferSize = PcmFramesToBytes(attrs); + if (bufferSize <= 0) { + fclose(file); + return HDF_FAILURE; + } + frame = (char *)calloc(1, bufferSize); + if (frame == nullptr) { + fclose(file); + return HDF_FAILURE; + } + remainingDataSize = headInfo.dataSize; + readSize = (remainingDataSize) > (bufferSize) ? (bufferSize) : (remainingDataSize); + numRead = fread(frame, 1, readSize, file); + if (numRead < 0) { + fclose(file); + return HDF_FAILURE; + } + fclose(file); + return HDF_SUCCESS; +} + +void CaptureFrameStatus(int status) +{ + g_captureState = status; + return; +} + +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; + if (capture == nullptr || capture->control.Start == nullptr || + capture->CaptureFrame == nullptr ||file == nullptr) { + return HDF_FAILURE; + } + ret = capture->control.Start((AudioHandle)capture); + if (ret < 0) { + return HDF_FAILURE; + } + char *frame = (char *)calloc(1, bufferSize); + if (frame == nullptr) { + return HDF_FAILURE; + } + do { + if (g_captureState) { + ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes); + if (ret < 0) { + if (ret == -1) { + continue; + } + free(frame); + frame = nullptr; + return HDF_FAILURE; + } + uint32_t replyByte = static_cast(replyBytes); + ret = fwrite(frame, replyByte, 1, file); + if (ret < 0) { + free(frame); + frame = nullptr; + return HDF_FAILURE; + } + totalSize += replyBytes; + } else { + totalSize += 0; + } + } while (totalSize <= filesize * MEGABYTE); + free(frame); + frame = nullptr; + return HDF_SUCCESS; +} + +int32_t WriteIdToBuf(struct HdfSBuf *sBuf, struct AudioCtlElemId id) +{ + 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 ChangeRegisterStatus(struct AudioCtlElemValue elemValue) +{ + struct HdfIoService *service = nullptr; + struct HdfSBuf *sBuf = nullptr; + struct HdfSBuf *reply = nullptr; + int32_t ret = -1; + service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); + if (service == nullptr) { + return HDF_FAILURE; + } + sBuf = HdfSBufObtainDefaultSize(); + if (sBuf == nullptr) { + HdfIoServiceRecycle(service); + return HDF_FAILURE; + } + ret = WriteEleValueToBuf(sBuf, elemValue); + if (ret < 0) { + HdfSBufRecycle(sBuf); + HdfIoServiceRecycle(service); + return HDF_FAILURE; + } + ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTRL_IOCTRL_ELEM_WRITE, sBuf, reply); + if (ret < 0) { + HdfSBufRecycle(sBuf); + HdfIoServiceRecycle(service); + return HDF_FAILURE; + } + HdfSBufRecycle(sBuf); + HdfIoServiceRecycle(service); + return HDF_SUCCESS; +} + +int32_t QueryRegisterStatus(struct AudioCtlElemId id, struct AudioCtlElemValue &elemValue) +{ + struct HdfIoService *service = nullptr; + struct HdfSBuf *sBuf = nullptr; + struct HdfSBuf *reply = nullptr; + int32_t ret = -1; + service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str()); + if (service == nullptr) { + return HDF_FAILURE; + } + sBuf = HdfSBufObtainDefaultSize(); + if (sBuf == nullptr) { + HdfIoServiceRecycle(service); + return HDF_FAILURE; + } + ret = WriteIdToBuf(sBuf, id); + if (ret < 0) { + HdfSBufRecycle(sBuf); + HdfIoServiceRecycle(service); + return HDF_FAILURE; + } + reply = HdfSBufObtainDefaultSize(); + if (reply == nullptr) { + HdfSBufRecycle(sBuf); + HdfIoServiceRecycle(service); + return HDF_FAILURE; + } + ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTRL_IOCTRL_ELEM_READ, sBuf, reply); + if (ret < 0) { + HdfSBufRecycle(sBuf); + HdfSBufRecycle(reply); + HdfIoServiceRecycle(service); + return HDF_FAILURE; + } + if (!HdfSbufReadInt32(reply, &elemValue.value[0])) { + HdfSBufRecycle(sBuf); + HdfSBufRecycle(reply); + HdfIoServiceRecycle(service); + return HDF_FAILURE; + } + HdfSBufRecycle(sBuf); + HdfSBufRecycle(reply); + HdfIoServiceRecycle(service); + return HDF_SUCCESS; +} + +int32_t PowerOff(struct AudioCtlElemValue firstElemValue, struct AudioCtlElemValue secondElemValue) +{ + int32_t ret = -1; + ret = ChangeRegisterStatus(firstElemValue); + if (ret < 0) { + return HDF_FAILURE; + } + ret = ChangeRegisterStatus(secondElemValue); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t CheckRegisterStatus(const struct AudioCtlElemId firstId, const struct AudioCtlElemId secondId, + const int firstStatus, const int secondStatus) +{ + int32_t ret = -1; + struct AudioCtlElemValue elemValue[2] = {{}, {}}; + ret = QueryRegisterStatus(firstId, elemValue[0]); + if (ret < 0) { + return HDF_FAILURE; + } + + if (firstStatus != elemValue[0].value[0]) { + return HDF_FAILURE; + } + ret = QueryRegisterStatus(secondId, elemValue[1]); + if (ret < 0) { + return HDF_FAILURE; + } + + if (secondStatus != elemValue[1].value[0]) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} +} +} \ No newline at end of file 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 new file mode 100755 index 0000000000000000000000000000000000000000..7753b51790bda44441e065f34fa83c1273a49248 --- /dev/null +++ b/audio/test/systemtest/common/lib_common/include/audio_lib_common.h @@ -0,0 +1,103 @@ +/** + * 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-related APIs, including custom data types and functions for loading drivers, + * accessing a driver ADM interface lib. + * + * @since 1.0 + * @version 1.0 + */ + +/** + * @file audio_lib_common.h + * + * @brief Declares APIs for operations related to the audio ADM interface lib. + * + * @since 1.0 + * @version 1.0 + */ + +#ifndef AUDIO_LIB_COMMON_H +#define AUDIO_LIB_COMMON_H + +#include +#include "audio_internal.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; +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); + +int32_t InitHwRenderMode(struct AudioHwRenderMode& renderMode); + +int32_t InitHwCaptureMode(struct AudioHwCaptureMode& captureMode); + +int32_t WavHeadAnalysis(struct AudioHeadInfo& wavHeadInfo, FILE *file, struct AudioSampleAttributes& attrs); +} +} +#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 new file mode 100755 index 0000000000000000000000000000000000000000..984afe58ddf503917118f4acfe344ea268ecbe9e --- /dev/null +++ b/audio/test/systemtest/common/lib_common/src/audio_lib_common.cpp @@ -0,0 +1,170 @@ +/* + * 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-related APIs, including custom data types and functions for loading drivers, + * accessing a driver ADM interface lib. + * + * @since 1.0 + * @version 1.0 + */ + +/** + * @file audio_lib_common.h + * + * @brief Declares APIs for operations related to the audio ADM interface lib. + * + * @since 1.0 + * @version 1.0 + */ + +#include "audio_lib_common.h" + +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); + frameRenderMode.frames = AUDIO_FORMAT_PCM_16_BIT; + frameRenderMode.mode = AUDIO_CHANNEL_BOTH_RIGHT; + frameRenderMode.periodSize = G_PERIODSIZE; + frameRenderMode.periodCount = G_PERIODCOUNT; + frameRenderMode.byteRate = G_BYTERATE; + frameRenderMode.bufferFrameSize = G_BUFFERFRAMESIZE; + frameRenderMode.bufferSize = G_BUFFERSIZE1; + frameRenderMode.buffer = NULL; + frameRenderMode.silenceThreshold = frameRenderMode.periodSize * frameRenderMode.periodCount; + frameRenderMode.silenceSize = G_SILENCETHRESHOLE; + frameRenderMode.startThreshold = frameRenderMode.periodSize; + frameRenderMode.stopThreshold = frameRenderMode.periodSize * frameRenderMode.periodCount; + return HDF_SUCCESS; +} + +int32_t InitHwCaptureFramepara(struct AudioFrameCaptureMode& frameCaptureMode) +{ + InitAttrs(frameCaptureMode.attrs); + frameCaptureMode.mode = AUDIO_CHANNEL_BOTH_RIGHT; + frameCaptureMode.byteRate = G_BYTERATE; + frameCaptureMode.periodSize = G_PERIODSIZE; + frameCaptureMode.periodCount = G_PERIODCOUNT; + frameCaptureMode.startThreshold = frameCaptureMode.periodSize; + frameCaptureMode.stopThreshold = frameCaptureMode.periodSize * frameCaptureMode.periodCount; + frameCaptureMode.silenceThreshold = frameCaptureMode.periodSize * frameCaptureMode.periodCount; + frameCaptureMode.silenceSize = G_SILENCETHRESHOLE; + frameCaptureMode.buffer = NULL; + frameCaptureMode.bufferFrameSize = G_BUFFERFRAMESIZE; + frameCaptureMode.bufferSize = G_BUFFERSIZE1; + return HDF_SUCCESS; +} + +int32_t InitHwRenderMode(struct AudioHwRenderMode& renderMode) +{ + renderMode.hwInfo.card = AUDIO_SERVICE_IN; + renderMode.hwInfo.portDescript.dir = PORT_OUT; + renderMode.hwInfo.portDescript.portId = G_PORTID; + renderMode.hwInfo.portDescript.portName = "AOP"; + renderMode.hwInfo.deviceDescript.portId = G_PORTID; + renderMode.hwInfo.deviceDescript.pins = PIN_OUT_SPEAKER; + renderMode.hwInfo.deviceDescript.desc = nullptr; + return HDF_SUCCESS; +} + +int32_t InitHwCaptureMode(struct AudioHwCaptureMode& captureMode) +{ + captureMode.hwInfo.card = AUDIO_SERVICE_IN; + captureMode.hwInfo.portDescript.dir = PORT_IN; + captureMode.hwInfo.portDescript.portId = 0; + captureMode.hwInfo.portDescript.portName = "AIP"; + captureMode.hwInfo.deviceDescript.portId = 0; + captureMode.hwInfo.deviceDescript.pins = PIN_IN_MIC; + captureMode.hwInfo.deviceDescript.desc = nullptr; + 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; +} + +int32_t WavHeadAnalysis(struct AudioHeadInfo& wavHeadInfo, FILE *file, struct AudioSampleAttributes& attrs) +{ + int32_t 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; +} +} +} \ No newline at end of file diff --git a/audio/test/systemtest/hdi/BUILD.gn b/audio/test/systemtest/hdi/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..5c0246eb565c5487c729d12fadfcf0a5500469c5 --- /dev/null +++ b/audio/test/systemtest/hdi/BUILD.gn @@ -0,0 +1,36 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//drivers/adapter/uhdf2/uhdf.gni") + +###########################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", + ] +} diff --git a/audio/test/systemtest/hdi/adapter/BUILD.gn b/audio/test/systemtest/hdi/adapter/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..f769f8416a020f4e76ab13b0272625e399ad5615 --- /dev/null +++ b/audio/test/systemtest/hdi/adapter/BUILD.gn @@ -0,0 +1,56 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//drivers/adapter/uhdf2/uhdf.gni") + +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/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", + ] +} +###########################end########################### \ No newline at end of file diff --git a/audio/test/systemtest/hdi/adapter/include/audio_hdiadapter_test.h b/audio/test/systemtest/hdi/adapter/include/audio_hdiadapter_test.h new file mode 100755 index 0000000000000000000000000000000000000000..a43a4cff1e2e79c1beead725f3116963dedacf13 --- /dev/null +++ b/audio/test/systemtest/hdi/adapter/include/audio_hdiadapter_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_HDIADAPTER_TEST_H +#define AUDIO_HDIADAPTER_TEST_H + +#endif diff --git a/audio/test/systemtest/hdi/adapter/src/audio_hdiadapter_test.cpp b/audio/test/systemtest/hdi/adapter/src/audio_hdiadapter_test.cpp new file mode 100755 index 0000000000000000000000000000000000000000..e7663fff675a611b3c7ab3b4b21f41869f884e5c --- /dev/null +++ b/audio/test/systemtest/hdi/adapter/src/audio_hdiadapter_test.cpp @@ -0,0 +1,874 @@ +/* + * 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-related APIs, including custom data types and functions for loading drivers, + * accessing a driver adapter. + * + * @since 1.0 + * @version 1.0 + */ + +/** + * @file audio_hdi_common.h + * + * @brief Declares APIs for operations related to the audio adapter. + * + * @since 1.0 + * @version 1.0 + */ + +#include "audio_hdi_common.h" +#include "audio_hdiadapter_test.h" + +using namespace std; +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; + +class AudioHdiAdapterTest : public testing::Test { +public: + static void SetUpTestCase(void); + 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; +}; + +void AudioHdiAdapterTest::SetUpTestCase(void) {} + +void AudioHdiAdapterTest::TearDownTestCase(void) {} + +void AudioHdiAdapterTest::SetUp(void) +{ + char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; + handleSo = dlopen(resolvedPath, RTLD_LAZY); + if (handleSo == nullptr) { + return; + } + GetAudioManager = (struct AudioManager *(*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); + if (GetAudioManager == nullptr) { + return; + } +} + +void AudioHdiAdapterTest::TearDown(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; + } + 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; +} + +/** +* @tc.name Test GetAllAdapters API via legal input +* @tc.number SUB_Audio_HDI_GetAllAdapters_0001 +* @tc.desc test GetAllAdapters interface，Returns 0 if the list is obtained successfully +* @tc.author: liweiming +*/ +HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_GetAllAdapters_0001, TestSize.Level1) +{ + int32_t ret = -1; + int size = 0; + struct AudioAdapterDescriptor *descs = nullptr; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager *manager = GetAudioManager(); + ASSERT_NE(nullptr, manager); + ret = manager->GetAllAdapters(manager, &descs, &size); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_ADAPTER_MAX_NUM, size); +} + +/** +* @tc.name Test GetAllAdapters API via setting the incoming parameter manager is nullptr +* @tc.number SUB_Audio_HDI_GetAllAdapters_0002 +* @tc.desc test GetAllAdapters interface，Returns -1 if the incoming parameter manager is nullptr +* @tc.author: liweiming +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager *manager = GetAudioManager(); + ASSERT_NE(nullptr, manager); + ret = manager->GetAllAdapters(manager1, &descs, &size); + EXPECT_EQ(HDF_FAILURE, ret); +} + +/** +* @tc.name Test GetAllAdapters API via setting the incoming parameter descs is nullptr +* @tc.number SUB_Audio_HDI_GetAllAdapters_0003 +* @tc.desc test GetAllAdapters interface，Returns -1 if the incoming parameter descs is nullptr +* @tc.author: liweiming +*/ +HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_GetAllAdapters_0003, TestSize.Level1) +{ + int32_t ret = -1; + int size = 0; + struct AudioAdapterDescriptor **descs = nullptr; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager *manager = GetAudioManager(); + ASSERT_NE(nullptr, manager); + ret = manager->GetAllAdapters(manager, descs, &size); + EXPECT_EQ(HDF_FAILURE, ret); +} + +/** +* @tc.name Test GetAllAdapters API via setting the incoming parameter size is nullptr +* @tc.number SUB_Audio_HDI_GetAllAdapters_0004 +* @tc.desc test GetAllAdapters interface，Returns -1 if the incoming parameter size is nullptr +* @tc.author: liweiming +*/ +HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_GetAllAdapters_0004, TestSize.Level1) +{ + int32_t ret = -1; + int *size = nullptr; + struct AudioAdapterDescriptor *descs = nullptr; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager *manager = GetAudioManager(); + ASSERT_NE(nullptr, manager); + ret = manager->GetAllAdapters(manager, &descs, size); + EXPECT_EQ(HDF_FAILURE, ret); +} + +/** +* @tc.name Test LoadAdapter API via legal input +* @tc.number SUB_Audio_HDI_LoadAdapter_0001 +* @tc.desc test LoadAdapter interface，Returns 0 if the driver is loaded successfully +* @tc.author: liweiming +*/ +HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_LoadAdapter_0001, TestSize.Level1) +{ + int32_t ret = -1; + int size = 0; + struct AudioAdapterDescriptor *descs = nullptr; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager *manager = GetAudioManager(); + ASSERT_NE(nullptr, manager); + ret = manager->GetAllAdapters(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); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = -1; + if (adapter != nullptr) { + if (adapter->InitAllPorts != nullptr && adapter->CreateRender != nullptr && + adapter->DestroyRender != nullptr && adapter->CreateCapture != nullptr && + adapter->DestroyCapture != nullptr && adapter->GetPortCapability != nullptr && + adapter->SetPassthroughMode != nullptr && adapter->GetPassthroughMode != nullptr) { + ret = 0; + } + } + EXPECT_EQ(HDF_SUCCESS, ret); + manager->UnloadAdapter(manager, adapter); +} + +/** +* @tc.name Test LoadAdapter API via changing the adapterName of incoming parameter desc +* @tc.number SUB_Audio_HDI_LoadAdapter_0002 +* @tc.desc test LoadAdapter interface，Returns -1 if the adapterName of incoming parameter desc is not support +* @tc.author: liweiming +*/ +HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_LoadAdapter_0002, TestSize.Level1) +{ + int32_t ret = -1; + int size = 0; + struct AudioAdapterDescriptor *descs = nullptr; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager *manager = GetAudioManager(); + ASSERT_NE(nullptr, manager); + ret = manager->GetAllAdapters(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); + EXPECT_EQ(HDF_FAILURE, ret); + desc->adapterName = "internal"; + ret = manager->LoadAdapter(manager, desc, &adapter); + manager->UnloadAdapter(manager, adapter); +} + +/** +* @tc.name Test LoadAdapter API via setting the adapterName of incoming parameter desc is illegal +* @tc.number SUB_Audio_HDI_LoadAdapter_0003 +* @tc.desc test LoadAdapter interface，Returns -1 if the adapterName of incoming parameter desc is illegal +* @tc.author: liweiming +*/ +HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_LoadAdapter_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = nullptr; + struct AudioAdapterDescriptor desc = { + .adapterName = "illegal", + .portNum = 2, + .ports = nullptr, + }; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager *manager = GetAudioManager(); + ASSERT_NE(nullptr, manager); + ret = manager->LoadAdapter(manager, &desc, &adapter); + EXPECT_EQ(HDF_FAILURE, ret); + manager->UnloadAdapter(manager, adapter); +} + +/** +* @tc.name Test LoadAdapter API via setting the adapterName of incoming parameter manager is nullptr +* @tc.number SUB_Audio_HDI_LoadAdapter_0004 +* @tc.desc test LoadAdapter interface，Returns -1 if the incoming parameter manager is nullptr +* @tc.author: liweiming +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager *manager = GetAudioManager(); + ASSERT_NE(nullptr, manager); + ret = manager->GetAllAdapters(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); + ASSERT_EQ(HDF_FAILURE, ret); + manager->UnloadAdapter(manager, adapter); +} + +/** +* @tc.name Test LoadAdapter API via setting the adapterName of incoming parameter desc is nullptr +* @tc.number SUB_Audio_HDI_LoadAdapter_0005 +* @tc.desc test LoadAdapter interface，Returns -1 if the incoming parameter desc is nullptr +* @tc.author: liweiming +*/ +HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_LoadAdapter_0005, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapterDescriptor *desc = nullptr; + struct AudioAdapter *adapter = nullptr; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager *manager = GetAudioManager(); + ASSERT_NE(nullptr, manager); + ret = manager->LoadAdapter(manager, desc, &adapter); + ASSERT_EQ(HDF_FAILURE, ret); + manager->UnloadAdapter(manager, adapter); +} + +/** +* @tc.name Test LoadAdapter API via setting the adapterName of incoming parameter adapter is nullptr +* @tc.number SUB_Audio_HDI_LoadAdapter_0006 +* @tc.desc test LoadAdapter interface，Returns -1 if the incoming parameter adapter is nullptr +* @tc.author: liweiming +*/ +HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_LoadAdapter_0006, TestSize.Level1) +{ + int32_t ret = -1; + int size = 0; + struct AudioAdapterDescriptor *descs = nullptr; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager *manager = GetAudioManager(); + ASSERT_NE(nullptr, manager); + ret = manager->GetAllAdapters(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); + EXPECT_EQ(HDF_FAILURE, ret); +} + +/** +* @tc.name Test AudioAdapterInitAllPorts API via legal input. +* @tc.number SUB_Audio_HDI_AdapterInitAllPorts_0001 +* @tc.desc Test AudioAdapterInitAllPorts interface, return 0 if the ports is initialize successfully. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterInitAllPorts_0001, 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_NAME2, &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 AudioAdapterInitAllPorts API when loads two adapters. +* @tc.number SUB_Audio_HDI_AdapterInitAllPorts_0002 +* @tc.desc Test AudioAdapterInitAllPorts interface, return 0 if loads two adapters successfully. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterInitAllPorts_0002, TestSize.Level1) +{ + int32_t ret = -1; + int32_t ret2 = -1; + struct AudioPort renderPort = {}; + struct AudioPort renderPortUsb = {}; + struct AudioAdapter *adapter = nullptr; + struct AudioAdapter *adapter1 = nullptr; + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME3, &adapter, renderPort); + ASSERT_EQ(HDF_SUCCESS, ret); + ASSERT_NE(nullptr, adapter); + ret2 = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter1, renderPortUsb); + if (ret2 < 0 || adapter1 == nullptr) { + manager.UnloadAdapter(&manager, adapter); + ASSERT_EQ(HDF_SUCCESS, ret2); + } + ret = adapter->InitAllPorts(adapter); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = adapter->InitAllPorts(adapter1); + EXPECT_EQ(HDF_SUCCESS, ret2); + + manager.UnloadAdapter(&manager, adapter); + manager.UnloadAdapter(&manager, adapter1); +} + +/** +* @tc.name Test AudioAdapterInitAllPorts API when the parameter adapter is empty. +* @tc.number SUB_Audio_HDI_AdapterInitAllPorts_0003 +* @tc.desc Test AudioAdapterInitAllPorts API, return -1 if the parameter adapter is empty. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterInitAllPorts_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioPort audioPort = {}; + struct AudioAdapter *adapter = nullptr; + struct AudioAdapter *adapterNull = nullptr; + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, audioPort); + ASSERT_EQ(HDF_SUCCESS, ret); + ASSERT_NE(nullptr, adapter); + ret = adapter->InitAllPorts(adapterNull); + EXPECT_EQ(HDF_FAILURE, ret); + 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 +* @tc.desc Test AudioAdapterGetPortCapability,return 0 if PortType is PORT_OUT. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPortCapability_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioPort audioPort = {}; + struct AudioAdapter *adapter = {}; + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + struct AudioPortCapability capability = {}; + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, audioPort); + ASSERT_EQ(HDF_SUCCESS, ret); + ASSERT_NE(nullptr, adapter); + ret = adapter->InitAllPorts(adapter); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = adapter->GetPortCapability(adapter, &audioPort, &capability); + if (ret < 0 || capability.formats == nullptr || capability.subPorts == nullptr) { + manager.UnloadAdapter(&manager, adapter); + ASSERT_NE(HDF_SUCCESS, ret); + ASSERT_NE(nullptr, capability.formats); + ASSERT_NE(nullptr, capability.subPorts); + } + if (capability.subPorts->desc == nullptr) { + manager.UnloadAdapter(&manager, adapter); + ASSERT_NE(nullptr, capability.subPorts->desc); + } + EXPECT_EQ(HDF_SUCCESS, ret); + manager.UnloadAdapter(&manager, adapter); +} + +/** +* @tc.name Test AudioAdapterGetPortCapability API when the PortType is PORT_IN. +* @tc.number SUB_Audio_HDI_AdapterGetPortCapability_0002 +* @tc.desc Test AudioAdapterGetPortCapability,return 0 if PortType is PORT_IN. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPortCapability_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioPort audioPort = {}; + struct AudioAdapter *adapter = {}; + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + struct AudioPortCapability capability = {}; + + ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME2, &adapter, audioPort); + ASSERT_EQ(HDF_SUCCESS, ret); + ASSERT_NE(nullptr, adapter); + ret = adapter->InitAllPorts(adapter); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = adapter->GetPortCapability(adapter, &audioPort, &capability); + EXPECT_EQ(HDF_SUCCESS, ret); + + manager.UnloadAdapter(&manager, adapter); +} + +/** +* @tc.name Test AudioAdapterGetPortCapability API when the PortType is PORT_OUT_IN. +* @tc.number SUB_Audio_HDI_AdapterGetPortCapability_0003 +* @tc.desc Test AudioAdapterGetPortCapability,return 0 if PortType is PORT_OUT_IN. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPortCapability_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioPort audioPort = {}; + struct AudioAdapter *adapter = {}; + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + struct AudioPortCapability capability = {}; + + ret = GetLoadAdapter(manager, PORT_OUT_IN, ADAPTER_NAME2, &adapter, audioPort); + ASSERT_EQ(HDF_SUCCESS, ret); + ASSERT_NE(nullptr, adapter); + ret = adapter->InitAllPorts(adapter); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = adapter->GetPortCapability(adapter, &audioPort, &capability); + EXPECT_EQ(HDF_SUCCESS, ret); + manager.UnloadAdapter(&manager, adapter); +} + +/** +* @tc.name Test AudioAdapterGetPortCapability API, when the parameter adapter is empty. +* @tc.number SUB_Audio_HDI_AdapterGetPortCapability_0004 +* @tc.desc Test AudioAdapterGetPortCapability, return -1 if the parameter adapter is empty. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPortCapability_0004, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioPort audioPort = {}; + struct AudioAdapter *adapter = nullptr; + struct AudioAdapter *adapterNull = nullptr; + struct AudioPortCapability capability = {}; + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME3, &adapter, audioPort); + ASSERT_EQ(HDF_SUCCESS, ret); + ASSERT_NE(nullptr, adapter); + ret = adapter->InitAllPorts(adapter); + ret = adapter->GetPortCapability(adapterNull, &audioPort, &capability); + EXPECT_EQ(HDF_FAILURE, ret); + + manager.UnloadAdapter(&manager, adapter); +} + +/** +* @tc.name Test AudioAdapterGetPortCapability API when the audioPort is nullptr or not supported. +* @tc.number SUB_Audio_HDI_AdapterGetPortCapability_0005 +* @tc.desc Test AudioAdapterGetPortCapability, return -1 if the audioPort is nullptr or not supported. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPortCapability_0005, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioPort *audioPortNull = nullptr; + struct AudioAdapter *adapter = nullptr; + struct AudioPortCapability capability = {}; + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + struct AudioPort audioPort = {}; + struct AudioPort audioPortError = { .dir = PORT_OUT, .portId = 9, .portName = "AIP" }; + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME3, &adapter, audioPort); + ASSERT_EQ(HDF_SUCCESS, ret); + ASSERT_NE(nullptr, adapter); + ret = adapter->InitAllPorts(adapter); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = adapter->GetPortCapability(adapter, audioPortNull, &capability); + EXPECT_EQ(HDF_FAILURE, ret); + + ret = adapter->GetPortCapability(adapter, &audioPortError, &capability); + EXPECT_EQ(HDF_FAILURE, ret); + manager.UnloadAdapter(&manager, adapter); +} + +/** +* @tc.name Test AudioAdapterGetPortCapability API when the capability is nullptr. +* @tc.number SUB_Audio_HDI_AdapterGetPortCapability_0006 +* @tc.desc Test AudioAdapterGetPortCapability, return -1 if capability is nullptr. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPortCapability_0006, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioPort audioPort = {}; + struct AudioAdapter *adapter = nullptr; + struct AudioPortCapability *capabilityNull = nullptr; + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME3, &adapter, audioPort); + ASSERT_EQ(HDF_SUCCESS, ret); + ASSERT_NE(nullptr, adapter); + ret = adapter->InitAllPorts(adapter); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = adapter->GetPortCapability(adapter, &audioPort, capabilityNull); + EXPECT_EQ(HDF_FAILURE, ret); + + manager.UnloadAdapter(&manager, adapter); +} + +/** +* @tc.name Test AdapterSetPassthroughMode API when the PortType is PORT_OUT. +* @tc.number SUB_Audio_HDI_AdapterSetPassthroughMode_0001 +* @tc.desc test AdapterSetPassthroughMode interface, return 0 if PortType is PORT_OUT. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterSetPassthroughMode_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioPort audioPort = {}; + struct AudioAdapter *adapter = nullptr; + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + enum AudioPortPassthroughMode modeLpcm = PORT_PASSTHROUGH_AUTO; + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, audioPort); + ASSERT_EQ(HDF_SUCCESS, ret); + ASSERT_NE(nullptr, adapter); + ret = adapter->InitAllPorts(adapter); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = adapter->SetPassthroughMode(adapter, &audioPort, PORT_PASSTHROUGH_LPCM); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = adapter->GetPassthroughMode(adapter, &audioPort, &modeLpcm); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(PORT_PASSTHROUGH_LPCM, modeLpcm); + + manager.UnloadAdapter(&manager, adapter); +} + +/** +* @tc.name Test AdapterSetPassthroughMode API when the PortType is PORT_IN. +* @tc.number SUB_Audio_HDI_AdapterSetPassthroughMode_0002 +* @tc.desc test AdapterSetPassthroughMode interface, return -1 if PortType is PORT_IN. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterSetPassthroughMode_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = nullptr; + struct AudioPort audioPort = {}; + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + + ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME2, &adapter, audioPort); + ASSERT_EQ(HDF_SUCCESS, ret); + ASSERT_NE(nullptr, adapter); + ret = adapter->InitAllPorts(adapter); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = adapter->SetPassthroughMode(adapter, &audioPort, PORT_PASSTHROUGH_LPCM); + EXPECT_EQ(HDF_FAILURE, ret); + + manager.UnloadAdapter(&manager, adapter); +} + +/** +* @tc.name Test AdapterSetPassthroughMode API when the parameter adapter is nullptr. +* @tc.number SUB_Audio_HDI_AdapterSetPassthroughMode_0003 +* @tc.desc test AdapterSetPassthroughMode interface, return -1 the parameter adapter is empty. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterSetPassthroughMode_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioPort audioPort = {}; + struct AudioAdapter *adapter = nullptr; + struct AudioAdapter *adapterNull = nullptr; + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME3, &adapter, audioPort); + ASSERT_EQ(HDF_SUCCESS, ret); + ASSERT_NE(nullptr, adapter); + ret = adapter->SetPassthroughMode(adapterNull, &audioPort, PORT_PASSTHROUGH_LPCM); + EXPECT_EQ(HDF_FAILURE, ret); + manager.UnloadAdapter(&manager, adapter); +} + +/** +* @tc.name Test AdapterSetPassthroughMode API when the parameter audioPort is nullptr or not supported. +* @tc.number SUB_Audio_HDI_AdapterSetPassthroughMode_0004 +* @tc.desc test AdapterSetPassthroughMode interface, return -1 if the audioPort is nullptr or not supported. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterSetPassthroughMode_0004, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioPort audioPort = {}; + struct AudioPort *audioPortNull = nullptr; + enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; + struct AudioAdapter *adapter = nullptr; + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + struct AudioPort audioPortError = { .dir = PORT_OUT, .portId = 8, .portName = "AIP1" }; + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, audioPort); + ASSERT_EQ(HDF_SUCCESS, ret); + ASSERT_NE(nullptr, adapter); + ret = adapter->InitAllPorts(adapter); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = adapter->SetPassthroughMode(adapter, audioPortNull, mode); + EXPECT_EQ(HDF_FAILURE, ret); + + ret = adapter->SetPassthroughMode(adapter, &audioPortError, mode); + EXPECT_EQ(HDF_FAILURE, ret); + manager.UnloadAdapter(&manager, adapter); +} + +/** +* @tc.name Test AdapterSetPassthroughMode API when the not supported mode. +* @tc.number SUB_Audio_HDI_AdapterSetPassthroughMode_0005 +* @tc.desc test AdapterSetPassthroughMode interface, return -1 if the not supported mode. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterSetPassthroughMode_0005, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioPort audioPort = {}; + struct AudioAdapter *adapter = nullptr; + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, audioPort); + ASSERT_EQ(HDF_SUCCESS, ret); + ASSERT_NE(nullptr, adapter); + ret = adapter->InitAllPorts(adapter); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = adapter->SetPassthroughMode(adapter, &audioPort, PORT_PASSTHROUGH_RAW); + EXPECT_EQ(HDF_FAILURE, ret); + + manager.UnloadAdapter(&manager, adapter); +} + +/** +* @tc.name Test AdapterGetPassthroughMode API via legal input +* @tc.number SUB_Audio_HDI_AdapterGetPassthroughMode_0001 +* @tc.desc test AdapterGetPassthroughMode interface, return 0 if is get successfully. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPassthroughMode_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioPort audioPort = {}; + enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_AUTO; + struct AudioAdapter *adapter = nullptr; + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, audioPort); + ASSERT_EQ(HDF_SUCCESS, ret); + ASSERT_NE(nullptr, adapter); + ret = adapter->InitAllPorts(adapter); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = adapter->SetPassthroughMode(adapter, &audioPort, PORT_PASSTHROUGH_LPCM); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = adapter->GetPassthroughMode(adapter, &audioPort, &mode); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(PORT_PASSTHROUGH_LPCM, mode); + + manager.UnloadAdapter(&manager, adapter); +} + +/** +* @tc.name Test AdapterGetPassthroughMode API when the parameter adapter is nullptr. +* @tc.number SUB_Audio_HDI_AdapterGetPassthroughMode_0002 +* @tc.desc test AdapterGetPassthroughMode interface, return -1 if the parameter adapter is empty.. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPassthroughMode_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioPort audioPort = {}; + enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; + struct AudioAdapter *adapter = nullptr; + struct AudioAdapter *adapterNull = nullptr; + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, audioPort); + ASSERT_EQ(HDF_SUCCESS, ret); + ASSERT_NE(nullptr, adapter); + ret = adapter->InitAllPorts(adapter); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = adapter->GetPassthroughMode(adapterNull, &audioPort, &mode); + EXPECT_EQ(HDF_FAILURE, ret); + + manager.UnloadAdapter(&manager, adapter); +} + +/** +* @tc.name Test AdapterGetPassthroughMode API when the parameter audioPort is nullptr or not supported. +* @tc.number SUB_Audio_HDI_AdapterGetPassthroughMode_0003 +* @tc.desc test AdapterGetPassthroughMode interface, return -1 if the audioPort is nullptr or not supported. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPassthroughMode_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioPort audioPort = {}; + struct AudioPort *audioPortNull = nullptr; + enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM; + struct AudioAdapter *adapter = nullptr; + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + struct AudioPort audioPortError = { .dir = PORT_OUT, .portId = 8, .portName = "AIP" }; + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, audioPort); + ASSERT_EQ(HDF_SUCCESS, ret); + ASSERT_NE(nullptr, adapter); + ret = adapter->InitAllPorts(adapter); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = adapter->GetPassthroughMode(adapter, audioPortNull, &mode); + EXPECT_EQ(HDF_FAILURE, ret); + + ret = adapter->GetPassthroughMode(adapter, &audioPortError, &mode); + EXPECT_EQ(HDF_FAILURE, ret); + manager.UnloadAdapter(&manager, adapter); +} + +/** +* @tc.name Test AdapterGetPassthroughMode API when the parameter mode is nullptr. +* @tc.number SUB_Audio_HDI_AdapterGetPassthroughMode_0004 +* @tc.desc test AdapterGetPassthroughMode interface, return -1 if the parameter mode is empty. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPassthroughMode_0004, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioPort audioPort = {}; + enum AudioPortPassthroughMode *modeNull = nullptr; + struct AudioAdapter *adapter = nullptr; + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, audioPort); + ASSERT_EQ(HDF_SUCCESS, ret); + ASSERT_NE(nullptr, adapter); + ret = adapter->InitAllPorts(adapter); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = adapter->GetPassthroughMode(adapter, &audioPort, modeNull); + EXPECT_EQ(HDF_FAILURE, ret); + + manager.UnloadAdapter(&manager, adapter); +} +} \ No newline at end of file diff --git a/audio/test/systemtest/hdi/capture/BUILD.gn b/audio/test/systemtest/hdi/capture/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..c3c5e075d97eb846c17acf0cfda696a44e53ac21 --- /dev/null +++ b/audio/test/systemtest/hdi/capture/BUILD.gn @@ -0,0 +1,212 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//drivers/adapter/uhdf2/uhdf.gni") + +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" + ] + + 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/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/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/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/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########################### \ No newline at end of file diff --git a/audio/test/systemtest/hdi/capture/include/audio_hdicapture_attr_test.h b/audio/test/systemtest/hdi/capture/include/audio_hdicapture_attr_test.h new file mode 100755 index 0000000000000000000000000000000000000000..e08c8b5289ac8ce0705d5717bf6f8978965e9555 --- /dev/null +++ b/audio/test/systemtest/hdi/capture/include/audio_hdicapture_attr_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_ATTR_TEST_H +#define AUDIO_HDICAPTURE_ATTR_TEST_H + +#endif diff --git a/audio/test/systemtest/hdi/capture/include/audio_hdicapture_control_test.h b/audio/test/systemtest/hdi/capture/include/audio_hdicapture_control_test.h new file mode 100755 index 0000000000000000000000000000000000000000..a2de06e2e2fd93a8ea47bd3c194a2282bcefbd64 --- /dev/null +++ b/audio/test/systemtest/hdi/capture/include/audio_hdicapture_control_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_CONTROL_TEST_H +#define AUDIO_HDICAPTURE_CONTROL_TEST_H + +#endif diff --git a/audio/test/systemtest/hdi/capture/include/audio_hdicapture_scene_test.h b/audio/test/systemtest/hdi/capture/include/audio_hdicapture_scene_test.h new file mode 100755 index 0000000000000000000000000000000000000000..e80537f6edfebcc36bdf94c67e0f10e6f4d33b18 --- /dev/null +++ b/audio/test/systemtest/hdi/capture/include/audio_hdicapture_scene_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_SCENE_TEST_H +#define AUDIO_HDICAPTURE_SCENE_TEST_H + +#endif diff --git a/audio/test/systemtest/hdi/capture/include/audio_hdicapture_test.h b/audio/test/systemtest/hdi/capture/include/audio_hdicapture_test.h new file mode 100755 index 0000000000000000000000000000000000000000..b2a3dc872054065c88052430be0f0ed725f6f010 --- /dev/null +++ b/audio/test/systemtest/hdi/capture/include/audio_hdicapture_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_TEST_H +#define AUDIO_HDICAPTURE_TEST_H + +#endif diff --git a/audio/test/systemtest/hdi/capture/include/audio_hdicapture_volume_test.h b/audio/test/systemtest/hdi/capture/include/audio_hdicapture_volume_test.h new file mode 100755 index 0000000000000000000000000000000000000000..f51f3953cef2206a614e98bf3b6ce944ba9f5712 --- /dev/null +++ b/audio/test/systemtest/hdi/capture/include/audio_hdicapture_volume_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_VOLUME_TEST_H +#define AUDIO_HDICAPTURE_VOLUME_TEST_H + +#endif 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 new file mode 100755 index 0000000000000000000000000000000000000000..e70c0bfb14a235bf4d0d21424090e20885e86940 --- /dev/null +++ b/audio/test/systemtest/hdi/capture/src/audio_hdicapture_attr_test.cpp @@ -0,0 +1,1344 @@ +/* + * 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 Defines audio-related APIs, including custom data types and functions for capture drivers funtion. + * accessing a driver adapter, and capturing audios. + * + * @since 1.0 + * @version 1.0 + */ + +/** + * @file audio_hdi_common.h + * + * @brief Declares APIs for operations related to the capturing audio adapter. + * + * @since 1.0 + * @version 1.0 + */ + +#include "audio_hdi_common.h" +#include "audio_hdicapture_attr_test.h" + +using namespace std; +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"; + +class AudioHdiCaptureAttrTest : public testing::Test { +public: + static void SetUpTestCase(void); + 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; +}; + +void AudioHdiCaptureAttrTest::SetUpTestCase(void) {} + +void AudioHdiCaptureAttrTest::TearDownTestCase(void) {} + +void AudioHdiCaptureAttrTest::SetUp(void) +{ + char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; + handleSo = dlopen(resolvedPath, RTLD_LAZY); + if (handleSo == nullptr) { + return; + } + GetAudioManager = (struct AudioManager *(*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); + if (GetAudioManager == 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]; + } + } + 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 AudioHdiCaptureAttrTest::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 || adapter->CreateCapture == nullptr || capture == nullptr) { + return HDF_FAILURE; + } + ret = InitAttrs(attrs); + if (ret < 0) { + return HDF_FAILURE; + } + ret = InitDevDesc(devDesc, capturePort.portId, pins); + if (ret < 0) { + return HDF_FAILURE; + } + ret = adapter->CreateCapture(adapter, &devDesc, &attrs, capture); + if (ret < 0 || *capture == nullptr) { + manager.UnloadAdapter(&manager, adapter); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHdiCaptureAttrTest::AudioCaptureStart(const string path, struct AudioCapture *capture) const +{ + int32_t ret = -1; + struct AudioSampleAttributes attrs = {}; + if (capture == nullptr) { + return HDF_FAILURE; + } + 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; +} + +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0001 +* @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; +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0001, TestSize.Level1) +{ + 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 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); + 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 = 8000; + attrs.channelCount = 1; + + ret = capture->attr.SetSampleAttributes(capture, &attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->attr.GetSampleAttributes(capture, &attrsValue); + 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); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0002 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_24_BIT; +* attrs.sampleRate = 11025; +* attrs.channelCount = 2; +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0002, TestSize.Level1) +{ + 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 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); + 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_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); + EXPECT_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); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0003 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = 22050; +* attrs.channelCount = 1; +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0003, TestSize.Level1) +{ + 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 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); + 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 = 22050; + attrs.channelCount = 1; + + ret = capture->attr.SetSampleAttributes(capture, &attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->attr.GetSampleAttributes(capture, &attrsValue); + 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); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0004 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_24_BIT; +* attrs.sampleRate = 32000; +* attrs.channelCount = 2; +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0004, TestSize.Level1) +{ + 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 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); + 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_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); + EXPECT_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); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0005 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = 44100; +* attrs.channelCount = 1; +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0005, TestSize.Level1) +{ + 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 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); + 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 = 44100; + attrs.channelCount = 1; + + ret = capture->attr.SetSampleAttributes(capture, &attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->attr.GetSampleAttributes(capture, &attrsValue); + 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); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0006 +* @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_COMMUNICATION; +* attrs.format = AUDIO_FORMAT_PCM_24_BIT; +* attrs.sampleRate = 48000; +* attrs.channelCount = 2; +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0006, TestSize.Level1) +{ + 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 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); + 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_COMMUNICATION; + attrs.format = AUDIO_FORMAT_PCM_24_BIT; + attrs.sampleRate = 48000; + attrs.channelCount = 2; + + ret = capture->attr.SetSampleAttributes(capture, &attrs); + 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_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 setting the capture is empty . +* @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0007 +* @tc.desc Test AudioCaptureSetSampleAttributes interface, return -1 if the capture is empty. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0007, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioPort capturePort = {}; + struct AudioAdapter *adapter = {}; + struct AudioSampleAttributes attrs = {}; + 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); + 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; + + ret = capture->attr.SetSampleAttributes(captureNull, &attrs); + EXPECT_EQ(HDF_FAILURE, ret); + ret = capture->attr.SetSampleAttributes(capture, nullptr); + 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_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; +* @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 = {}; + 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); + 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); + + 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); + + 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); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via illegal 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; +* @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 = {}; + 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); + 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); + + 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); + + 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); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via illegal 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; +* @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 = {}; + 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); + 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); + + 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); + + 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); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via illegal 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; +* @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 = {}; + 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); + 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_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); + + 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); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via illegal 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; +* @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 = {}; + 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); + 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_AAC_HE_V1; + attrs1.sampleRate = 8000; + attrs1.channelCount = 1; + ret = capture->attr.SetSampleAttributes(capture, &attrs1); + EXPECT_EQ(HDF_FAILURE, 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); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureSetSampleAttributes API via illegal input. +* @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; +* @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 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); + 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 = 8000; + attrs.channelCount = 5; + ret = capture->attr.SetSampleAttributes(capture, &attrs); + 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 = 8000; + uint32_t ret2 = 1; + struct AudioPort capturePort = {}; + struct AudioAdapter *adapter = {}; + struct AudioSampleAttributes attrs = {}; + struct AudioSampleAttributes attrsValue = {}; + struct AudioCapture *capture = nullptr; + enum AudioPortDirection portType = PORT_IN; + enum AudioPortPin pins = PIN_IN_MIC; + struct AudioManager manager = *GetAudioManager(); + ASSERT_NE(nullptr, GetAudioManager); + + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + + 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); + 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); + EXPECT_EQ(ret2, attrsValue.channelCount); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureGetSampleAttributes API via setting the capture is empty . +* @tc.number SUB_Audio_HDI_AudioCaptureGetSampleAttributes_0002 +* @tc.desc Test AudioCaptureGetSampleAttributes interface, return -1 if the capture is empty. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureGetSampleAttributes_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioPort capturePort = {}; + struct AudioAdapter *adapter = {}; + struct AudioSampleAttributes attrs = {}; + 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); + 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; + + ret = capture->attr.GetSampleAttributes(captureNull, &attrs); + EXPECT_EQ(HDF_FAILURE, ret); + ret = capture->attr.GetSampleAttributes(capture, nullptr); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureGetFrameSize API via legal input +* @tc.number SUB_Audio_hdi_CaptureGetFrameSize_0001 +* @tc.desc test AudioCaptureGetFrameSize interface, return 0 is call successfully. +* @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(size, INITIAL_VALUE); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureGetFrameSize API via setting the parameter handle is nullptr +* @tc.number SUB_Audio_hdi_CaptureGetFrameSize_0002 +* @tc.desc test AudioCaptureGetFrameSize interface, return -1 if the parameter handle is nullptr. +* @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureGetFrameSize API via setting the parameter size is nullptr +* @tc.number SUB_Audio_hdi_CaptureGetFrameSize_0003 +* @tc.desc test AudioCaptureGetFrameSize interface, return -1 if the parameter size is nullptr. +* @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureGetFrameCount API via legal input +* @tc.number SUB_Audio_hdi_CaptureGetFrameCount_0001 +* @tc.desc test AudioCaptureGetFrameCount interface, return 0 if the FrameCount is called after creating the object. +* @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(count, INITIAL_VALUE); + + capture->control.Stop((AudioHandle)capture); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureGetFrameCount API via legal input in the difference scene +* @tc.number SUB_Audio_hdi_CaptureGetFrameCount_0001 +* @tc.desc test AudioCaptureGetFrameCount interface, return 0 if the GetFrameCount is called after started. +* @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(count, INITIAL_VALUE); + + 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_0003 +* @tc.desc test AudioCaptureGetFrameCount interface, return -1 if the parameter handle is nullptr. +* @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + 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 +* @tc.desc test AudioCaptureGetFrameCount interface, return -1 if the parameter handle is nullptr. +* @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + 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.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetCurrentChannelId_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; + uint32_t channelId = 0; + uint32_t channelIdValue = CHANNELCOUNT; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(channelIdValue, channelId); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test GetCurrentChannelId API via getting channelId to 1 and set channelCount to 1 + * @tc.number SUB_Audio_HDI_CaptureGetCurrentChannelId_0002 + * @tc.desc Test GetCurrentChannelId interface,return 0 if get channelId to 1 and set channelCount to 1 + * @tc.author: tiansuli +*/ +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 = {}; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(channelCountExp, attrsValue.channelCount); + + ret = capture->attr.GetCurrentChannelId(capture, &channelId); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(channelIdExp, channelId); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test GetCurrentChannelId API via CurrentChannelId is obtained after started + * @tc.number SUB_Audio_HDI_CaptureGetCurrentChannelId_0003 + * @tc.desc Test GetCurrentChannelId interface, return 0 if CurrentChannelId is obtained after started + * @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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.GetCurrentChannelId(capture, &channelId); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(channelIdExp, channelId); + + capture->control.Stop((AudioHandle)capture); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test GetCurrentChannelId API via setting the parameter capture is nullptr + * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_0004 + * @tc.desc Test GetCurrentChannelId interface,return -1 if set the parameter capture is nullptr + * @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test CaptureGetCurrentChannelId API via setting the parameter channelId is nullptr + * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_0005 + * @tc.desc Test CaptureGetCurrentChannelId interface, return -1 if setting the parameter channelId is nullptr + * @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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, channelIdNull); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +} 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 new file mode 100755 index 0000000000000000000000000000000000000000..2542dab01f291316fb04710013af349eb979d630 --- /dev/null +++ b/audio/test/systemtest/hdi/capture/src/audio_hdicapture_control_test.cpp @@ -0,0 +1,1293 @@ +/* + * 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 Defines audio-related APIs, including custom data types and functions for capture drivers funtion. + * accessing a driver adapter, and capturing audios. + * + * @since 1.0 + * @version 1.0 + */ + +/** + * @file audio_hdi_common.h + * + * @brief Declares APIs for operations related to the capturing audio adapter. + * + * @since 1.0 + * @version 1.0 + */ + +#include "audio_hdi_common.h" +#include "audio_hdicapture_control_test.h" + +using namespace std; +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"; + +class AudioHdiCaptureControlTest : public testing::Test { +public: + static void SetUpTestCase(void); + 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; +}; + +void AudioHdiCaptureControlTest::SetUpTestCase(void) {} + +void AudioHdiCaptureControlTest::TearDownTestCase(void) {} + +void AudioHdiCaptureControlTest::SetUp(void) +{ + char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; + handleSo = dlopen(resolvedPath, RTLD_LAZY); + if (handleSo == nullptr) { + return; + } + GetAudioManager = (struct AudioManager *(*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); + if (GetAudioManager == 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; + } + ret = InitDevDesc(devDesc, capturePort.portId, pins); + if (ret < 0) { + return HDF_FAILURE; + } + ret = adapter->CreateCapture(adapter, &devDesc, &attrs, capture); + if (ret < 0 || *capture == nullptr) { + manager.UnloadAdapter(&manager, adapter); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHdiCaptureControlTest::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; + } + ret = InitDevDesc(devDesc, renderPort.portId, pins); + if (ret < 0) { + return HDF_FAILURE; + } + ret = adapter->CreateRender(adapter, &devDesc, &attrs, render); + if (ret < 0 || *render == nullptr) { + manager.UnloadAdapter(&manager, adapter); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHdiCaptureControlTest::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; +} + +/** +* @tc.name Test AudioCreateCapture API via legal input +* @tc.number SUB_Audio_HDI_AudioCreateCapture_0001 +* @tc.desc Test AudioCreateCapture interface,Returns 0 if the AudioCapture object is created successfully +* @tc.author: liweiming +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = AudioCreateCapture(pins, manager, capturePort, adapter, &capture); + if (ret < 0) { + manager.UnloadAdapter(&manager, adapter); + ASSERT_EQ(HDF_SUCCESS, ret); + } + EXPECT_EQ(HDF_SUCCESS, ret); + 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_0003 +* @tc.desc test AudioCreateCapture interface,Returns 0 if the AudioCapture object can be created successfully + when AudioRender was created +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, audioPort); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = AudioCreateRender(pinsRender, manager, adapter, audioPort, &render); + if (ret < 0) { + manager.UnloadAdapter(&manager, adapter); + ASSERT_EQ(HDF_SUCCESS, ret); + } + ret = AudioCreateCapture(pinsCapture, manager, audioPort, adapter, &capture); + if (ret < 0) { + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); + ASSERT_EQ(HDF_SUCCESS, ret); + } + adapter->DestroyRender(adapter, render); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCreateCapture API via creating two capture objects +* @tc.number SUB_Audio_HDI_AudioCreateCapture_0004 +* @tc.desc Test AudioCreateCapture interface,return 0 if the the two audiocapture objects are created successfully +* @tc.author: liweiming +*/ +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; + struct AudioCapture *captureFirst = nullptr; + struct AudioCapture *captureSecond = nullptr; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapterFirst, capturePortFirst); + 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); + if (ret < 0) { + adapterFirst->DestroyCapture(adapterFirst, captureFirst); + manager.UnloadAdapter(&manager, adapterFirst); + manager.UnloadAdapter(&manager, adapterSecond); + ASSERT_EQ(HDF_SUCCESS, ret); + } + adapterFirst->DestroyCapture(adapterFirst, captureFirst); + adapterSecond->DestroyCapture(adapterSecond, captureSecond); + manager.UnloadAdapter(&manager, adapterFirst); + manager.UnloadAdapter(&manager, adapterSecond); +} +/** +* @tc.name Test AudioCreateCapture API via setting the incoming parameter adapter is nullptr +* @tc.number SUB_Audio_HDI_AudioCreateCapture_0005 +* @tc.desc Test AudioCreateCapture interface,Returns -1 if the incoming parameter adapter is nullptr +* @tc.author: liweiming +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0005, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioPort capturePort = {}; + struct AudioDeviceDescriptor devDesc = {}; + struct AudioSampleAttributes attrs = {}; + enum AudioPortDirection portType = PORT_IN; + enum AudioPortPin pins = PIN_IN_MIC; + struct AudioAdapter *adapter = nullptr; + struct AudioAdapter *adapterNull = nullptr; + struct AudioCapture *capture = nullptr; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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(adapterNull, &devDesc, &attrs, &capture); + EXPECT_EQ(HDF_FAILURE, ret); + + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCreateCapture API via setting the incoming parameter desc is nullptr +* @tc.number SUB_Audio_HDI_AudioCreateCapture_0006 +* @tc.desc Test AudioCreateCapture interface,Returns -1 if the incoming parameter desc is nullptr +* @tc.author: liweiming +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0006, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioPort capturePort = {}; + struct AudioSampleAttributes attrs = {}; + enum AudioPortDirection portType = PORT_IN; + struct AudioDeviceDescriptor *devDesc = 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); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = InitAttrs(attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = adapter->CreateCapture(adapter, devDesc, &attrs, &capture); + EXPECT_EQ(HDF_FAILURE, ret); + + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCreateCapture API via setting the incoming parameter attrs is nullptr +* @tc.number SUB_Audio_HDI_AudioCreateCapture_0007 +* @tc.desc Test AudioCreateCapture interface,Returns -1 if the incoming parameter attrs is nullptr +* @tc.author: liweiming +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0007, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioPort capturePort = {}; + struct AudioDeviceDescriptor devDesc = {}; + enum AudioPortDirection portType = PORT_IN; + enum AudioPortPin pins = PIN_IN_MIC; + struct AudioSampleAttributes *attrs = 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); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = InitDevDesc(devDesc, capturePort.portId, pins); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = adapter->CreateCapture(adapter, &devDesc, attrs, &capture); + EXPECT_EQ(HDF_FAILURE, ret); + + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCreateCapture API via setting the incoming parameter capture is nullptr +* @tc.number SUB_Audio_HDI_AudioCreateCapture_0008 +* @tc.desc Test AudioCreateCapture interface,Returns -1 if the incoming parameter capture is nullptr +* @tc.author: liweiming +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0008, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioPort capturePort = {}; + struct AudioDeviceDescriptor devDesc = {}; + struct AudioSampleAttributes attrs = {}; + enum AudioPortDirection portType = PORT_IN; + enum AudioPortPin pins = PIN_IN_MIC; + struct AudioAdapter *adapter = nullptr; + struct AudioCapture **capture = nullptr; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + EXPECT_EQ(HDF_FAILURE, ret); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCreateCapture API via setting the incoming parameter adapter which port type is PORT_OUT +* @tc.number SUB_Audio_HDI_AudioCreateCapture_0008 +* @tc.desc Test AudioCreateCapture interface,Returns -1 if the incoming parameter adapter which port type is PORT_OUT +* @tc.author: liweiming +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0009, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioPort capturePort = {}; + struct AudioDeviceDescriptor devDesc = {}; + struct AudioSampleAttributes attrs = {}; + enum AudioPortDirection portType = PORT_OUT; + enum AudioPortPin pins = PIN_OUT_SPEAKER; + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME, &adapter, capturePort); + 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); + EXPECT_EQ(HDF_FAILURE, ret); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioDestroyCapture API via legal input +* @tc.number SUB_Audio_HDI_AudioDestroyCapture_0001 +* @tc.desc Test AudioDestroyCapture interface,Returns 0 if the AudioCapture object is destroyed +* @tc.author: liweiming +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); +} +/** +* @tc.name Test AudioDestroyCapture API via setting the incoming parameter adapter is nullptr +* @tc.number SUB_Audio_HDI_AudioDestroyCapture_0002 +* @tc.desc Test AudioDestroyCapture interface,Returns -1 if the incoming parameter adapter is nullptr +* @tc.author: liweiming +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + EXPECT_EQ(HDF_SUCCESS, ret); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioDestroyCapture API via setting the incoming parameter capture is nullptr +* @tc.number SUB_Audio_HDI_AudioDestroyCapture_0003 +* @tc.desc Test AudioDestroyCapture interface,Returns -1 if the incoming parameter capture is nullptr +* @tc.author: liweiming +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioDestroyCapture_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioPort capturePort = {}; + enum AudioPortDirection portType = PORT_IN; + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = nullptr; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = adapter->DestroyCapture(adapter, capture); + EXPECT_EQ(HDF_FAILURE, ret); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureStart API via legal input +* @tc.number SUB_Audio_HDI_StartCapture_0001 +* @tc.desc Test AudioCaptureStart interface,return 0 if the audiocapture object is started successfully +* @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStart_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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); + + capture->control.Stop((AudioHandle)capture); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test CaptureStart API via setting the incoming parameter handle is nullptr +* @tc.number SUB_Audio_HDI_CaptureStart_0002 +* @tc.desc Test CaptureStart interface,return -1 if the incoming parameter handle is nullptr +* @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStart_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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); + + capture->control.Stop((AudioHandle)capture); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureStart API via start two capture object continuously +* @tc.number SUB_Audio_HDI_CaptureStart_0003 +* @tc.desc Test AudioCaptureStart interface,return 0 if the Audiocapturestart was successfully called twice +* @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStart_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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); + + capture->control.Stop((AudioHandle)capture); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test AudioCaptureStop API via legal input + * @tc.number SUB_Audio_HDI_CaptureStop_0001 + * @tc.desc Test AudioCaptureStop interface,return 0 if the audiocapture object is stopped successfully + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStop_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test AudioCaptureStop API via stop two capture object continuously + * @tc.number SUB_Audio_HDI_CaptureStop_0002 + * @tc.desc Test AudioCaptureStop interface,return -4 if Audiocapturestop was successfully called twice + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStop_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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); + EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test AudioCaptureStop API via start an audio capture after stopping + * @tc.number SUB_Audio_HDI_CaptureStop_0003 + * @tc.desc Test AudioCaptureStop interface,return 0 if stop and start an audio capture successfully + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStop_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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); + + capture->control.Stop((AudioHandle)capture); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test AudioCaptureStop API via the capture does not start and stop only + * @tc.number SUB_Audio_HDI_CaptureStop_0004 + * @tc.desc Test AudioCaptureStop interface,return -4 if the capture does not start and stop only + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStop_0004, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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 CapturePause API via legal input + * @tc.number SUB_Audio_HDI_CapturePause_0001 + * @tc.desc test HDI CapturePause interface，return 0 if the capture is paused after start + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CapturePause_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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.Stop((AudioHandle)capture); + EXPECT_EQ(HDF_SUCCESS, ret); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test CapturePause API via the interface is called twice in a row + * @tc.number SUB_Audio_HDI_CapturePause_0002 + * @tc.desc Test CapturePause interface, return -1 the second time if CapturePause is called twice + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CapturePause_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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); + + ret = capture->control.Stop((AudioHandle)capture); + EXPECT_EQ(HDF_SUCCESS, ret); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test CapturePause API via setting the incoming parameter handle is nullptr + * @tc.number SUB_Audio_HDI_CapturePause_0003 + * @tc.desc Test CapturePause interface,return -1 if the incoming parameter handle is nullptr + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CapturePause_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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); + + ret = capture->control.Stop((AudioHandle)capture); + EXPECT_EQ(HDF_SUCCESS, ret); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test CapturePause API via the capture is not Started and paused only. + * @tc.number SUB_Audio_HDI_CapturePause_0004 + * @tc.desc Test AudioRenderPause interface,return -1 if the capture is not Started and paused only. + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CapturePause_0004, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test CapturePause API via the capture is paused after stoped. + * @tc.number SUB_Audio_HDI_CapturePause_0005 + * @tc.desc Test CapturePause interface, return -1 the capture is paused after stoped. + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CapturePause_0005, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test CaptureResume API via legal input + * @tc.number SUB_Audio_HDI_CaptureResume_0001 + * @tc.desc Test CaptureResume interface,return 0 if the capture is resumed after paused + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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.Stop((AudioHandle)capture); + EXPECT_EQ(HDF_SUCCESS, ret); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test CaptureResume API via the interface is called twice in a row + * @tc.number SUB_Audio_HDI_CaptureResume_0002 + * @tc.desc Test CaptureResume interface,return -1 the second time if the CaptureResume is called twice + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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); + + ret = capture->control.Stop((AudioHandle)capture); + EXPECT_EQ(HDF_SUCCESS, ret); + 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 + * @tc.desc test HDI CaptureResume interface,return -1 if the capture is resumed after started + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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); + + ret = capture->control.Stop((AudioHandle)capture); + EXPECT_EQ(HDF_SUCCESS, ret); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test CaptureResume API via setting the incoming parameter handle is nullptr + * @tc.number SUB_Audio_HDI_CaptureResume_0004 + * @tc.desc Test CaptureResume interface, return -1 if the incoming parameter handle is nullptr + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0004, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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); + + ret = capture->control.Stop((AudioHandle)capture); + EXPECT_EQ(HDF_SUCCESS, ret); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test CaptureResume API via the capture is resumed after stopped +* @tc.number SUB_Audio_HDI_CaptureResume_0005 +* @tc.desc test HDI CaptureResume interface,return -1 if the capture is resumed after stopped +* @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0005, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test CaptureResume API via the capture Continue to start after resume +* @tc.number SUB_Audio_HDI_CaptureResume_0006 +* @tc.desc test HDI CaptureResume interface,return -1 if the capture Continue to start after resume +* @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0006, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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); + EXPECT_EQ(HDF_FAILURE, ret); + + capture->control.Stop((AudioHandle)capture); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test RenderResume API via the different capture objects is startedã€pausedã€resumed and stopped. +* @tc.number SUB_Audio_HDI_CaptureResume_0007 +* @tc.desc test HDI CaptureResume interface,return 0 if the different objects is startedã€pausedã€resumed and stopped. +* @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0007, TestSize.Level1) +{ + struct AudioManager 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_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); + 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); +} +/** + * @tc.name Test CaptureFlush API via legal input Verify that the data in the buffer is flushed after stop + * @tc.number SUB_Audio_HDI_CaptureFlush_0001 + * @tc.desc Test CaptureFlush interface,return -2 if the data in the buffer is flushed successfully after stop + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureFlush_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test CaptureFlush that the data in the buffer is flushed when handle is nullptr + * @tc.number SUB_Audio_HDI_CaptureFlush_0002 + * @tc.desc Test CaptureFlush, return -1 if the data in the buffer is flushed when handle is nullptr + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureFlush_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +} \ No newline at end of file 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 new file mode 100755 index 0000000000000000000000000000000000000000..7ecfdc29d35d94bbb775dc7a01b69b7a93f6ca1b --- /dev/null +++ b/audio/test/systemtest/hdi/capture/src/audio_hdicapture_scene_test.cpp @@ -0,0 +1,540 @@ +/* + * 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 Defines audio-related APIs, including custom data types and functions for capture drivers funtion. + * accessing a driver adapter, and capturing audios. + * + * @since 1.0 + * @version 1.0 + */ + +/** + * @file audio_hdi_common.h + * + * @brief Declares APIs for operations related to the capturing audio adapter. + * + * @since 1.0 + * @version 1.0 + */ + +#include "audio_hdi_common.h" +#include "audio_hdicapture_scene_test.h" + +using namespace std; +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"; + +class AudioHdiCaptureSceneTest : public testing::Test { +public: + static void SetUpTestCase(void); + 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; +}; + +void AudioHdiCaptureSceneTest::SetUpTestCase(void) {} + +void AudioHdiCaptureSceneTest::TearDownTestCase(void) {} + +void AudioHdiCaptureSceneTest::SetUp(void) +{ + char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; + handleSo = dlopen(resolvedPath, RTLD_LAZY); + if (handleSo == nullptr) { + return; + } + GetAudioManager = (struct AudioManager *(*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); + if (GetAudioManager == 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]; + } + } + 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 AudioHdiCaptureSceneTest::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 || adapter->CreateCapture == nullptr || capture == nullptr) { + return HDF_FAILURE; + } + ret = InitAttrs(attrs); + if (ret < 0) { + return HDF_FAILURE; + } + ret = InitDevDesc(devDesc, capturePort.portId, pins); + if (ret < 0) { + return HDF_FAILURE; + } + ret = adapter->CreateCapture(adapter, &devDesc, &attrs, capture); + if (ret < 0 || *capture == nullptr) { + manager.UnloadAdapter(&manager, adapter); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHdiCaptureSceneTest::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; +} + +/** +* @tc.name Test AudioCaptureCheckSceneCapability API and check scene's capability +* @tc.number SUB_Audio_HDI_CaptureCheckSceneCapability_0001 +* @tc.desc Test AudioCaptureCheckSceneCapability interface,return 0 if check scene's capability successful. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_CaptureCheckSceneCapability_0001, TestSize.Level1) +{ + int32_t ret = -1; + bool supported = false; + struct AudioPort capturePort = {}; + enum AudioPortDirection portType = PORT_IN; + enum AudioPortPin pins = PIN_IN_MIC; + 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); + 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); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_TRUE(supported); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test checking scene's capability where the scene is not configed in the josn. +* @tc.number SUB_Audio_HDI_CaptureCheckSceneCapability_0002 +* @tc.desc Test AudioCreateCapture interface,return -1 if the scene is not configed in the josn. +* @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 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); + 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); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test checking scene's capability where the capture is empty +* @tc.number SUB_Audio_HDI_CaptureCheckSceneCapability_0003 +* @tc.desc Test AudioCreateCapture interface,return -1 if the capture is empty. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_CaptureCheckSceneCapability_0003, TestSize.Level1) +{ + int32_t ret = -1; + bool supported = true; + 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; + struct AudioSceneDescriptor scenes = {}; + + struct AudioManager manager = *GetAudioManager(); + ASSERT_NE(nullptr, GetAudioManager); + + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + 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); +} +/** +* @tc.name Test checking scene's capability where the scene is empty +* @tc.number SUB_Audio_HDI_CaptureCheckSceneCapability_0004 +* @tc.desc Test AudioCreateCapture interface,return -1 if the scene is empty. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_CaptureCheckSceneCapability_0004, TestSize.Level1) +{ + int32_t ret = -1; + bool supported = true; + struct AudioPort capturePort = {}; + enum AudioPortDirection portType = PORT_IN; + enum AudioPortPin pins = PIN_IN_MIC; + 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); + 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); + + ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); + EXPECT_EQ(HDF_SUCCESS, ret); + + capture->control.Stop((AudioHandle)capture); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test checking scene's capability where the parameter supported is empty. +* @tc.number SUB_Audio_HDI_CaptureCheckSceneCapability_0005 +* @tc.desc Test AudioCreateCapture interface,return -1 if the parameter supported is empty. +* @tc.author: ZHANGHAILIN +*/ +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 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); + 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); +} +/** +* @tc.name Test AudioCaptureSelectScene API via legal input +* @tc.number SUB_Audio_HDI_AudioCaptureSelectScene_0001 +* @tc.desc Test AudioCaptureSelectScene interface,return 0 if select capture's scene successful. +* @tc.author: ZHANGHAILIN +*/ +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 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); + 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); + EXPECT_EQ(HDF_SUCCESS, ret); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureSelectScene API after capture start. +* @tc.number SUB_Audio_HDI_AudioCaptureSelectScene_0002 +* @tc.desc Test AudioCaptureSelectScene, return 0 if select capture's scene successful after capture start. +* @tc.author: ZHANGHAILIN +*/ +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 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); + 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); + + scenes.scene.id = 0; + scenes.desc.pins = PIN_IN_MIC; + ret = capture->scene.SelectScene(capture, &scenes); + EXPECT_EQ(HDF_SUCCESS, ret); + + capture->control.Stop((AudioHandle)capture); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureSelectScene API where the parameter handle is empty. +* @tc.number SUB_Audio_HDI_AudioCaptureSelectScene_0003 +* @tc.desc Test AudioCaptureSelectScene, return -1 if the parameter handle is empty. +* @tc.author: ZHANGHAILIN +*/ +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 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); + 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); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureSelectScene API where the parameter scene is empty. +* @tc.number SUB_Audio_HDI_AudioCaptureSelectScene_0004 +* @tc.desc Test AudioCaptureSelectScene, return -1 if the parameter scene is empty. +* @tc.author: ZHANGHAILIN +*/ +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 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); + 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); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureSelectScene API where the scene is not configed in the josn. +* @tc.number SUB_Audio_HDI_AudioCaptureSelectScene_0005 +* @tc.desc Test AudioCaptureSelectScene, return -1 if the scene is not configed in the josn. +* @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 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); + 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); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +} \ No newline at end of file diff --git a/audio/test/systemtest/hdi/capture/src/audio_hdicapture_test.cpp b/audio/test/systemtest/hdi/capture/src/audio_hdicapture_test.cpp new file mode 100755 index 0000000000000000000000000000000000000000..727eb650c5abdf11c9d9f608a65bb4dbb771853a --- /dev/null +++ b/audio/test/systemtest/hdi/capture/src/audio_hdicapture_test.cpp @@ -0,0 +1,1031 @@ +/* + * 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 Defines audio-related APIs, including custom data types and functions for capture drivers funtion. + * accessing a driver adapter, and capturing audios. + * + * @since 1.0 + * @version 1.0 + */ + +/** + * @file audio_hdi_common.h + * + * @brief Declares APIs for operations related to the capturing audio adapter. + * + * @since 1.0 + * @version 1.0 + */ + +#include "audio_hdi_common.h" +#include "audio_hdicapture_test.h" + +using namespace std; +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 int BUFFER_SIZE = 16384; +const int BUFFER_SIZE_LITTLE = 0; +const uint64_t FILESIZE = 2048; + +class AudioHdiCaptureTest : public testing::Test { +public: + static void SetUpTestCase(void); + 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 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) {} + +void AudioHdiCaptureTest::SetUp(void) +{ + char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; + handleSo = dlopen(resolvedPath, RTLD_LAZY); + if (handleSo == nullptr) { + return; + } + GetAudioManager = (struct AudioManager *(*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); + if (GetAudioManager == 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]; + } + } + 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 AudioHdiCaptureTest::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; + } + ret = InitDevDesc(devDesc, capturePort.portId, pins); + if (ret < 0) { + return HDF_FAILURE; + } + ret = adapter->CreateCapture(adapter, &devDesc, &attrs, capture); + if (ret < 0 || *capture == nullptr) { + manager.UnloadAdapter(&manager, adapter); + return HDF_FAILURE; + } + 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; +} + +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) +{ + int32_t ret = -1; + int size = 0; + auto *inst = (AudioHdiCaptureTest *)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 AudioHdiCaptureTest::RecordAudio(struct PrepareAudioPara& audiopara) +{ + int32_t ret = -1; + struct AudioDeviceDescriptor devDesc = {}; + if (audiopara.adapter == nullptr || audiopara.adapter->CreateCapture == nullptr + || audiopara.manager == nullptr) { + return HDF_FAILURE; + } + ret = InitAttrs(audiopara.attrs); + if (ret < 0) { + return HDF_FAILURE; + } + ret = InitDevDesc(devDesc, (&audiopara.audioPort)->portId, audiopara.pins); + if (ret < 0) { + return HDF_FAILURE; + } + 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; + } + + FILE *file = fopen(audiopara.path, "wb+"); + if (file == nullptr) { + audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); + return HDF_FAILURE; + } + ret = StartRecord(audiopara.capture, file, audiopara.fileSize); + if (ret < 0) { + audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture); + 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 +* @tc.desc test AudioCaptureCaptureFrame interface,Returns 0 if the input data is read successfully +* @tc.author: liweiming +*/ +HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0001, TestSize.Level1) +{ + 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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + + capture->control.Stop((AudioHandle)capture); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); + if (frame != nullptr) { + free(frame); + frame = nullptr; + } +} +/** +* @tc.name Test AudioCaptureCaptureFrame API via setting the incoming parameter frame is nullptr +* @tc.number SUB_Audio_HDI_AudioCaptureFrame_0002 +* @tc.desc test AudioCaptureCaptureFrame interface,Returns -1 if the incoming parameter frame is nullptr +* @tc.author: liweiming +*/ +HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0002, TestSize.Level1) +{ + 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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + EXPECT_EQ(HDF_FAILURE, ret); + + capture->control.Stop((AudioHandle)capture); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureCaptureFrame API via setting the incoming parameter replyBytes is nullptr +* @tc.number SUB_Audio_HDI_AudioCaptureFrame_0003 +* @tc.desc test AudioCaptureCaptureFrame interface,Returns -1 if the incoming parameter replyBytes is nullptr +* @tc.author: liweiming +*/ +HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0003, TestSize.Level1) +{ + 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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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_FAILURE, ret); + + capture->control.Stop((AudioHandle)capture); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); + if (frame != nullptr) { + free(frame); + frame = nullptr; + } +} +/** +* @tc.name Test AudioCaptureCaptureFrame API via setting the incoming parameter capture is nullptr +* @tc.number SUB_Audio_HDI_AudioCaptureFrame_0004 +* @tc.desc test AudioCaptureCaptureFrame interface,Returns -1 if the incoming parameter capture is nullptr +* @tc.author: liweiming +*/ +HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0004, TestSize.Level1) +{ + 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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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(captureNull, frame, requestBytes, &replyBytes); + EXPECT_EQ(HDF_FAILURE, ret); + + capture->control.Stop((AudioHandle)capture); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); + if (frame != nullptr) { + free(frame); + frame = nullptr; + } +} +/** +* @tc.name Test AudioCaptureFrame API without calling interface capturestart +* @tc.number SUB_Audio_HDI_AudioCaptureFrame_0005 +* @tc.desc Test AudioCaptureFrame interface,Returns -1 if without calling interface capturestart +* @tc.author: liweiming +*/ +HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0005, TestSize.Level1) +{ + 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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); + if (frame != nullptr) { + free(frame); + frame = nullptr; + } +} +/** +* @tc.name Test AudioCaptureCaptureFrame API via setting the incoming parameter requestBytes +less than interface requirements +* @tc.number SUB_Audio_HDI_AudioCaptureFrame_0006 +* @tc.desc test AudioCaptureCaptureFrame interface,Returns -1 if the incoming parameter +requestBytes less than interface requirements +* @tc.author: liweiming +*/ +HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0006, TestSize.Level1) +{ + 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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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_FAILURE, ret); + + capture->control.Stop((AudioHandle)capture); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); + if (frame != nullptr) { + free(frame); + frame = nullptr; + } +} +/** +* @tc.name Test AudioCaptureGetCapturePosition API via legal input +* @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0001 +* @tc.desc Test AudioCaptureGetCapturePosition interface,Returns 0 if get CapturePosition during playing. +* @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0001, TestSize.Level1) +{ + int32_t ret = -1; + uint64_t frames = 0; + int64_t timeExp = 0; + struct AudioTimeStamp time = {.tvSec = 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(3); + ret = audiopara.capture->GetCapturePosition(audiopara.capture, &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 = (int32_t)result; + EXPECT_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 Test GetCapturePosition API via get CapturePosition after the audiois Paused and resumed +* @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0002 +* @tc.desc Test GetCapturePosition interface,Returns 0 if get Position after Pause and resume during playing +* @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0002, TestSize.Level1) +{ + int32_t ret = -1; + uint64_t frames = 0; + int64_t timeExp = 0; + struct AudioTimeStamp time = {.tvSec = 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(3); + ret = audiopara.capture->control.Pause((AudioHandle)(audiopara.capture)); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.capture->GetCapturePosition(audiopara.capture, &frames, &time); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(time.tvSec, timeExp); + EXPECT_GT(frames, INITIAL_VALUE); + ret = audiopara.capture->control.Resume((AudioHandle)(audiopara.capture)); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = audiopara.capture->GetCapturePosition(audiopara.capture, &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 = (int32_t)result; + EXPECT_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 Test GetCapturePosition API via get CapturePosition after the audio file is stopped +* @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0003 +* @tc.desc Test GetCapturePosition interface,Returns 0 if get CapturePosition after stop during playing +* @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_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_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(3); + ret = audiopara.capture->GetCapturePosition(audiopara.capture, &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 = (int32_t)result; + EXPECT_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 Test GetCapturePosition API via get CapturePosition after the object is created + * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0004 + * @tc.desc Test GetCapturePosition interface, return 0 if get CapturePosition after the object is created + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0004, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager manager = {}; + struct AudioPort capturePort = {}; + struct AudioAdapter *adapter = {}; + struct AudioCapture *capture = nullptr; + uint64_t frames = 0; + struct AudioTimeStamp time = {.tvSec = 0}; + int64_t timeExp = 0; + + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME2, &adapter, capturePort); + 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, timeExp); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test GetCapturePosition API via setting the parameter Capture is nullptr + * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0005 + * @tc.desc Test GetCapturePosition interface, return -1 if setting the parameter Capture is nullptr + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0005, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager manager = {}; + struct AudioPort capturePort = {}; + 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_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); + + capture->control.Stop((AudioHandle)capture); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test GetCapturePosition API via setting the parameter frames is nullptr + * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0006 + * @tc.desc Test GetCapturePosition interface, return -1 if setting the parameter frames is nullptr + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0006, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager manager = {}; + struct AudioPort capturePort = {}; + struct AudioAdapter *adapter = {}; + struct AudioCapture *capture = nullptr; + uint64_t *framesNull = nullptr; + struct AudioTimeStamp time = {.tvSec = 0}; + + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME2, &adapter, capturePort); + 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); + + capture->control.Stop((AudioHandle)capture); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test GetCapturePosition API via setting the parameter time is nullptr + * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0007 + * @tc.desc Test GetCapturePosition interface, return -1 if setting the parameter time is nullptr + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0007, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager manager = {}; + struct AudioPort capturePort = {}; + 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_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); + + capture->control.Stop((AudioHandle)capture); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test GetCapturePosition API via get CapturePosition continuously + * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0008 + * @tc.desc Test GetCapturePosition interface, return 0 if the GetCapturePosition was called twice + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0008, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager manager = {}; + struct AudioPort capturePort = {}; + struct AudioAdapter *adapter = {}; + struct AudioCapture *capture = nullptr; + uint64_t frames = 0; + struct AudioTimeStamp time = {.tvSec = 0}; + struct AudioTimeStamp timeSec = {.tvNSec = 1}; + int64_t timeExp = 0; + + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME2, &adapter, capturePort); + 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_EQ(time.tvSec, timeExp); + EXPECT_GT(frames, INITIAL_VALUE); + ret = capture->GetCapturePosition(capture, &frames, &timeSec); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(timeSec.tvNSec, timeExp); + EXPECT_GT(frames, INITIAL_VALUE); + + capture->control.Stop((AudioHandle)capture); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test GetCapturePosition API via define format to AUDIO_FORMAT_PCM_16_BIT + * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0009 + * @tc.desc Test GetCapturePosition interface,return 0 if get framesize define format to AUDIO_FORMAT_PCM_16_BIT + * @tc.author: tiansuli +*/ +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(); + ASSERT_NE(nullptr, GetAudioManager); + ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME2, &adapter, capturePort); + 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); + } + attrs.type = AUDIO_IN_MEDIA; + attrs.interleaved = false; + attrs.format = AUDIO_FORMAT_PCM_16_BIT; + attrs.sampleRate = 48000; + attrs.channelCount = 2; + ret = capture->attr.SetSampleAttributes(capture, &attrs); + 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(channelCountExp, attrsValue.channelCount); + + 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.tvNSec, timeExp); + EXPECT_GT(frames, INITIAL_VALUE); + + capture->control.Stop((AudioHandle)capture); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test GetCapturePosition API via define format to AUDIO_FORMAT_PCM_24_BIT + * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0010 + * @tc.desc Test GetCapturePosition interface,return 0 if get framesize define format to AUDIO_FORMAT_PCM_24_BIT + * @tc.author: tiansuli +*/ +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 = {}; + 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(); + ASSERT_NE(nullptr, GetAudioManager); + ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME2, &adapter, capturePort); + 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); + } + attrs.type = AUDIO_IN_MEDIA; + attrs.interleaved = false; + attrs.format = AUDIO_FORMAT_PCM_24_BIT; + attrs.sampleRate = 48000; + attrs.channelCount = 2; + ret = capture->attr.SetSampleAttributes(capture, &attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + 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); + + 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.tvNSec, timeExp); + EXPECT_GT(frames, INITIAL_VALUE); + + capture->control.Stop((AudioHandle)capture); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test GetCapturePosition API via define sampleRate and channelCount to different value + * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0011 + * @tc.desc Test GetCapturePosition interface,return 0 if get framesize define channelCount as different values + * @tc.author: tiansuli +*/ +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 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(); + ASSERT_NE(nullptr, GetAudioManager); + ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME2, &adapter, capturePort); + 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); + } + attrs.type = AUDIO_IN_MEDIA; + attrs.interleaved = false; + 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); + 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 = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->GetCapturePosition(capture, &frames, &time); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(time.tvNSec, timeExp); + EXPECT_GT(frames, INITIAL_VALUE); + + capture->control.Stop((AudioHandle)capture); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test GetCapturePosition API via define sampleRate and channelCount to 1 + * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0012 + * @tc.desc Test GetCapturePosition interface,return 0 if get framesize define channelCount to 1 + * @tc.author: tiansuli +*/ +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(); + ASSERT_NE(nullptr, GetAudioManager); + ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME2, &adapter, capturePort); + 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); + } + attrs.type = AUDIO_IN_MEDIA; + attrs.interleaved = false; + attrs.format = AUDIO_FORMAT_PCM_24_BIT; + attrs.sampleRate = 48000; + attrs.channelCount = 1; + ret = capture->attr.SetSampleAttributes(capture, &attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + 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); + + 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.tvNSec, timeExp); + EXPECT_GT(frames, INITIAL_VALUE); + + capture->control.Stop((AudioHandle)capture); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +} \ No newline at end of file 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 new file mode 100755 index 0000000000000000000000000000000000000000..e02d79af7ad7bb1fd7b87f62588b8f1408e0b5ad --- /dev/null +++ b/audio/test/systemtest/hdi/capture/src/audio_hdicapture_volume_test.cpp @@ -0,0 +1,1026 @@ +/* + * 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 Defines audio-related APIs, including custom data types and functions for capture drivers funtion. + * accessing a driver adapter, and capturing audios. + * + * @since 1.0 + * @version 1.0 + */ + +/** + * @file audio_hdi_common.h + * + * @brief Declares APIs for operations related to the capturing audio adapter. + * + * @since 1.0 + * @version 1.0 + */ + +#include "audio_hdi_common.h" +#include "audio_hdicapture_volume_test.h" + +using namespace std; +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"; + +class AudioHdiCaptureVolumeTest : public testing::Test { +public: + static void SetUpTestCase(void); + 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; +}; + +void AudioHdiCaptureVolumeTest::SetUpTestCase(void) {} + +void AudioHdiCaptureVolumeTest::TearDownTestCase(void) {} + +void AudioHdiCaptureVolumeTest::SetUp(void) +{ + char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; + handleSo = dlopen(resolvedPath, RTLD_LAZY); + if (handleSo == nullptr) { + return; + } + GetAudioManager = (struct AudioManager *(*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); + if (GetAudioManager == 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]; + } + } + 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 AudioHdiCaptureVolumeTest::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 || adapter->CreateCapture == nullptr || capture == nullptr) { + return HDF_FAILURE; + } + ret = InitAttrs(attrs); + if (ret < 0) { + return HDF_FAILURE; + } + ret = InitDevDesc(devDesc, capturePort.portId, pins); + if (ret < 0) { + return HDF_FAILURE; + } + ret = adapter->CreateCapture(adapter, &devDesc, &attrs, capture); + if (ret < 0 || *capture == nullptr) { + manager.UnloadAdapter(&manager, adapter); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHdiCaptureVolumeTest::AudioCaptureStart(const string path, struct AudioCapture *capture) const +{ + int32_t ret = -1; + struct AudioSampleAttributes attrs = {}; + if (capture == nullptr) { + return HDF_FAILURE; + } + 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; +} + +/** +* @tc.name Test AudioCaptureSetMute API via legal input. +* @tc.number SUB_Audio_HDI_AudioCaptureSetMute_0001 +* @tc.desc Test AudioCaptureSetMute interface , return 0 if the audiocapture object sets mute successfully. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_HDI_AudioCaptureSetMute_0001, TestSize.Level1) +{ + 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); + 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); + + ret = capture->volume.GetMute(capture, &muteTrue); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_TRUE(muteTrue); + + ret = capture->volume.SetMute(capture, muteFalse); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = capture->volume.GetMute(capture, &muteFalse); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_FALSE(muteFalse); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureSetMute API via setting the capture is empty . +* @tc.number SUB_Audio_HDI_AudioCaptureSetMute_0002 +* @tc.desc Test AudioCaptureSetMute interface, return -1 if the capture is empty. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_HDI_AudioCaptureSetMute_0002, TestSize.Level1) +{ + 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); + 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); + + ret = capture->volume.SetMute(captureNull, muteFalse); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureSetMute API,when the parameter mutevalue equals 2. +* @tc.number SUB_Audio_HDI_AudioCaptureSetMute_0003 +* @tc.desc Test AudioCaptureSetMute interface and set the parameter mutevalue with 2. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_HDI_AudioCaptureSetMute_0003, TestSize.Level1) +{ + 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); + 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); + + ret = capture->volume.GetMute(capture, &muteValue); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_TRUE(muteValue); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureGetMute API via legal input. +* @tc.number SUB_Audio_HDI_AudioCaptureGetMute_0001 +* @tc.desc Test AudioCaptureGetMute interface , return 0 if the audiocapture gets mute successfully. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_HDI_AudioCaptureGetMute_0001, TestSize.Level1) +{ + 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); + 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); + + ret = capture->volume.SetMute(capture, muteFalse); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = capture->volume.GetMute(capture, &muteFalse); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_FALSE(muteFalse); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test interface AudioCaptureGetMute when capture is empty. +* @tc.number SUB_Audio_HDI_AudioCaptureGetMute_0002 +* @tc.desc Test AudioCreateCapture interface, return -1 if the capture is empty. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_HDI_AudioCaptureGetMute_0002, TestSize.Level1) +{ + 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); + 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); + + ret = capture->volume.GetMute(captureNull, &muteFalse); + EXPECT_EQ(HDF_FAILURE, ret); + + ret = capture->volume.GetMute(capture, nullptr); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureSetVolume API via legal input. +* @tc.number SUB_Audio_HDI_AudioCaptureSetVolume_0001 +* @tc.desc Test AudioCaptureSetVolume interface , return 0 if the audiocapture sets volume successfully. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_HDI_AudioCaptureSetVolume_0001, TestSize.Level1) +{ + int32_t ret = -1; + float volumeInit = 0.30; + float volumeInitExpc = 0.30; + 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 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); + 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); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(volumeInitExpc, volumeInit); + ret = capture->volume.SetVolume(capture, volumeLow); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->volume.GetVolume(capture, &volumeLow); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(volumeLowExpc, volumeLow); + ret = capture->volume.SetVolume(capture, volumeMid); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->volume.GetVolume(capture, &volumeMid); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(volumeMidExpc, volumeMid); + ret = capture->volume.SetVolume(capture, volumeHigh); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->volume.GetVolume(capture, &volumeHigh); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(volumeHighExpc, volumeHigh); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureSetVolume,when volume is set maximum value or minimum value. +* @tc.number SUB_Audio_HDI_AudioCaptureSetVolume_0002 +* @tc.desc Test AudioCaptureSetVolume,return 0 if volume is set maximum value or minimum value. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_HDI_AudioCaptureSetVolume_0002, TestSize.Level1) +{ + int32_t ret = -1; + float volumeMin = 0; + float volumeMinExpc = 0; + float volumeMax = 1.0; + float volumeMaxExpc = 1.0; + float volumeMinBoundary = -1; + float volumeMaxBoundary = 1.1; + struct AudioPort capturePort = {}; + struct AudioAdapter *adapter = {}; + 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); + 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); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(volumeMinExpc, volumeMin); + + ret = capture->volume.SetVolume(capture, volumeMax); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->volume.GetVolume(capture, &volumeMax); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(volumeMaxExpc, volumeMax); + + ret = capture->volume.SetVolume(capture, volumeMinBoundary); + EXPECT_EQ(HDF_FAILURE, ret); + + ret = capture->volume.SetVolume(capture, volumeMaxBoundary); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureSetVolume,when capture is empty. +* @tc.number SUB_Audio_HDI_AudioCaptureSetVolume_0003 +* @tc.desc Test AudioCaptureSetVolume,return -1 when capture is empty. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_HDI_AudioCaptureSetVolume_0003, TestSize.Level1) +{ + int32_t ret = -1; + float volume = 0; + struct AudioPort capturePort = {}; + struct AudioAdapter *adapter = {}; + 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); + 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); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureGetVolume API via legal input. +* @tc.number SUB_Audio_HDI_AudioCaptureGetVolume_001 +* @tc.desc Test AudioCaptureGetVolume interface , return 0 if the audiocapture is get successful. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_HDI_AudioCaptureGetVolume_001, TestSize.Level1) +{ + 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 AudioCapture *capture = nullptr; + struct AudioManager manager = *GetAudioManager(); + ASSERT_NE(nullptr, GetAudioManager); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(defaultVolume, volume); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureGetVolume when when capturing is in progress. +* @tc.number SUB_Audio_HDI_AudioCaptureGetVolume_002. +* @tc.desc Test AudioCaptureGetVolume,return 0 when when capturing is in progress. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_HDI_AudioCaptureGetVolume_002, TestSize.Level1) +{ + 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 AudioCapture *capture = nullptr; + struct AudioManager manager = *GetAudioManager(); + ASSERT_NE(nullptr, GetAudioManager); + + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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->volume.SetVolume(capture, volume); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->volume.GetVolume(capture, &volume); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(defaultVolume, volume); + + ret = capture->control.Stop((AudioHandle)capture); + EXPECT_EQ(HDF_SUCCESS, ret); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureGetVolume,when capture is empty. +* @tc.number SUB_Audio_HDI_AudioCaptureGetVolume_0003 +* @tc.desc Test AudioCaptureGetVolume,return -1 when capture is empty. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiCaptureVolumeTest, SUB_Audio_HDI_AudioCaptureGetVolume_0003, TestSize.Level1) +{ + 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 AudioCapture *capture = nullptr; + struct AudioCapture *captureNull = nullptr; + struct AudioManager manager = *GetAudioManager(); + + ASSERT_NE(nullptr, GetAudioManager); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureGetGainThreshold API via legal input +* @tc.number SUB_Audio_hdi_CaptureGetGainThreshold_0001 +* @tc.desc test AudioCaptureGetGainThreshold interface, return 0 is call successfully. +* @tc.author: liweiming +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + EXPECT_EQ(min, GAIN_MIN); + EXPECT_EQ(max, GAIN_MAX); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureGetGainThreshold API via setting the incoming parameter handle is nullptr +* @tc.number SUB_Audio_hdi_CaptureGetGainThreshold_0002 +* @tc.desc test AudioCaptureGetGainThreshold interface, return -1 if the incoming parameter handle is nullptr. +* @tc.author: liweiming +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureGetGainThreshold API via setting the incoming parameter min is nullptr +* @tc.number SUB_Audio_hdi_CaptureGetGainThreshold_0003 +* @tc.desc test AudioCaptureGetGainThreshold interface, return -1 if the incoming parameter min is nullptr. +* @tc.author: liweiming +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureGetGainThreshold API via setting the incoming parameter max is nullptr +* @tc.number SUB_Audio_hdi_CaptureGetGainThreshold_0004 +* @tc.desc test AudioCaptureGetGainThreshold interface, return -1 if the incoming parameter max is nullptr. +* @tc.author: liweiming +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureSetGain API via legal input +* @tc.number SUB_Audio_hdi_CaptureSetGain_0001 +* @tc.desc test AudioCaptureSetGain interface, return 0 is call successfully. +* @tc.author: tiansuli +*/ +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; + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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; + float gainMax = max; + float gainMin = min; + float gainExpc = max - 1; + float gainMaxExpc = max; + float gainMinExpc = min; + ret = capture->volume.SetGain((AudioHandle)capture, gainMax); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->volume.GetGain((AudioHandle)capture, &gainMax); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(gainMaxExpc, gainMax); + + ret = capture->volume.SetGain((AudioHandle)capture, gainMin); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->volume.GetGain((AudioHandle)capture, &gainMin); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(gainMinExpc, gainMin); + + ret = capture->volume.SetGain((AudioHandle)capture, gain); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->volume.GetGain((AudioHandle)capture, &gain); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(gainExpc, gain); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureSetGain API via setting gain greater than the maximum and less than the minimum +* @tc.number SUB_Audio_hdi_CaptureSetGain_0002 +* @tc.desc test AudioCaptureSetGain interface, return -1 if gain greater than the maximum and less than the minimum +* @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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 gainOne = max+1; + float gainSec = min-1; + ret = capture->volume.SetGain((AudioHandle)capture, gainOne); + EXPECT_EQ(HDF_FAILURE, ret); + + ret = capture->volume.SetGain((AudioHandle)capture, gainSec); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureSetGain API via setting the incoming parameter handle is nullptr. +* @tc.number SUB_Audio_hdi_CaptureSetGain_0006 +* @tc.desc test AudioCaptureSetGain interface, return -1 if the incoming parameter handle is nullptr. +* @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureGetGain API via legal input +* @tc.number SUB_Audio_hdi_CaptureGetGain_0001 +* @tc.desc test AudioCaptureGetGain interface, return 0 if CaptureGetGain is call successfully. +* @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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 = min+1; + float gainValue = min+1; + ret = capture->volume.SetGain((AudioHandle)capture, gain); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = capture->volume.GetGain((AudioHandle)capture, &gain); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(gainValue, gain); + + capture->control.Stop((AudioHandle)capture); + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureGetGain API via setting the incoming parameter handle is nullptr +* @tc.number SUB_Audio_hdi_CaptureGetGain_0002 +* @tc.desc test AudioCaptureGetGain interface, return -1 if the incoming parameter handle is nullptr. +* @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureGetGain API via legal input in difference scenes +* @tc.number SUB_Audio_hdi_CaptureGetGain_0003 +* @tc.desc test AudioCaptureGetGain interface, return 0 if get gain after creating the capture object. +* @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + ret = capture->volume.GetGain((AudioHandle)capture, &gain); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(gainOne, gain); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioCaptureGetGain API via setting the parameter gain is nullptr +* @tc.number SUB_Audio_hdi_CaptureGetGain_0004 +* @tc.desc test AudioCaptureGetGain interface, return -1 if the parameter gain is nullptr. +* @tc.author: tiansuli +*/ +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; + float *gainNull = nullptr; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, portType, ADAPTER_NAME2, &adapter, capturePort); + 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); + + adapter->DestroyCapture(adapter, capture); + manager.UnloadAdapter(&manager, adapter); +} +} \ No newline at end of file diff --git a/audio/test/systemtest/hdi/hdireliability/BUILD.gn b/audio/test/systemtest/hdi/hdireliability/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..2d256586887f06b9cc2107b15dd6d4ee73c8e5e6 --- /dev/null +++ b/audio/test/systemtest/hdi/hdireliability/BUILD.gn @@ -0,0 +1,98 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//drivers/adapter/uhdf2/uhdf.gni") + +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" + ] + + 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/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########################### \ No newline at end of file diff --git a/audio/test/systemtest/hdi/hdireliability/include/audio_hdicapture_reliability_test.h b/audio/test/systemtest/hdi/hdireliability/include/audio_hdicapture_reliability_test.h new file mode 100755 index 0000000000000000000000000000000000000000..fa73112ca464a77c989f2a8ebac6a91890a05f9e --- /dev/null +++ b/audio/test/systemtest/hdi/hdireliability/include/audio_hdicapture_reliability_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_RELIABILITY_TEST_H +#define AUDIO_HDICAPTURE_RELIABILITY_TEST_H + +#endif diff --git a/audio/test/systemtest/hdi/hdireliability/include/audio_hdirender_reliability_test.h b/audio/test/systemtest/hdi/hdireliability/include/audio_hdirender_reliability_test.h new file mode 100755 index 0000000000000000000000000000000000000000..a26c753247ca52a696e4f7924dcb7a612a1f2194 --- /dev/null +++ b/audio/test/systemtest/hdi/hdireliability/include/audio_hdirender_reliability_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_RELIABILITY_TEST_H +#define AUDIO_HDIRENDER_RELIABILITY_TEST_H + +#endif 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 new file mode 100755 index 0000000000000000000000000000000000000000..ccaf88ba0cb0966b1f48309609c08f2ce97fcad7 --- /dev/null +++ b/audio/test/systemtest/hdi/hdireliability/src/audio_hdicapture_reliability_test.cpp @@ -0,0 +1,1683 @@ +/* + * 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_hdi_common.h" +#include +#include "audio_hdicapture_reliability_test.h" + +using namespace std; +using namespace testing::ext; +using namespace HMOS::Audio; + +namespace { +const string AUDIO_FILE = "//bin/audiocapturetest.wav"; +const string AUDIO_FILE_LOG = "//bin/14031.wav"; +const string AUDIO_FILE_ERR = "//bin/test.txt"; +const string ADAPTER_NAME = "hdmi"; +const string ADAPTER_NAME2 = "usb"; +const string ADAPTER_NAME3 = "internal"; +const int PTHREAD_SAMEADA_COUNT = 3; +const int PTHREAD_DIFFADA_COUNT = 2; +const int BUFFER_SIZE = 16384; + +class AudioHdiCaptureReliabilityTest : public testing::Test { +public: + static void SetUpTestCase(void); + 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 RelAudioDestroyCapture(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 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 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 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 RelAudioCaptureGetCapturePosition(struct RelCaptureAdapterPara &ptr); +}; + +using THREAD_FUNC = void *(*)(void *); + +void AudioHdiCaptureReliabilityTest::SetUpTestCase(void) {} + +void AudioHdiCaptureReliabilityTest::TearDownTestCase(void) {} + +void AudioHdiCaptureReliabilityTest::SetUp(void) +{ + char resolvedPath[] = "//system/lib/libhdi_audio.z.so"; + handleSo = dlopen(resolvedPath, RTLD_LAZY); + if (handleSo == nullptr) { + cout << "Open Error:" << dlerror() << endl; + return; + } + GetAudioManager = (struct AudioManager* (*)())(dlsym(handleSo, "GetAudioManagerFuncs")); + if (GetAudioManager == nullptr) { + cout << "Dlsym Error: " << dlerror() << endl; + return; + } +} + +void AudioHdiCaptureReliabilityTest::TearDown(void) +{ + 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; + uint64_t getframes; + uint32_t getcurrentchannelId; +}; + +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}; +}; + +int32_t AudioHdiCaptureReliabilityTest::RelGetAllAdapter(struct RelCaptureAdapterPara& ptr) +{ + int size = 0; + auto *inst = (AudioHdiCaptureReliabilityTest *)ptr.param; + if (inst != nullptr && inst->GetAudioManager != nullptr) { + ptr.manager = inst->GetAudioManager(); + } + if (ptr.manager == nullptr) { + return HDF_FAILURE; + } + ptr.manager->GetAllAdapters(ptr.manager, &ptr.descs, &size); + if (ptr.descs == nullptr || size == 0) { + return HDF_FAILURE; + } else { + int index = HMOS::Audio::SwitchAdapter(ptr.descs, ptr.adapterName, ptr.portType, ptr.capturePort, size); + if (index < 0) { + return HDF_FAILURE; + } else { + ptr.desc = &ptr.descs[index]; + } + } + return HDF_SUCCESS; +} + +int32_t AudioHdiCaptureReliabilityTest::RelLoadAdapter(struct RelCaptureAdapterPara& ptr) +{ + if (ptr.desc == nullptr) { + return HDF_FAILURE; + } else { + ptr.manager->LoadAdapter(ptr.manager, ptr.desc, &ptr.adapter); + } + if (ptr.adapter == nullptr) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHdiCaptureReliabilityTest::RelAudioCreateCapture(struct RelCaptureAdapterPara& ptr) +{ + int32_t ret = -1; + struct AudioSampleAttributes attrs = {}; + struct AudioDeviceDescriptor devDesc = {}; + if (ptr.adapter == nullptr || ptr.manager == nullptr) { + return HDF_FAILURE; + } + ret = HMOS::Audio::InitAttrs(attrs); + if (ret < 0) { + return HDF_FAILURE; + } + ret = HMOS::Audio::InitDevDesc(devDesc, (&ptr.capturePort)->portId, ptr.pins); + if (ret < 0) { + return HDF_FAILURE; + } + ret = ptr.adapter->CreateCapture(ptr.adapter, &devDesc, &attrs, &ptr.capture); + if (ret < 0 || ptr.capture == nullptr) { + ptr.manager->UnloadAdapter(ptr.manager, ptr.adapter); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHdiCaptureReliabilityTest::RelAudioDestroyCapture(struct RelCaptureAdapterPara& ptr) +{ + int32_t ret = -1; + if (ptr.adapter == nullptr || ptr.manager == nullptr) { + return HDF_FAILURE; + } + ret = ptr.adapter->DestroyCapture(ptr.adapter, ptr.capture); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureStart(struct RelCaptureAdapterPara& ptr) +{ + int32_t ret = -1; + ret = ptr.capture->control.Start((AudioHandle)(ptr.capture)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureFrame(struct RelCaptureAdapterPara& ptr) +{ + int32_t ret = -1; + uint64_t requestBytes = BUFFER_SIZE; + uint64_t replyBytes = 0; + + char *frame = (char *)calloc(1, BUFFER_SIZE); + if (frame == nullptr) { + return HDF_FAILURE; + } + + ret = ptr.capture->CaptureFrame(ptr.capture, frame, requestBytes, &replyBytes); + if (ret < 0) { + free(frame); + frame = nullptr; + return HDF_FAILURE; + } + free(frame); + frame = nullptr; + return HDF_SUCCESS; +} + +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureStartAndCaputreFrame(struct RelCaptureAdapterPara& ptr) +{ + int32_t ret = -1; + struct AudioSampleAttributes attrs = {}; + FILE *file = fopen(ptr.path, "wb+"); + if (file == nullptr) { + return HDF_FAILURE; + } + ret = InitAttrs(attrs); + if (ret < 0) { + fclose(file); + return HDF_FAILURE; + } + + ret = FrameStartCapture(ptr.capture, file, attrs); + if (ret < 0) { + fclose(file); + return HDF_FAILURE; + } + fclose(file); + return HDF_SUCCESS; +} + +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureStop(struct RelCaptureAdapterPara& ptr) +{ + int32_t ret = -1; + ret = ptr.capture->control.Stop((AudioHandle)(ptr.capture)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHdiCaptureReliabilityTest::RelAudioCapturePause(struct RelCaptureAdapterPara& ptr) +{ + int32_t ret = -1; + ret = ptr.capture->control.Pause((AudioHandle)(ptr.capture)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureResume(struct RelCaptureAdapterPara& ptr) +{ + int32_t ret = -1; + ret = ptr.capture->control.Resume((AudioHandle)(ptr.capture)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSetMute(struct RelCaptureAdapterPara& ptr) +{ + int32_t ret = -1; + ret = ptr.capture->volume.SetMute(ptr.capture, ptr.character.setmute); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetMute(struct RelCaptureAdapterPara& ptr) +{ + int32_t ret = -1; + ret = ptr.capture->volume.GetMute(ptr.capture, &(ptr.character.getmute)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSetVolume(struct RelCaptureAdapterPara& ptr) +{ + int32_t ret = -1; + ret = ptr.capture->volume.SetVolume(ptr.capture, ptr.character.setvolume); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetVolume(struct RelCaptureAdapterPara& ptr) +{ + int32_t ret = -1; + ret = ptr.capture->volume.GetVolume(ptr.capture, &(ptr.character.getvolume)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureProcedure(struct RelCaptureAdapterPara& ptr) +{ + int32_t ret = -1; + ret = RelGetAllAdapter(ptr); + if (ret < 0) { + return HDF_FAILURE; + } + + ret = RelLoadAdapter(ptr); + if (ret < 0) { + return HDF_FAILURE; + } + + ret = RelAudioCreateCapture(ptr); + if (ret < 0) { + return HDF_FAILURE; + } + + ret = RelAudioCaptureStartAndCaputreFrame(ptr); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHdiCaptureReliabilityTest::RelAudioAdapterInitAllPorts(struct RelCaptureAdapterPara& ptr) +{ + int32_t ret = -1; + if (ptr.adapter == nullptr) { + return HDF_FAILURE; + } + ret = ptr.adapter->InitAllPorts(ptr.adapter); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHdiCaptureReliabilityTest::RelAudioAdapterGetPortCapability(struct RelCaptureAdapterPara& ptr) +{ + int32_t ret = -1; + if (ptr.adapter == nullptr) { + return HDF_FAILURE; + } + ret = ptr.adapter->GetPortCapability(ptr.adapter, &(ptr.capturePort), &(ptr.capability)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHdiCaptureReliabilityTest::RelAudioAdapterSetPassthroughMode(struct RelCaptureAdapterPara& ptr) +{ + int32_t ret = -1; + if (ptr.adapter == nullptr) { + return HDF_FAILURE; + } + ret = ptr.adapter->SetPassthroughMode(ptr.adapter, &(ptr.capturePort), ptr.mode); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHdiCaptureReliabilityTest::RelAudioAdapterGetPassthroughMode(struct RelCaptureAdapterPara& ptr) +{ + int32_t ret = -1; + if (ptr.adapter == nullptr) { + return HDF_FAILURE; + } + ret = ptr.adapter->GetPassthroughMode(ptr.adapter, &(ptr.capturePort), &(ptr.mode)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** + * @brief Resume audio Captureing. + * + * @param struct RelCaptureAdapterPara + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise + */ +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetGainThreshold(struct RelCaptureAdapterPara &ptr) +{ + int32_t ret = -1; + ret = ptr.capture->volume.GetGainThreshold(ptr.capture, &(ptr.character.gainthresholdmin), + &(ptr.character.gainthresholdmax)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** + * @brief Resume audio Captureing. + * + * @param struct RelCaptureAdapterPara + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise + */ +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSetGain(struct RelCaptureAdapterPara &ptr) +{ + int32_t ret = -1; + ret = ptr.capture->volume.SetGain(ptr.capture, ptr.character.setgain); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** + * @brief Resume audio Captureing. + * + * @param struct RelCaptureAdapterPara + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise + */ +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetGain(struct RelCaptureAdapterPara &ptr) +{ + int32_t ret = -1; + ret = ptr.capture->volume.GetGain(ptr.capture, &(ptr.character.getgain)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** + * @brief Resume audio Captureing. + * + * @param struct RelCaptureAdapterPara + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise + */ +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetFrameSize(struct RelCaptureAdapterPara &ptr) +{ + int32_t ret = -1; + ret = ptr.capture->attr.GetFrameSize(ptr.capture, &(ptr.character.getframesize)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** + * @brief Resume audio Captureing. + * + * @param struct RelCaptureAdapterPara + * + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise + */ +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetFrameCount(struct RelCaptureAdapterPara &ptr) +{ + int32_t ret = -1; + ret = ptr.capture->attr.GetFrameCount(ptr.capture, &(ptr.character.getframecount)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** + * @brief Resume audio Captureing. + * + * @param struct RelCaptureAdapterPara + * + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise + */ +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetCurrentChannelId(struct RelCaptureAdapterPara &ptr) +{ + int32_t ret = -1; + ret = ptr.capture->attr.GetCurrentChannelId(ptr.capture, &(ptr.character.getcurrentchannelId)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** + * @brief Resume audio Captureing. + * + * @param struct RelCaptureAdapterPara + * + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise + */ +int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetCapturePosition(struct RelCaptureAdapterPara &ptr) +{ + int32_t ret = -1; + ret = ptr.capture->GetCapturePosition(ptr.capture, &(ptr.character.getframes), &(ptr.time)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** +* @tc.name RelAudioCreateCapture API via The passed in adaptername is the differentt +* @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 +*/ +HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCreateCapture_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); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCreateCapture, ¶[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); + ret = (intptr_t)result; + 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 RelAudioDestroyCapture API via The passed in adaptername is the different +* @tc.number SUB_Audio_HDI_AudioCaptureStart_Reliability_0002 +* @tc.desc test AudioCaptureStart interface,Returns 0 if the AudioCapture object is destroyed +* @tc.author: wangkang +*/ +HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioDestroyCapture_Reliability_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct RelCaptureAdapterPara 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_NAME3.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); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioDestroyCapture, ¶[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); + para[i].manager->UnloadAdapter(para[i].manager, para[i].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(AudioHdiCaptureReliabilityTest, 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); + } + for (int32_t i = 0; i < PTHREAD_DIFFADA_COUNT; ++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].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 RelAudioCaptureStart API via The passed in adaptername is the differentt +* @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 +*/ + +HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureStart_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); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureStart, ¶[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); + 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 RelAudioCaptureStop API via The passed in adaptername is the differentt +* @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 +*/ + +HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureStop_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); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureStop, ¶[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); + ret = (intptr_t)result; + 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 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(AudioHdiCaptureReliabilityTest, 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); + int32_t 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; + int32_t ret = -1; + 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 +* @tc.desc test InitAllPorts interface, return 0 if the ports is initialize successfully. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioInitAllPorts_Reliability_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct RelCaptureAdapterPara 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_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); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioAdapterInitAllPorts, ¶[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); + ret = (intptr_t)result; + EXPECT_EQ(HDF_SUCCESS, ret); + para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); + } +} + +/** +* @tc.name test RelAudioAdapterInitAllPorts API via Multi thread calling mono card +* @tc.number SUB_Audio_HDI_AudioInitAllPorts_Reliability_0002 +* @tc.desc test InitAllPorts interface, return 0 if the ports is initialize successfully. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCaptureReliabilityTest, 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 RelCaptureAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + + pthread_t tids[PTHREAD_SAMEADA_COUNT]; + for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { + ret = RelGetAllAdapter(para); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = RelLoadAdapter(para); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = memcpy_s(&arrpara[i], sizeof(RelCaptureAdapterPara), ¶, sizeof(RelCaptureAdapterPara)); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioAdapterInitAllPorts, &arrpara[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + } + for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { + void *result = nullptr; + int32_t ret = -1; + pthread_join(tids[i], &result); + ret = (intptr_t)result; + EXPECT_EQ(HDF_SUCCESS, ret); + arrpara[i].manager->UnloadAdapter(arrpara[i].manager, arrpara[i].adapter); + } +} + +/** +* @tc.name test RelAudioAdapterGetPortCapability API via Multi thread calling multi sound card +* @tc.number SUB_Audio_HDI_AudioGetPortCapability_Reliability_0001 +* @tc.desc test GetPortCapability interface,return 0 if the Get Port capability successfully. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioGetPortCapability_Reliability_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct RelCaptureAdapterPara 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_NAME3.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 = RelAudioAdapterInitAllPorts(para[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioAdapterGetPortCapability, ¶[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].manager->UnloadAdapter(para[i].manager, para[i].adapter); + } +} + +/** +* @tc.name test RelAudioAdapterGetPortCapability API via Multi thread calling mono card +* @tc.number SUB_Audio_HDI_AudioGetPortCapability_Reliability_0002 +* @tc.desc test GetPortCapability interface,return 0 if the Get Port capability successfully. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCaptureReliabilityTest, 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 RelCaptureAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + + pthread_t tids[PTHREAD_SAMEADA_COUNT]; + for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { + ret = RelGetAllAdapter(para); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = RelLoadAdapter(para); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = RelAudioAdapterInitAllPorts(para); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = memcpy_s(&arrpara[i], sizeof(RelCaptureAdapterPara), ¶, sizeof(RelCaptureAdapterPara)); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioAdapterGetPortCapability, &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); + arrpara[i].manager->UnloadAdapter(arrpara[i].manager, arrpara[i].adapter); + } +} + +/** +* @tc.name test RelAudioAdapterSetPassthroughMode API via Multi thread calling multi sound card +* @tc.number SUB_Audio_HDI_AudioSetPassthroughMode_Reliability_0001 +* @tc.desc test SetPassthroughMode interface,return 0 if the Set Passthrough Mode successfully. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioSetPassthroughMode_Reliability_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct RelCaptureAdapterPara 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_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, + .path = AUDIO_FILE.c_str(), .mode = PORT_PASSTHROUGH_LPCM + } + }; + + 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 = RelAudioAdapterInitAllPorts(para[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioAdapterSetPassthroughMode, ¶[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); + ret = (intptr_t)result; + EXPECT_EQ(HDF_SUCCESS, ret); + ret = para[i].adapter->GetPassthroughMode(para[i].adapter, &(para[i].capturePort), &(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); + } +} + +/** +* @tc.name test RelAudioAdapterSetPassthroughMode API via Multi thread calling mono card +* @tc.number SUB_Audio_HDI_AudioSetPassthroughMode_Reliability_0002 +* @tc.desc test SetPassthroughMode interface,return 0 if the Set Passthrough Mode successfully. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCaptureReliabilityTest, 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 RelCaptureAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + pthread_t tids[PTHREAD_SAMEADA_COUNT]; + for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { + ret = RelGetAllAdapter(para); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = RelLoadAdapter(para); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = RelAudioAdapterInitAllPorts(para); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = memcpy_s(&arrpara[i], sizeof(RelCaptureAdapterPara), ¶, sizeof(RelCaptureAdapterPara)); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioAdapterSetPassthroughMode, &arrpara[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + } + for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { + void *result = nullptr; + int32_t ret = -1; + 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)); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(PORT_PASSTHROUGH_LPCM, arrpara[i].mode); + arrpara[i].manager->UnloadAdapter(arrpara[i].manager, arrpara[i].adapter); + } +} + +/** +* @tc.name test RelAudioAdapterGetPassthroughMode API via Multi thread calling multi sound card +* @tc.number SUB_Audio_HDI_AudioGetPassthroughMode_Reliability_0001 +* @tc.desc test GetPassthroughMode interface,return 0 if the Get Passthrough Mode successfully. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioGetPassthroughMode_Reliability_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct RelCaptureAdapterPara 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_NAME2.c_str(), .param = this, .pins = PIN_IN_MIC, + .path = AUDIO_FILE.c_str(), .mode = PORT_PASSTHROUGH_LPCM + } + }; + 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 = RelAudioAdapterInitAllPorts(para[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = RelAudioAdapterSetPassthroughMode(para[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioAdapterGetPassthroughMode, ¶[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); + ret = (intptr_t)result; + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(PORT_PASSTHROUGH_LPCM, para[i].mode); + para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); + } +} + +/** +* @tc.name test RelAudioAdapterGetPassthroughMode API via Multi thread calling mono card +* @tc.number SUB_Audio_HDI_AudioGetPassthroughMode_Reliability_0002 +* @tc.desc test GetPassthroughMode interface,return 0 if the Get Passthrough Mode successfully. +* @tc.author: liutian +*/ +HWTEST_F(AudioHdiCaptureReliabilityTest, 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 RelCaptureAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + pthread_t tids[PTHREAD_SAMEADA_COUNT]; + for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { + ret = RelGetAllAdapter(para); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = RelLoadAdapter(para); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = RelAudioAdapterInitAllPorts(para); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = memcpy_s(&arrpara[i], sizeof(RelCaptureAdapterPara), ¶, sizeof(RelCaptureAdapterPara)); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = RelAudioAdapterSetPassthroughMode(arrpara[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioAdapterGetPassthroughMode, &arrpara[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + } + for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { + void *result = nullptr; + int32_t ret = -1; + pthread_join(tids[i], &result); + ret = (intptr_t)result; + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(PORT_PASSTHROUGH_LPCM, arrpara[i].mode); + arrpara[i].manager->UnloadAdapter(arrpara[i].manager, arrpara[i].adapter); + } +} + +/** +* @tc.name test AudioCaptureResume API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioCaptureResume_Reliability_0002 +* @tc.desc test CaptureResume interface Reliability pass through pthread_create fun and adapterName is different. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureResume_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 = RelAudioCapturePause(para[i]); + ASSERT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureResume, ¶[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].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 AudioCaptureSetGain API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioCaptureSetGain_Reliability_0001 +* @tc.desc test AudioCaptureSetGain interface Reliability pass through pthread_create fun and adapterName is same. +* @tc.author: zhouyongxiao +*/ +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 RelCaptureAdapterPara 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)); + EXPECT_EQ(HDF_SUCCESS, ret); + arrpara[i].character.setgain = 2; + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureSetGain, &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 = arrpara[i].capture->volume.GetGain(arrpara[i].capture, &(arrpara[i].character.getgain)); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(2, 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); +} +/** +* @tc.name test AudioCaptureSetVolume API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioCaptureSetGain_Reliability_0002 +* @tc.desc test SetGain interface Reliability pass through pthread_create fun and adapterName is different. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSetGain_Reliability_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct RelCaptureAdapterPara 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_NAME3.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); + para[i].character.setgain = 15; + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureSetGain, ¶[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); + ret = (intptr_t)result; + EXPECT_EQ(HDF_SUCCESS, ret); + 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)); + 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 AudioCaptureGetGain API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioCaptureGetGain_Reliability_0001 +* @tc.desc test AudioCaptureGetGain interface Reliability pass through pthread_create fun and adapterName is same. +* @tc.author: zhouyongxiao +*/ +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 RelCaptureAdapterPara 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)); + 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); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetGain, &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(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); +} +/** +* @tc.name test AudioCaptureGetGain API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioCaptureGetGain_Reliability_0002 +* @tc.desc test GetGain interface Reliability pass through pthread_create fun and adapterName is different. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetGain_Reliability_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct RelCaptureAdapterPara 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_NAME3.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); + para[i].character.setgain = 15; + ret = para[i].capture->volume.SetGain(para[i].capture, para[i].character.setgain); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetGain, ¶[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); + EXPECT_LT(INITIAL_VALUE, para[i].character.getgain); + 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 AudioCaptureGetGainThreshold API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioCaptureGetGainThreshold_Reliability_0001 +* @tc.desc test GetGainThreshold interface Reliability pass through pthread_create fun and adapterName is same. +* @tc.author: zhouyongxiao +*/ +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 RelCaptureAdapterPara 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)); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetGainThreshold, &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); + } + 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); +} +/** +* @tc.name test AudioCaptureGetGainThreshold API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioCaptureGetGainThreshold_Reliability_0002 +* @tc.desc test GetGainThreshold interface Reliability pass through pthread_create fun and adapterName is different. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetGainThreshold_Reliability_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct RelCaptureAdapterPara 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_NAME3.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); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetGainThreshold, ¶[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); + 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); + } +} +/** +* @tc.name test AudioCaptureGetFrameSize API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioCaptureGetFrameSize_Reliability_0001 +* @tc.desc test AudioCaptureGetFrameSize interface Reliability pass through pthread_create fun and adapterName is same +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetFrameSize_Reliability_0001, TestSize.Level1) +{ + 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 RelCaptureAdapterPara 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)); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetFrameSize, &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(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); +} +/** +* @tc.name test AudioCaptureGetFrameSize API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioCaptureGetFrameSize_Reliability_0002 +* @tc.desc test GetFrameSize interface Reliability pass through pthread_create fun and adapterName is different. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetFrameSize_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); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetFrameSize, ¶[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); + 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); + } +} +/** +* @tc.name test AudioCaptureGetFrameCount API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioCaptureGetFrameCount_Reliability_0001 +* @tc.desc test CaptureGetFrameCount interface Reliability pass through pthread_create fun and adapterName is same +* @tc.author: zhouyongxiao +*/ +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 RelCaptureAdapterPara 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)); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetFrameCount, &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(INITIAL_VALUE, arrpara[i].character.getframecount); + } + 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); +} +/** +* @tc.name test AudioCaptureGetFrameCount API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioCaptureGetFrameCount_Reliability_0002 +* @tc.desc test GetFrameCount interface Reliability pass through pthread_create fun and adapterName is different. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetFrameCount_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); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetFrameCount, ¶[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); + EXPECT_LT(INITIAL_VALUE, para[i].character.getframecount); + + 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 AudioGetCapturePosition API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioGetCapturePosition_Reliability_0001 +* @tc.desc test AudioGetCapturePosition interface Reliability pass through pthread_create fun and adapterName is same. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioGetCapturePosition_Reliability_0001, TestSize.Level1) +{ + 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 RelCaptureAdapterPara 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)); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetCapturePosition, &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(INITIAL_VALUE, arrpara[i].character.getframes); + EXPECT_LT(timeExp, arrpara[i].time.tvNSec); + } + 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); +} +/** +* @tc.name test AudioCaptureGetCapturePosition API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_Reliability_0002 +* @tc.desc test GetCapturePosition interface Reliability pass through pthread_create fun and adapterName is different +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_Reliability_0002, TestSize.Level1) +{ + int32_t ret = -1; + int64_t timeExp = 0; + 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); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetCapturePosition, ¶[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); + 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); + } +} +/** +* @tc.name test AudioGetCurrentChannelId API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioGetCurrentChannelId_Reliability_0001 +* @tc.desc test AudioGetCurrentChannelId interface Reliability pass through pthread_create fun and adapterName is same +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioGetCurrentChannelId_Reliability_0001, TestSize.Level1) +{ + 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 RelCaptureAdapterPara 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)); + EXPECT_EQ(HDF_SUCCESS, ret); + arrpara[i].character.getcurrentchannelId = 0; + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetCurrentChannelId, &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(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); +} +/** +* @tc.name test AudioCaptureGetCurrentChannelId API via Multithread call. +* @tc.number SUB_Audio_HDI_CaptureGetCurrentChannelId_Reliability_0002 +* @tc.desc test GetCurrentChannelId interface Reliability pass through pthread_create fun and adapterName is different +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_CaptureGetCurrentChannelId_Reliability_0002, TestSize.Level1) +{ + int32_t ret = -1; + uint32_t channelIdValue = 2; + 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); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetCurrentChannelId, ¶[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); + 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); + } +} +} \ 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 new file mode 100755 index 0000000000000000000000000000000000000000..ac16d04396c3fa30de491e40d30da4dc644a12cb --- /dev/null +++ b/audio/test/systemtest/hdi/hdireliability/src/audio_hdirender_reliability_test.cpp @@ -0,0 +1,1475 @@ +/* + * 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_hdi_common.h" +#include +#include "audio_hdirender_reliability_test.h" + +using namespace std; +using namespace testing::ext; +using namespace HMOS::Audio; + +namespace { +const string AUDIO_FILE = "//bin/audiorendertest.wav"; +const string AUDIO_FILE_LOG = "//bin/14031.wav"; +const string AUDIO_FILE_ERR = "//bin/test.txt"; +const string ADAPTER_NAME = "hdmi"; +const string ADAPTER_NAME2 = "usb"; +const string ADAPTER_NAME3 = "internal"; +const int PTHREAD_SAMEADA_COUNT = 10; +const int PTHREAD_DIFFADA_COUNT = 3; + +class AudioHdiRenderReliabilityTest : public testing::Test { +public: + static void SetUpTestCase(void); + 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 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 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 RelAudioRenderGetRenderPosition(struct RelRenderAdapterPara &ptr); + static int32_t RelAudioRenderSetChannelMode(struct RelRenderAdapterPara &ptr); + static int32_t RelAudioRenderGetChannelMode(struct RelRenderAdapterPara &ptr); +}; + +using THREAD_FUNC = void *(*)(void *); + +void AudioHdiRenderReliabilityTest::SetUpTestCase(void) {} + +void AudioHdiRenderReliabilityTest::TearDownTestCase(void) {} + +void AudioHdiRenderReliabilityTest::SetUp(void) +{ + char resolvedPath[] = "//system/lib/libhdi_audio.z.so"; + handleSo = dlopen(resolvedPath, RTLD_LAZY); + if (handleSo == nullptr) { + return; + } + GetAudioManager = (struct AudioManager* (*)())(dlsym(handleSo, "GetAudioManagerFuncs")); + if (GetAudioManager == nullptr) { + return; + } +} + +void AudioHdiRenderReliabilityTest::TearDown(void) +{ + // step 2: input testsuit teardown step + if (handleSo != nullptr) { + dlclose(handleSo); + handleSo = nullptr; + } + 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; + uint64_t getframes; + uint32_t getcurrentchannelId; + enum AudioChannelMode setmode; + enum AudioChannelMode getmode; +}; + +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}; +}; + +/** + * @brief Obtains the list of all adapters supported by an audio driver and Switch appropriate Adapter. + * + * @param struct RelRenderAdapterPara + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise + */ +int32_t AudioHdiRenderReliabilityTest::RelGetAllAdapter(struct RelRenderAdapterPara& ptr) +{ + int size = 0; + auto *inst = (AudioHdiRenderReliabilityTest *)ptr.param; + if (inst != nullptr && inst->GetAudioManager != nullptr) { + ptr.manager = inst->GetAudioManager(); + } + if (ptr.manager == nullptr) { + return HDF_FAILURE; + } + ptr.manager->GetAllAdapters(ptr.manager, &ptr.descs, &size); + if (ptr.descs == nullptr || size == 0) { + return HDF_FAILURE; + } else { + int index = HMOS::Audio::SwitchAdapter(ptr.descs, ptr.adapterName, ptr.portType, ptr.renderPort, size); + if (index < 0) { + return HDF_FAILURE; + } else { + ptr.desc = &ptr.descs[index]; + } + } + if (ptr.desc == nullptr) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** + * @brief Loads the driver for an audio adapter which is GetAllAdapters Switch appropriate Adapter. + * + * @param struct RelRenderAdapterPara + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise. + */ +int32_t AudioHdiRenderReliabilityTest::RelLoadAdapter(struct RelRenderAdapterPara& ptr) +{ + ptr.manager->LoadAdapter(ptr.manager, ptr.desc, &ptr.adapter); + + if (ptr.adapter == nullptr) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** + * @brief Creates an AudioRender object. + * + * @param struct RelRenderAdapterPara + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise. + */ +int32_t AudioHdiRenderReliabilityTest::RelAudioCreateRender(struct RelRenderAdapterPara& ptr) +{ + int32_t ret = -1; + struct AudioSampleAttributes attrs = {}; + struct AudioDeviceDescriptor devDesc = {}; + if (ptr.adapter == nullptr || ptr.manager == nullptr) { + return HDF_FAILURE; + } + ret = HMOS::Audio::InitAttrs(attrs); + if (ret < 0) { + return HDF_FAILURE; + } + ret = HMOS::Audio::InitDevDesc(devDesc, (&ptr.renderPort)->portId, ptr.pins); + if (ret < 0) { + return HDF_FAILURE; + } + ret = ptr.adapter->CreateRender(ptr.adapter, &devDesc, &attrs, &ptr.render); + if (ret < 0 || ptr.render == nullptr) { + ptr.manager->UnloadAdapter(ptr.manager, ptr.adapter); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** + * @brief Destroy an AudioRender object. + * + * @param struct RelRenderAdapterPara + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise. + */ +int32_t AudioHdiRenderReliabilityTest::RelAudioDestroyRender(struct RelRenderAdapterPara& ptr) +{ + int32_t ret = -1; + if (ptr.adapter == nullptr || ptr.render == nullptr) { + return HDF_FAILURE; + } + ret = ptr.adapter->DestroyRender(ptr.adapter, ptr.render); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + + +/** + * @brief Starts audio rendering. + * + * @param struct RelRenderAdapterPara + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise. + */ +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderStartAndFrame(struct RelRenderAdapterPara& ptr) +{ + int32_t ret = -1; + struct AudioSampleAttributes attrs = {}; + char absPath[PATH_MAX] = {0}; + if (realpath(ptr.path, absPath) == nullptr) { + return HDF_FAILURE; + } + FILE *file = fopen(absPath, "rb"); + if (file == nullptr) { + return HDF_FAILURE; + } + ret = InitAttrs(attrs); + if (ret < 0) { + return HDF_FAILURE; + } + if (HMOS::Audio::WavHeadAnalysis(ptr.headInfo, file, attrs) < 0) { + return HDF_FAILURE; + } else { + ret = HMOS::Audio::FrameStart(ptr.headInfo, ptr.render, file, attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + } + if (ret == 0) { + fclose(file); + } else { + fclose(file); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** + * @brief Stops audio rendering. + * + * @param struct RelRenderAdapterPara + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise. + */ +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderStart(struct RelRenderAdapterPara& ptr) +{ + int32_t ret = -1; + ret = ptr.render->control.Start((AudioHandle)(ptr.render)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** + * @brief audio send Frame. + * + * @param struct RelRenderAdapterPara + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise. + */ +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderFrame(struct RelRenderAdapterPara& ptr) +{ + int32_t ret = -1; + uint64_t requestBytes = 0; + uint64_t replyBytes = 0; + char *frame = nullptr; + + ret = HMOS::Audio::RenderFramePrepare(ptr.path, frame, requestBytes); + if (ret < 0) { + return HDF_FAILURE; + } + ret = ptr.render->RenderFrame(ptr.render, frame, requestBytes, &replyBytes); + if (ret < 0) { + if (frame != nullptr) { + free(frame); + frame = nullptr; + } + return HDF_FAILURE; + } + if (frame != nullptr) { + free(frame); + frame = nullptr; + } + return HDF_SUCCESS; +} + +/** + * @brief Stops audio rendering. + * + * @param struct RelRenderAdapterPara + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise. + */ +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderStop(struct RelRenderAdapterPara& ptr) +{ + int32_t ret = -1; + ret = ptr.render->control.Stop((AudioHandle)(ptr.render)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** + * @brief Pause audio rendering. + * + * @param struct RelRenderAdapterPara + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise. + */ +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderPause(struct RelRenderAdapterPara& ptr) +{ + int32_t ret = -1; + ret = ptr.render->control.Pause((AudioHandle)(ptr.render)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** + * @brief Resume audio rendering. + * + * @param struct RelRenderAdapterPara + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise. + */ +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderResume(struct RelRenderAdapterPara& ptr) +{ + int32_t ret = -1; + ret = ptr.render->control.Resume((AudioHandle)(ptr.render)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** + * @brief Resume audio rendering. + * + * @param struct RelRenderAdapterPara + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise. + */ +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetGainThreshold(struct RelRenderAdapterPara& ptr) +{ + int32_t ret = -1; + + ret = ptr.render->volume.GetGainThreshold(ptr.render, &(ptr.character.gainthresholdmin), + &(ptr.character.gainthresholdmax)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** + * @brief Resume audio rendering. + * + * @param struct RelRenderAdapterPara + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise. + */ +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSetGain(struct RelRenderAdapterPara& ptr) +{ + int32_t ret = -1; + ret = ptr.render->volume.SetGain(ptr.render, ptr.character.setgain); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** + * @brief Resume audio rendering. + * + * @param struct RelRenderAdapterPara + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise. + */ +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetGain(struct RelRenderAdapterPara& ptr) +{ + int32_t ret = -1; + ret = ptr.render->volume.GetGain(ptr.render, &(ptr.character.getgain)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** + * @brief Render procedure include RelGetAllAdapter,RelLoadAdapter.RelAudioCreateRender,RelAudioRenderStartAndFrame. + * + * @param struct RelRenderAdapterPara + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise. + */ +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderProcedure(struct RelRenderAdapterPara& ptr) +{ + int32_t ret = -1; + ret = RelGetAllAdapter(ptr); + if (ret < 0) { + return HDF_FAILURE; + } + + ret = RelLoadAdapter(ptr); + if (ret < 0) { + return HDF_FAILURE; + } + + ret = RelAudioCreateRender(ptr); + if (ret < 0) { + return HDF_FAILURE; + } + + ret = RelAudioRenderStartAndFrame(ptr); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** + * @brief Set audio mute. + * + * @param struct RelRenderAdapterPara + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise. + */ +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSetMute(struct RelRenderAdapterPara& ptr) +{ + int32_t ret = -1; + ret = ptr.render->volume.SetMute(ptr.render, ptr.character.setmute); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** + * @brief Get audio mute. + * + * @param struct RelRenderAdapterPara + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise. + */ +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetMute(struct RelRenderAdapterPara& ptr) +{ + int32_t ret = -1; + ret = ptr.render->volume.GetMute(ptr.render, &(ptr.character.getmute)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** + * @brief Set audio mute. + * + * @param struct RelRenderAdapterPara + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise. + */ +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSetVolume(struct RelRenderAdapterPara& ptr) +{ + int32_t ret = -1; + ret = ptr.render->volume.SetVolume(ptr.render, ptr.character.setvolume); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** + * @brief Get audio mute. + * + * @param struct RelRenderAdapterPara + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise. + */ +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetVolume(struct RelRenderAdapterPara& ptr) +{ + int32_t ret = -1; + ret = ptr.render->volume.GetVolume(ptr.render, &(ptr.character.getvolume)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** + * @brief Resume audio rendering. + * + * @param struct RelRenderAdapterPara + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise. + */ +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetFrameSize(struct RelRenderAdapterPara &ptr) +{ + int32_t ret = -1; + ret = ptr.render->attr.GetFrameSize(ptr.render, &(ptr.character.getframesize)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** + * @brief Resume audio rendering. + * + * @param struct RelRenderAdapterPara + * + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise. + */ +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetFrameCount(struct RelRenderAdapterPara &ptr) +{ + int32_t ret = -1; + ret = ptr.render->attr.GetFrameCount(ptr.render, &(ptr.character.getframecount)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** + * @brief Resume audio rendering. + * + * @param struct RelRenderAdapterPara + * + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise. + */ +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetCurrentChannelId(struct RelRenderAdapterPara &ptr) +{ + int32_t ret = -1; + ret = ptr.render->attr.GetCurrentChannelId(ptr.render, &(ptr.character.getcurrentchannelId)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** + * @brief Resume audio rendering. + * + * @param struct RelRenderAdapterPara + * + * + * @return Returns 0 if the initialization is successful; returns a negative value otherwise. + */ +int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetRenderPosition(struct RelRenderAdapterPara &ptr) +{ + int32_t ret = -1; + ret = ptr.render->GetRenderPosition(ptr.render, &(ptr.character.getframes), &(ptr.time)); + if (ret < 0) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +/** +* @tc.name test GetAllAdapter API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioGetAllAdapter_Reliability_0001 +* @tc.desc test Reliability GetAllAdapters interface pass through pthread_create fun and adapterName is same. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, 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, + .path = AUDIO_FILE.c_str() + }; + struct RelRenderAdapterPara 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)); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelGetAllAdapter, &arrpara[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + } + for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { + void *result = 0; + pthread_join(tids[i], &result); + EXPECT_EQ(HDF_SUCCESS, (intptr_t)result); + } +} + +/** +* @tc.name test LoadAdapter API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioLoadlAdapter_Reliability_0002 +* @tc.desc test LoadAdapter interface Reliability pass through pthread_create fun and adapterName is different. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioLoadlAdapter_Reliability_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = 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 = RelGetAllAdapter(para[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelLoadAdapter, ¶[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); + ret = (intptr_t)result; + EXPECT_EQ(HDF_SUCCESS, ret); + para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); + } +} + +/** +* @tc.name test LoadAdapter API via Multithread call but desc is nullptr. +* @tc.number SUB_Audio_HDI_AudioLoadlAdapter_Reliability_0003 +* @tc.desc test LoadAdapter interface Reliability pass through pthread_create fun. +* adapterName is different and desc is nullptr. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioLoadlAdapter_Reliability_0003, TestSize.Level1) +{ + int32_t ret = -1; + int32_t failcount = 0; + int32_t succeedcount = 0; + struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = 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 = RelGetAllAdapter(para[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + para[i].desc = nullptr; + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelLoadAdapter, ¶[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); + ret = (intptr_t)result; + if (ret == 0) { + EXPECT_EQ(HDF_SUCCESS, ret); + succeedcount = succeedcount + 1; + para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); + } else { + EXPECT_EQ(HDF_FAILURE, ret); + failcount = failcount + 1; + } + } + EXPECT_EQ(failcount, PTHREAD_DIFFADA_COUNT); + EXPECT_EQ(succeedcount, 0); +} + +/** +* @tc.name test AudioCreateRender API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioCreateRender_Reliability_0001 +* @tc.desc test CreateRender interface Reliability pass through pthread_create fun and adapterName is different. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioCreateRender_Reliability_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = 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 = RelGetAllAdapter(para[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = RelLoadAdapter(para[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCreateRender, ¶[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); + ret = (intptr_t)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 AudioDestroyRender API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioDestroyRender_Reliability_0002 +* @tc.desc test DestroyRender interface Reliability pass through pthread_create fun and adapterName is different. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioDestroyRender_Reliability_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = 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 = RelGetAllAdapter(para[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = RelLoadAdapter(para[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = RelAudioCreateRender(para[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioDestroyRender, ¶[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); + para[i].manager->UnloadAdapter(para[i].manager, para[i].adapter); + } +} + +/** +* @tc.name test AudioRenderStart API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioRenderStart_Reliability_0002 +* @tc.desc test AudioRenderStart interface Reliability pass through pthread_create fun.adapterName is different. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderStart_Reliability_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = 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 = RelGetAllAdapter(para[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = RelLoadAdapter(para[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = RelAudioCreateRender(para[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderStart, ¶[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); + ret = (intptr_t)result; + 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); + } +} + +/** +* @tc.name test AudioRenderFrame API via Multithread call. +* @tc.number SUB_Audio_HDI_RelAudioRenderFrame_Reliability_0002 +* @tc.desc test AudioRenderFrame interface Reliability pass through pthread_create fun.adapterName is different. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderFrame_Reliability_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = 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 = RelGetAllAdapter(para[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = RelLoadAdapter(para[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = RelAudioCreateRender(para[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = RelAudioRenderStart(para[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderFrame, ¶[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); + ret = (intptr_t)result; + 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); + } +} + +/** +* @tc.name test AudioRenderStop API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioRenderStop_Reliability_0001 +* @tc.desc test AudioRenderStop interface Reliability pass through pthread_create fun and adapterName is same. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderStop_Reliability_0001, TestSize.Level1) +{ + 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, + .path = AUDIO_FILE.c_str()}; + struct RelRenderAdapterPara 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)); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderStop, &arrpara[i]); + EXPECT_EQ(HDF_SUCCESS, ret); + } + for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) { + void *result = nullptr; + int32_t ret = -1; + pthread_join(tids[i], &result); + ret = (intptr_t)result; + if (ret == 0) { + EXPECT_EQ(HDF_SUCCESS, ret); + succeedcount = succeedcount + 1; + } else { + EXPECT_EQ(HDF_FAILURE, ret); + failcount = failcount + 1; + } + } + + 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); +} + +/** +* @tc.name test AudioRenderStop API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioRenderStop_Reliability_0002 +* @tc.desc test AudioRenderStop interface Reliability pass through pthread_create fun and adapterName is different. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderStop_Reliability_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = 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_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderStop, ¶[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); + ret = (intptr_t)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 AudioRenderPause API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioRenderPause_Reliability_0001 +* @tc.desc test AudioRenderPause interface Reliability pass through pthread_create fun and adapterName is same. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderPause_Reliability_0001, TestSize.Level1) +{ + 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, + .path = AUDIO_FILE.c_str()}; + struct RelRenderAdapterPara 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)); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderPause, &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); + ret = (intptr_t)result; + if (ret == 0) { + EXPECT_EQ(HDF_SUCCESS, ret); + succeedcount = succeedcount + 1; + } else { + EXPECT_EQ(HDF_FAILURE, ret); + failcount = failcount + 1; + } + } + para.render->control.Stop((AudioHandle)(para.render)); + 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); +} + +/** +* @tc.name test AudioRenderPause API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioRenderPause_Reliability_0002 +* @tc.desc test AudioRenderPause interface Reliability pass through pthread_create fun and adapterName is different +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderPause_Reliability_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = 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_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderPause, ¶[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->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); + } +} + +/** +* @tc.name test AudioRenderResume API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioRenderResume_Reliability_0001 +* @tc.desc test RelAudioRenderResume interface Reliability pass through pthread_create fun and adapterName is same. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderResume_Reliability_0001, TestSize.Level1) +{ + 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, + .path = AUDIO_FILE.c_str()}; + struct RelRenderAdapterPara arrpara[PTHREAD_SAMEADA_COUNT]; + + ret = RelAudioRenderProcedure(para); + ASSERT_EQ(HDF_SUCCESS, ret); + ret = RelAudioRenderPause(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)); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderResume, &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); + ret = (intptr_t)result; + if (ret == 0) { + EXPECT_EQ(HDF_SUCCESS, ret); + succeedcount = succeedcount + 1; + } else { + EXPECT_EQ(HDF_FAILURE, ret); + failcount = failcount + 1; + } + } + para.render->control.Stop((AudioHandle)(para.render)); + para.adapter->DestroyRender(para.adapter, para.render); + para.manager->UnloadAdapter(para.manager, para.adapter); +} +/** +* @tc.name test AudioRenderResume API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioRenderResume_Reliability_0002 +* @tc.desc test AudioRenderResume interface Reliability pass through pthread_create fun and adapterName is different. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderResume_Reliability_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = 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_EQ(HDF_SUCCESS, ret); + ret = RelAudioRenderPause(para[i]); + ASSERT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderResume, ¶[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->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); + } +} + +/** +* @tc.name test AudioRenderGetFrameSize API via Multithread call. +* @tc.number SUB_Audio_HDI_AudiorenderGetVolume_Reliability_0001 +* @tc.desc test GetFrameSize interface Reliability pass through pthread_create fun and adapterName is same. +* @tc.author: zhouyongxiao +*/ +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, + .path = AUDIO_FILE.c_str()}; + struct RelRenderAdapterPara 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)); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetFrameSize, &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(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); +} + +/** +* @tc.name test AudioRenderGetFrameSize API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioRenderGetFrameSize_Reliability_0002 +* @tc.desc test GetFrameSize interface Reliability pass through pthread_create fun and adapterName is different. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetFrameSize_Reliability_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = 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_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; + int32_t ret = -1; + 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)); + 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 AudioRenderGetFrameCount API via Multithread call. +* @tc.number SUB_Audio_HDI_AudiorenderGetVolume_Reliability_0001 +* @tc.desc test GetFrameCount interface Reliability pass through pthread_create fun and adapterName is same. +* @tc.author: zhouyongxiao +*/ +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, + .path = AUDIO_FILE.c_str()}; + struct RelRenderAdapterPara 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)); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetFrameCount, &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(INITIAL_VALUE, arrpara[i].character.getframecount); + } + 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); +} + +/** +* @tc.name test AudioRenderGetFrameCount API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioRenderGetFrameCount_Reliability_0002 +* @tc.desc test GetFrameCount interface Reliability pass through pthread_create fun and adapterName is different. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetFrameCount_Reliability_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = 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_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetFrameCount, ¶[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); + EXPECT_LT(INITIAL_VALUE, para[i].character.getframecount); + + 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); + } +} + +/** +* @tc.name test AudioRenderGetRenderPosition API via Multithread call. +* @tc.number SUB_Audio_HDI_AudiorenderGetVolume_Reliability_0001 +* @tc.desc test GetRenderPosition interface Reliability pass through pthread_create fun and adapterName is same. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_Reliability_0001, TestSize.Level1) +{ + 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, + .path = AUDIO_FILE.c_str()}; + struct RelRenderAdapterPara 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)); + EXPECT_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetRenderPosition, &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(INITIAL_VALUE, arrpara[i].character.getframes); + EXPECT_LT(timeExp, arrpara[i].time.tvNSec); + } + 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); +} + +/** +* @tc.name test AudioRenderGetRenderPosition API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_Reliability_0002 +* @tc.desc test GetRenderPosition interface Reliability pass through pthread_create fun and adapterName is different. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_Reliability_0002, TestSize.Level1) +{ + int32_t ret = -1; + int64_t timeExp = 0; + struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = 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_EQ(HDF_SUCCESS, ret); + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetRenderPosition, ¶[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); + 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); + } +} + +/** +* @tc.name test AudioRenderGetVolume API via Multithread call. +* @tc.number SUB_Audio_HDI_AudiorenderGetVolume_Reliability_0001 +* @tc.desc test GetCurrentChannelId interface Reliability pass through pthread_create fun and adapterName is same. +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetCurrentChannelId_Reliability_0001, TestSize.Level1) +{ + 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, + .path = AUDIO_FILE.c_str()}; + struct RelRenderAdapterPara 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)); + EXPECT_EQ(HDF_SUCCESS, ret); + arrpara[i].character.getcurrentchannelId = 0; + int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetCurrentChannelId, &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(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); +} + +/** +* @tc.name test AudioRenderGetCurrentChannelId API via Multithread call. +* @tc.number SUB_Audio_HDI_AudioRenderGetCurrentChannelId_Reliability_0002 +* @tc.desc test GetCurrentChannelId interface Reliability pass through pthread_create fun and adapterName is different +* @tc.author: zhouyongxiao +*/ +HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetCurrentChannelId_Reliability_0002, TestSize.Level1) +{ + int32_t ret = -1; + uint32_t channelIdValue = 2; + struct RelRenderAdapterPara para[PTHREAD_DIFFADA_COUNT] = { + { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME2.c_str(), .param = this, .pins = PIN_OUT_SPEAKER, + .path = AUDIO_FILE.c_str() + }, { + .portType = PORT_OUT, .adapterName = ADAPTER_NAME3.c_str(), .param = 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_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; + int32_t ret = -1; + 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)); + 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); + } +} +} diff --git a/audio/test/systemtest/hdi/render/BUILD.gn b/audio/test/systemtest/hdi/render/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..043fd1697e0d27762fbc5b73f69823f701817acd --- /dev/null +++ b/audio/test/systemtest/hdi/render/BUILD.gn @@ -0,0 +1,208 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//drivers/adapter/uhdf2/uhdf.gni") + +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" + ] + + 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/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/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/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" + ] + + 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########################### \ No newline at end of file diff --git a/audio/test/systemtest/hdi/render/include/audio_hdirender_attr_test.h b/audio/test/systemtest/hdi/render/include/audio_hdirender_attr_test.h new file mode 100755 index 0000000000000000000000000000000000000000..2b45c4275b4ea15aa7fb6c7e9c23efcefc4705ae --- /dev/null +++ b/audio/test/systemtest/hdi/render/include/audio_hdirender_attr_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_ATTR_TEST +#define AUDIO_HDIRENDER_ATTR_TEST + +#endif diff --git a/audio/test/systemtest/hdi/render/include/audio_hdirender_control_test.h b/audio/test/systemtest/hdi/render/include/audio_hdirender_control_test.h new file mode 100755 index 0000000000000000000000000000000000000000..a302965274195b221787e596da9ba24026744cae --- /dev/null +++ b/audio/test/systemtest/hdi/render/include/audio_hdirender_control_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_CONTROL_TEST_H +#define AUDIO_HDIRENDER_CONTROL_TEST_H + +#endif diff --git a/audio/test/systemtest/hdi/render/include/audio_hdirender_scene_test.h b/audio/test/systemtest/hdi/render/include/audio_hdirender_scene_test.h new file mode 100755 index 0000000000000000000000000000000000000000..0e6a208d1c3a8780da476351221827baac8aba7d --- /dev/null +++ b/audio/test/systemtest/hdi/render/include/audio_hdirender_scene_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_SCENE_TEST_H +#define AUDIO_HDIRENDER_SCENE_TEST_H + +#endif diff --git a/audio/test/systemtest/hdi/render/include/audio_hdirender_test.h b/audio/test/systemtest/hdi/render/include/audio_hdirender_test.h new file mode 100755 index 0000000000000000000000000000000000000000..b83148e1d6cddc861d29cf274f7c63cb13aa403b --- /dev/null +++ b/audio/test/systemtest/hdi/render/include/audio_hdirender_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_TEST_H +#define AUDIO_HDIRENDER_TEST_H + +#endif diff --git a/audio/test/systemtest/hdi/render/include/audio_hdirender_volume_test.h b/audio/test/systemtest/hdi/render/include/audio_hdirender_volume_test.h new file mode 100755 index 0000000000000000000000000000000000000000..fee4409264d91822ade596bbb194324c8d7d0f5e --- /dev/null +++ b/audio/test/systemtest/hdi/render/include/audio_hdirender_volume_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_VOLUME_TEST_H +#define AUDIO_HDIRENDER_VOLUME_TEST_H + +#endif 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 new file mode 100755 index 0000000000000000000000000000000000000000..8adec45112c157b97a999d7354250d23cd6b746d --- /dev/null +++ b/audio/test/systemtest/hdi/render/src/audio_hdirender_attr_test.cpp @@ -0,0 +1,1670 @@ +/* + * 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 Defines audio-related APIs, including custom data types and functions for loading drivers, + * accessing a driver adapter, and rendering audios. + * + * @since 1.0 + * @version 1.0 + */ + +/** + * @file audio_hdi_common.h + * + * @brief Declares APIs for operations related to the audio render adapter. + * + * @since 1.0 + * @version 1.0 + */ + +#include "audio_hdi_common.h" +#include "audio_hdirender_attr_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"; +const string ADAPTER_NAME2 = "usb"; +const string ADAPTER_NAME3 = "internal"; + +class AudioHdiRenderAttrTest : public testing::Test { +public: + static void SetUpTestCase(void); + 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; +}; + +void AudioHdiRenderAttrTest::SetUpTestCase(void) {} + +void AudioHdiRenderAttrTest::TearDownTestCase(void) {} + +void AudioHdiRenderAttrTest::SetUp(void) +{ + char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; + handleSo = dlopen(resolvedPath, RTLD_LAZY); + if (handleSo == nullptr) { + return; + } + GetAudioManager = (struct AudioManager* (*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); + if (GetAudioManager == 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; + } + ret = InitDevDesc(devDesc, renderPort.portId, pins); + if (ret < 0) { + return HDF_FAILURE; + } + ret = adapter->CreateRender(adapter, &devDesc, &attrs, render); + if (ret < 0 || *render == nullptr) { + manager.UnloadAdapter(&manager, adapter); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHdiRenderAttrTest::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; +} + +/** +* @tc.name Test AudioRenderSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0001 +* @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = AUDIO_SAMPLE_RATE_MASK_8000; +* attrs.channelCount = 1; +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0001, TestSize.Level1) +{ + int32_t ret = -1; + 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); + 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); + 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); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0002 +* @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_24_BIT; +* attrs.sampleRate = 11025; +* attrs.channelCount = 2; +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0002, TestSize.Level1) +{ + int32_t ret = -1; + 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); + 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 = 11025; + attrs.channelCount = 2; + + ret = render->attr.SetSampleAttributes(render, &attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->attr.GetSampleAttributes(render, &attrsValue); + EXPECT_EQ(HDF_SUCCESS, ret); + + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(ret1, attrsValue.sampleRate); + EXPECT_EQ(ret2, attrsValue.channelCount); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0003 +* @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = 22050; +* attrs.channelCount = 1; +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0003, TestSize.Level1) +{ + int32_t ret = -1; + 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); + 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 = 22050; + attrs.channelCount = 2; + + ret = render->attr.SetSampleAttributes(render, &attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->attr.GetSampleAttributes(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(ret1, attrsValue.sampleRate); + EXPECT_EQ(ret2, attrsValue.channelCount); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0004 +* @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_24_BIT; +* attrs.sampleRate = 32000; +* attrs.channelCount = 2; +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0004, TestSize.Level1) +{ + int32_t ret = -1; + 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); + 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 = 32000; + attrs.channelCount = 2; + + ret = render->attr.SetSampleAttributes(render, &attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->attr.GetSampleAttributes(render, &attrsValue); + EXPECT_EQ(HDF_SUCCESS, ret); + + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(ret1, attrsValue.sampleRate); + EXPECT_EQ(ret2, attrsValue.channelCount); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderSetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0005 +* @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_MEDIA; +* attrs.format = AUDIO_FORMAT_PCM_16_BIT; +* attrs.sampleRate = 44100; +* attrs.channelCount = 1; +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0005, TestSize.Level1) +{ + int32_t ret = -1; + 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); + 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 = 44100; + attrs.channelCount = 1; + + ret = render->attr.SetSampleAttributes(render, &attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->attr.GetSampleAttributes(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(ret1, attrsValue.sampleRate); + EXPECT_EQ(ret2, attrsValue.channelCount); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderSetSampleAttributes API via legal input. +* @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows. +* attrs.type = AUDIO_IN_COMMUNICATION; +* attrs.format = AUDIO_FORMAT_PCM_24_BIT; +* attrs.sampleRate = 48000; +* attrs.channelCount = 2; +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0006, TestSize.Level1) +{ + int32_t ret = -1; + 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); + 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 = 2; + + ret = render->attr.SetSampleAttributes(render, &attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->attr.GetSampleAttributes(render, &attrsValue); + EXPECT_EQ(HDF_SUCCESS, ret); + + EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type); + EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format); + EXPECT_EQ(ret1, attrsValue.sampleRate); + EXPECT_EQ(ret2, attrsValue.channelCount); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderSetSampleAttributes API via setting the render is empty . +* @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0007 +* @tc.desc Test AudioRenderSetSampleAttributes interface, return -1 if the render is empty. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0007, TestSize.Level1) +{ + 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); + 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; + + ret = render->attr.SetSampleAttributes(renderNull, &attrs); + EXPECT_EQ(HDF_FAILURE, ret); + ret = render->attr.SetSampleAttributes(render, nullptr); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderSetSampleAttributes API via illegal 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; +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0008, 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); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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_16_BIT; + attrs1.sampleRate = 12000; + attrs1.channelCount = 1; + ret = render->attr.SetSampleAttributes(render, &attrs1); + EXPECT_EQ(HDF_ERR_NOT_SUPPORT, 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); + + 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); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderSetSampleAttributes API via illegal 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_16/24_BIT; +* attrs.sampleRate = 64000/96000/0xFFFFFFFFu; +* attrs.channelCount = 1/2; +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0009, 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); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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_16_BIT; + attrs1.sampleRate = 64000; + attrs1.channelCount = 1; + ret = render->attr.SetSampleAttributes(render, &attrs1); + EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); + + 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); + + attrs3.type = AUDIO_IN_MEDIA; + attrs3.format = AUDIO_FORMAT_PCM_16_BIT; + attrs3.sampleRate = 0xFFFFFFFFu; + attrs3.channelCount = 2; + ret = render->attr.SetSampleAttributes(render, &attrs3); + 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_0010 +* @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; +* attrs.sampleRate = 8000/11025/22050; +* attrs.channelCount = 1/2; +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0010, 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); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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; + 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; + 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; + ret = render->attr.SetSampleAttributes(render, &attrs3); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderSetSampleAttributes API via illegal 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_AAC_LC/LD/ELD; +* attrs.sampleRate = 32000/44100/48000; +* attrs.channelCount = 1/2; +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0011, 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); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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; + 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; + 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; + ret = render->attr.SetSampleAttributes(render, &attrs3); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderSetSampleAttributes API via illegal 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_AAC_HE_V1/V2 +* attrs.sampleRate = 8000/44100; +* attrs.channelCount = 1/2; +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0012, 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); + 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; + 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; + ret = render->attr.SetSampleAttributes(render, &attrs2); + EXPECT_EQ(HDF_FAILURE, 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 = 8000; +* attrs.channelCount = 5; +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0013, 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); + 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; + ret = render->attr.SetSampleAttributes(render, &attrs); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderGetSampleAttributes API via legal input. +* @tc.number SUB_Audio_HDI_AudioRenderGetSampleAttributes_0001 +* @tc.desc Test AudioRenderGetSampleAttributes ,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(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderGetSampleAttributes_0001, TestSize.Level1) +{ + int32_t ret = -1; + 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); + 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); + 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); + EXPECT_EQ(ret2, attrsValue.channelCount); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRendereGetSampleAttributes API via setting the render is empty . +* @tc.number SUB_Audio_HDI_AudioRenderGetSampleAttributes_0002 +* @tc.desc Test AudioRendereGetSampleAttributes interface, return -1 if the render is empty. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderGetSampleAttributes_0002, TestSize.Level1) +{ + 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); + 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; + + ret = render->attr.GetSampleAttributes(renderNull, &attrs); + EXPECT_EQ(HDF_FAILURE, ret); + ret = render->attr.GetSampleAttributes(render, attrsValue); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderGetFrameSize API via legal input + * @tc.number SUB_Audio_HDI_RenderGetFrameSize_0001 + * @tc.desc Test RenderGetFrameSize interface,return 0 if the FrameSize was obtained successfully + * @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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); + EXPECT_GT(size, zero); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test AudioCaptureGetFrameSize API via setting the incoming parameter handle is nullptr + * @tc.number SUB_Audio_HDI_RenderGetFrameSize_0002 + * @tc.desc Test RenderGetFrameSize interface,return -1 if failed to get the FrameSize when handle is nullptr + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager manager = {}; + 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); + 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); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderGetFrameSize API setting the incoming parameter FrameSize is nullptr + * @tc.number SUB_Audio_HDI_RenderGetFrameSize_0003 + * @tc.desc Test RenderGetFrameSize interface,return -1 if failed to get the FrameSize when size is nullptr + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager manager = {}; + 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); + 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); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderGetFrameSize API via define format to different values + * @tc.number SUB_Audio_HDI_RenderGetFrameSize_0004 + * @tc.desc Test RenderGetFrameSize interface,return 0 if get framesize define format as different values + * @tc.author: tiansuli +*/ +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 = {}; + uint64_t size = 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); + 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); + 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 = render->attr.GetFrameSize(render, &size); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(size, INITIAL_VALUE); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderGetFrameSize API via define sampleRate to different values + * @tc.number SUB_Audio_HDI_RenderGetFrameSize_0005 + * @tc.desc Test RenderGetFrameSize interface,return 0 if get framesize define sampleRate as different values + * @tc.author: tiansuli +*/ +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 = {}; + uint64_t size = 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); + 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); + 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 = render->attr.GetFrameSize(render, &size); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(size, INITIAL_VALUE); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderGetFrameSize API via define channelCount to different values + * @tc.number SUB_Audio_HDI_RenderGetFrameSize_0006 + * @tc.desc Test RenderGetFrameSize interface,return 0 if get framesize define channelCount as different values + * @tc.author: tiansuli +*/ +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 = {}; + uint64_t size = 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); + 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); + 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 = render->attr.GetFrameSize(render, &size); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(size, INITIAL_VALUE); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderGetFrameSize API via define sampleRate to different value + * @tc.number SUB_Audio_HDI_RenderGetFrameSize_0007 + * @tc.desc Test RenderGetFrameSize interface,return 0 if get framesize define sampleRate as different values + * @tc.author: tiansuli +*/ +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 = {}; + uint64_t size = 0; + uint64_t channelCountExp = 1; + uint32_t sampleRateExp = 44100; + struct AudioManager manager = *GetAudioManager(); + ASSERT_NE(nullptr, GetAudioManager); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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); + 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 = render->attr.GetFrameSize(render, &size); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(size, INITIAL_VALUE); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderGetFrameCount API via legal + * @tc.number SUB_Audio_HDI_RenderGetFrameCount_0001 + * @tc.desc Test RenderGetFrameCount interface, return 0 if the FrameSize was obtained successfully + * @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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); + EXPECT_GT(count, zero); + + render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderGetFrameCount API via setting the incoming parameter handle is nullptr + * @tc.number SUB_Audio_HDI_RenderGetFrameCount_0002 + * @tc.desc Test RenderGetFrameCount interface,return -1 if the incoming parameter handle is nullptr + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager manager = {}; + struct AudioAdapter *adapter = nullptr; + struct AudioPort renderPort = {}; + 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); + 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); + + render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderGetFrameCount API setting the incoming parameter count is nullptr + * @tc.number SUB_Audio_HDI_RenderGetFrameCount_0003 + * @tc.desc Test RenderGetFrameCount interface,return -1 if the incoming parameter count is nullptr + * @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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); + + render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderGetFrameCount API via define channelCount to different value + * @tc.number SUB_Audio_HDI_RenderGetFrameCount_0004 + * @tc.desc Test RenderGetFrameCount interface,return 0 if get framesize define channelCount as different values + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0004, TestSize.Level1) +{ + int32_t ret = -1; + 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); + 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); + 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 = AudioRenderStart(AUDIO_FILE, 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); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderGetFrameCount API via define format to different value + * @tc.number SUB_Audio_HDI_RenderGetFrameCount_0005 + * @tc.desc Test RenderGetFrameCount interface,return 0 if get framesize define format as different values + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0005, TestSize.Level1) +{ + int32_t ret = -1; + 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); + 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); + 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 = AudioRenderStart(AUDIO_FILE, 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); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderGetFrameCount API via define channelCount to different value + * @tc.number SUB_Audio_HDI_RenderGetFrameCount_0006 + * @tc.desc Test RenderGetFrameCount interface,return 0 if get framesize define channelCount to different values + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0006, TestSize.Level1) +{ + int32_t ret = -1; + 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); + 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); + 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 = AudioRenderStart(AUDIO_FILE, 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); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderGetFrameCount API via define format to different value + * @tc.number SUB_Audio_HDI_RenderGetFrameCount_0007 + * @tc.desc Test RenderGetFrameCount interface,return 0 if get framesize define format as different values + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0007, TestSize.Level1) +{ + int32_t ret = -1; + 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); + 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); + 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 = AudioRenderStart(AUDIO_FILE, 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); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderGetCurrentChannelId API via legal input + * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_0001 + * @tc.desc Test RenderGetCurrentChannelId, return 0 if the default CurrentChannelId is obtained successfully + * @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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); + EXPECT_EQ(channelIdValue, channelId); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test GetCurrentChannelId API via get channelId to 1 and set channelCount to 1 + * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_0003 + * @tc.desc Test GetCurrentChannelId interface,return 0 if get channelId to 1 and set channelCount to 1 + * @tc.author: tiansuli +*/ +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 = {}; + + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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 = 48000; + attrs.channelCount = 1; + ret = render->attr.SetSampleAttributes(render, &attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->attr.GetSampleAttributes(render, &attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(channelCountExp, attrs.channelCount); + + ret = render->attr.GetCurrentChannelId(render, &channelId); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(channelIdExp, channelId); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderGetCurrentChannelId API via CurrentChannelId is obtained after created + * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_0003 + * @tc.desc Test RenderGetCurrentChannelId interface, return 0 if CurrentChannelId is obtained after created + * @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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); + EXPECT_EQ(channelIdExp, channelId); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test GetCurrentChannelId API via setting the parameter render is nullptr + * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_0004 + * @tc.desc Test GetCurrentChannelId interface,return -1 if set the parameter render is nullptr + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetCurrentChannelId_0004, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager manager = {}; + 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); + 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); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderGetCurrentChannelId API via setting the parameter channelId is nullptr + * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_0005 + * @tc.desc Test RenderGetCurrentChannelId interface, return -1 if setting the parameter channelId is nullptr + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetCurrentChannelId_0005, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager manager = {}; + struct AudioAdapter *adapter = nullptr; + struct AudioPort renderPort = {}; + struct AudioRender *render = nullptr; + uint32_t *channelIdNull = nullptr; + + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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, channelIdNull); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +} \ 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 new file mode 100755 index 0000000000000000000000000000000000000000..5ebef7523257445c3fafa5ef084744be07f97b60 --- /dev/null +++ b/audio/test/systemtest/hdi/render/src/audio_hdirender_control_test.cpp @@ -0,0 +1,1202 @@ +/* + * 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 Defines audio-related APIs, including custom data types and functions for loading drivers, + * accessing a driver adapter, and rendering audios. + * + * @since 1.0 + * @version 1.0 + */ + +/** + * @file audio_hdi_common.h + * + * @brief Declares APIs for operations related to the audio render adapter. + * + * @since 1.0 + * @version 1.0 + */ + +#include "audio_hdi_common.h" +#include "audio_hdirender_control_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"; +const string ADAPTER_NAME2 = "usb"; +const string ADAPTER_NAME3 = "internal"; + +class AudioHdiRenderControlTest : public testing::Test { +public: + static void SetUpTestCase(void); + 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; +}; + +void AudioHdiRenderControlTest::SetUpTestCase(void) {} + +void AudioHdiRenderControlTest::TearDownTestCase(void) {} + +void AudioHdiRenderControlTest::SetUp(void) +{ + char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; + handleSo = dlopen(resolvedPath, RTLD_LAZY); + if (handleSo == nullptr) { + return; + } + GetAudioManager = (struct AudioManager* (*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); + if (GetAudioManager == 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; + } + ret = InitDevDesc(devDesc, renderPort.portId, pins); + if (ret < 0) { + return HDF_FAILURE; + } + ret = adapter->CreateRender(adapter, &devDesc, &attrs, render); + if (ret < 0 || *render == nullptr) { + manager.UnloadAdapter(&manager, adapter); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} +int32_t AudioHdiRenderControlTest::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; +} + +/** + * @tc.name Test AudioRenderStart API via legal input + * @tc.number SUB_Audio_HDI_RenderStart_0001 + * @tc.desc Test AudioRenderStart interface,return 0 if the audiorender object is created successfully. + * @tc.author: wangqian +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStart_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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); + } +} +/** + * @tc.name Test AudioRenderStart API via setting the incoming parameter handle is nullptr + * @tc.number SUB_Audio_HDI_RenderStart_0002 + * @tc.desc Test AudioRenderStart interface, return -1 if the incoming parameter handle is nullptr + * @tc.author: wangqian +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStart_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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)renderNull); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); + } +} +/** +* @tc.name Test AudioRenderStart API via the interface is called twice in a row +* @tc.number SUB_Audio_HDI_RenderStart_0003 +* @tc.desc Test AudioRenderStart interface,return -1 the second time if the RenderStart is called twice +* @tc.author: Xuhuandi +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStart_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderStop API via legal input +* @tc.number SUB_Audio_HDI_RenderStop_0001 +* @tc.desc test AudioRenderStop interface. return 0 if the rendering is successfully stopped. +* @tc.author: Xuhuandi +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStop_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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); + } +} +/** +* @tc.name Test AudioRenderStop API via the render does not start and stop only +* @tc.number SUB_Audio_HDI_RenderStop_0002 +* @tc.desc test AudioRenderStop interface. return -4 if the render does not start and stop only +* @tc.author: Xuhuandi +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStop_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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); + } +} +/** +* @tc.name Test RenderStop API via the interface is called twice in a row +* @tc.number SUB_Audio_HDI_RenderStop_0003 +* @tc.desc Test RenderStop interface,return -4 the second time if the RenderStop is called twice +* @tc.author: Xuhuandi +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStop_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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); + } +} +/** +* @tc.name Test RenderStop API via setting the incoming parameter handle is nullptr +* @tc.number SUB_Audio_HDI_RenderStop_0004 +* @tc.desc Test RenderStop interface, return -1 if the incoming parameter handle is nullptr +* @tc.author: Xuhuandi +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStop_0004, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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); + } +} +/** + * @tc.name Test RenderPause API via legal input + * @tc.number SUB_Audio_HDI_RenderPause_001 + * @tc.desc test HDI RenderPause interface，return 0 if the render is paused after start + * @tc.author: Xuhuandi +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderPause_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderPause API via the interface is called twice in a row +* @tc.number SUB_Audio_HDI_RenderPause_0002 +* @tc.desc Test AudioRenderPause interface, return -1 the second time if RenderPause is called twice +* @tc.author: Xuhuandi +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderPause_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = nullptr; + struct AudioPort renderPort = {}; + struct AudioRender *render = nullptr; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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); + + render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderPause API via the render is paused before Started. +* @tc.number SUB_Audio_HDI_RenderPause_0003 +* @tc.desc Test AudioRenderPause interface,return -1 if the render is paused before Started. +* @tc.author: Xuhuandi +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderPause_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = nullptr; + struct AudioPort renderPort = {}; + struct AudioRender *render = nullptr; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderPause API via the render is paused after resumed. +* @tc.number SUB_Audio_HDI_RenderPause_0004 +* @tc.desc Test AudioRenderPause interface,return 0 if the render is paused after resumed. +* @tc.author: Xuhuandi +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderPause_0004, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = nullptr; + struct AudioPort renderPort = {}; + struct AudioRender *render = nullptr; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderPause API via the render is paused after stoped. +* @tc.number SUB_Audio_HDI_RenderPause_0005 +* @tc.desc Test AudioRenderPause interface, return -1 the render is paused after stoped. +* @tc.author: Xuhuandi +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderPause_0005, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = nullptr; + struct AudioPort renderPort = {}; + struct AudioRender *render = nullptr; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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 RenderResume API via the render is resumed after started + * @tc.number SUB_Audio_HDI_RenderResume_0001 + * @tc.desc test HDI RenderResume interface,return -1 if the render is resumed after started + * @tc.author: Xuhuandi +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderResume_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = nullptr; + struct AudioPort renderPort = {}; + struct AudioRender *render = nullptr; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderResume API via the render is resumed after stopped + * @tc.number SUB_Audio_HDI_RenderResume_0002 + * @tc.desc test HDI RenderResume interface,return -1 if the render is resumed after stopped + * @tc.author: Xuhuandi +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderResume_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = nullptr; + struct AudioPort renderPort = {}; + struct AudioRender *render = nullptr; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderResume API via legal input + * @tc.number SUB_Audio_HDI_RenderResume_0003 + * @tc.desc Test AudioRenderResume interface,return 0 if the render is resumed after paused + * @tc.author: Xuhuandi +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderResume_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = nullptr; + struct AudioPort renderPort = {}; + struct AudioRender *render = nullptr; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderResume API via the interface is called twice in a row + * @tc.number SUB_Audio_HDI_RenderResume_0004 + * @tc.desc Test RenderResume interface,return -1 the second time if the RenderResume is called twice + * @tc.author: Xuhuandi +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderResume_0004, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = nullptr; + struct AudioPort renderPort = {}; + struct AudioRender *render = nullptr; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderResume API via the render Continue to start after resume + * @tc.number SUB_Audio_HDI_RenderResume_0005 + * @tc.desc test HDI RenderResume interface,return -1 if the render Continue to start after resume + * @tc.author: Xuhuandi +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderResume_0005, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = nullptr; + struct AudioPort renderPort = {}; + struct AudioRender *render = nullptr; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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); + EXPECT_EQ(HDF_FAILURE, ret); + + render->control.Stop((AudioHandle)render); + 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 +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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.Stop((AudioHandle)render); + EXPECT_EQ(HDF_SUCCESS, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test AudioCreateRender API via legal input. + * @tc.number SUB_Audio_HDI_CreateRender_0001 + * @tc.desc test AudioCreateRender interface,return 0 if render is created successful. + * @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = nullptr; + struct AudioPort renderPort = {}; + struct AudioRender *render = nullptr; + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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); +} +/** + * @tc.name Test AudioCreateRender API when two renders is created successful. + * @tc.number SUB_Audio_HDI_AudioCreateRender_0002 + * @tc.desc Test AudioCreateRender interface,return 0 when two renders is created successful. + * @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_AudioCreateRender_0002, TestSize.Level1) +{ + int32_t ret = -1; + 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(); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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); + manager.UnloadAdapter(&manager, adapter2); +} +/** + * @tc.name Test AudioCreateRender API via setting the incoming parameter pins is PIN_IN_MIC. + * @tc.number SUB_Audio_HDI_CreateRender_0003 + * @tc.desc test AudioCreateRender interface,return -1 if the incoming parameter pins is PIN_IN_MIC. + * @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = nullptr; + struct AudioPort renderPort = {}; + struct AudioRender *render = nullptr; + struct AudioSampleAttributes attrs = {}; + struct AudioDeviceDescriptor devDesc = {}; + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ASSERT_EQ(HDF_SUCCESS, ret); + + InitAttrs(attrs); + InitDevDesc(devDesc, renderPort.portId, PIN_IN_MIC); + + ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render); + EXPECT_EQ(HDF_FAILURE, ret); + manager.UnloadAdapter(&manager, adapter); +} + +/** + * @tc.name Test AudioCreateRender API via setting the incoming parameter attr is error. + * @tc.number SUB_Audio_HDI_CreateRender_0004 + * @tc.desc test AudioCreateRender interface,return -1 if the incoming parameter attr is error. + * @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0004, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = nullptr; + struct AudioPort renderPort = {}; + struct AudioRender *render = nullptr; + struct AudioSampleAttributes attrs = {}; + struct AudioDeviceDescriptor devDesc = {}; + uint32_t channelCountErr = 5; + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ASSERT_EQ(HDF_SUCCESS, ret); + + InitAttrs(attrs); + InitDevDesc(devDesc, renderPort.portId, PIN_OUT_SPEAKER); + attrs.format = AUDIO_FORMAT_AAC_MAIN; + ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render); + EXPECT_EQ(HDF_FAILURE, ret); + attrs.channelCount = channelCountErr; + ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render); + EXPECT_EQ(HDF_FAILURE, ret); + attrs.type = AUDIO_IN_COMMUNICATION; + ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render); + EXPECT_EQ(HDF_FAILURE, ret); + + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test AudioCreateRender API via setting the incoming parameter adapter is nullptr + * @tc.number SUB_Audio_HDI_CreateRender_0005 + * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter adapter is nullptr. + * @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0005, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = nullptr; + struct AudioPort renderPort = {}; + struct AudioRender *render = nullptr; + struct AudioAdapter *adapterNull = nullptr; + struct AudioSampleAttributes attrs = {}; + struct AudioDeviceDescriptor devDesc = {}; + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ASSERT_EQ(HDF_SUCCESS, ret); + + InitAttrs(attrs); + InitDevDesc(devDesc, renderPort.portId, PIN_OUT_SPEAKER); + + ret = adapter->CreateRender(adapterNull, &devDesc, &attrs, &render); + EXPECT_EQ(HDF_FAILURE, ret); + + manager.UnloadAdapter(&manager, adapter); +} + +/** + * @tc.name Test AudioCreateRender API via setting the incoming parameter devDesc is nullptr + * @tc.number SUB_Audio_HDI_CreateRender_0006 + * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter devDesc is nullptr. + * @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0006, TestSize.Level1) +{ + int32_t ret = -1; + 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); + ASSERT_EQ(HDF_SUCCESS, ret); + + InitAttrs(attrs); + + ret = adapter->CreateRender(adapter, devDescNull, &attrs, &render); + EXPECT_EQ(HDF_FAILURE, ret); + + manager.UnloadAdapter(&manager, adapter); +} + +/** + * @tc.name Test AudioCreateRender API via setting the incoming parameter attrs is nullptr + * @tc.number SUB_Audio_HDI_CreateRender_0007 + * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter attrs is nullptr. + * @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0007, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = nullptr; + struct AudioPort renderPort = {}; + 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); + ASSERT_EQ(HDF_SUCCESS, ret); + + InitDevDesc(devDesc, renderPort.portId, PIN_OUT_SPEAKER); + + ret = adapter->CreateRender(adapter, &devDesc, attrsNull, &render); + EXPECT_EQ(HDF_FAILURE, ret); + + manager.UnloadAdapter(&manager, adapter); +} + +/** + * @tc.name Test AudioCreateRender API via setting the incoming parameter render is nullptr + * @tc.number SUB_Audio_HDI_CreateRender_0008 + * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter render is nullptr. + * @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0008, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = nullptr; + struct AudioPort renderPort = {}; + struct AudioRender **renderNull = nullptr; + struct AudioSampleAttributes attrs = {}; + struct AudioDeviceDescriptor devDesc = {}; + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ASSERT_EQ(HDF_SUCCESS, ret); + + InitAttrs(attrs); + InitDevDesc(devDesc, renderPort.portId, PIN_OUT_SPEAKER); + + ret = adapter->CreateRender(adapter, &devDesc, &attrs, renderNull); + EXPECT_EQ(HDF_FAILURE, ret); + + manager.UnloadAdapter(&manager, adapter); +} + +/** + * @tc.name Test AudioCreateRender API via setting the incoming parameter devDesc is error + * @tc.number SUB_Audio_HDI_CreateRender_0009 + * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter devDesc is error. + * @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0009, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = nullptr; + struct AudioPort renderPort = {}; + struct AudioRender *render = nullptr; + struct AudioSampleAttributes attrs = {}; + struct AudioDeviceDescriptor devDesc = {}; + + ASSERT_NE(nullptr, GetAudioManager); + struct AudioManager manager = *GetAudioManager(); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + ASSERT_EQ(HDF_SUCCESS, ret); + + ret = InitAttrs(attrs); + InitDevDesc(devDesc, renderPort.portId, PIN_OUT_SPEAKER); + + devDesc.portId = -5; + ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render); + EXPECT_EQ(HDF_FAILURE, ret); + devDesc.pins = PIN_NONE; + ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render); + EXPECT_EQ(HDF_FAILURE, ret); + devDesc.desc = "devtestname"; + ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render); + EXPECT_EQ(HDF_FAILURE, ret); + + manager.UnloadAdapter(&manager, adapter); +} + +/** + * @tc.name Test AudioDestroyRender API via legal input. + * @tc.number SUB_Audio_HDI_DestroyRender_0001 + * @tc.desc Test AudioDestroyRender interface, return 0 if render is destroyed successful. + * @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_DestroyRender_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = nullptr; + struct AudioPort renderPort = {}; + struct AudioRender *render = nullptr; + struct AudioManager manager = *GetAudioManager(); + ASSERT_NE(nullptr, GetAudioManager); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test AudioDestroyRender API,where the parameter render is empty. + * @tc.number SUB_Audio_HDI_DestroyRender_0002 + * @tc.desc Test AudioDestroyRender interface, return -1 if the parameter render is empty. + * @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_DestroyRender_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioAdapter *adapter = nullptr; + struct AudioPort renderPort = {}; + 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); + 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); + manager.UnloadAdapter(&manager, adapter); +} + +/** + * @tc.name Test RenderFlush API via legal input Verify that the data in the buffer is flushed after stop + * @tc.number SUB_Audio_HDI_RenderFlush_0001 + * @tc.desc Test RenderFlush interface,return -2 if the data in the buffer is flushed successfully after stop + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderFlush_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @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.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderFlush_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager 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_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); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +} \ No newline at end of file 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 new file mode 100755 index 0000000000000000000000000000000000000000..37264cc9614c4c9dc4d94c603607116d28b7611b --- /dev/null +++ b/audio/test/systemtest/hdi/render/src/audio_hdirender_scene_test.cpp @@ -0,0 +1,620 @@ +/* + * 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 Defines audio-related APIs, including custom data types and functions for loading drivers, + * accessing a driver adapter, and rendering audios. + * + * @since 1.0 + * @version 1.0 + */ + +/** + * @file audio_hdi_common.h + * + * @brief Declares APIs for operations related to the audio render adapter. + * + * @since 1.0 + * @version 1.0 + */ + +#include "audio_hdi_common.h" +#include "audio_hdirender_scene_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"; +const string ADAPTER_NAME2 = "usb"; +const string ADAPTER_NAME3 = "internal"; + +class AudioHdiRenderSceneTest : public testing::Test { +public: + static void SetUpTestCase(void); + 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); +}; + +using THREAD_FUNC = void *(*)(void *); + +void AudioHdiRenderSceneTest::SetUpTestCase(void) {} + +void AudioHdiRenderSceneTest::TearDownTestCase(void) {} + +void AudioHdiRenderSceneTest::SetUp(void) +{ + char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; + handleSo = dlopen(resolvedPath, RTLD_LAZY); + if (handleSo == nullptr) { + return; + } + GetAudioManager = (struct AudioManager* (*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); + if (GetAudioManager == 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; + } + ret = InitDevDesc(devDesc, renderPort.portId, pins); + if (ret < 0) { + return HDF_FAILURE; + } + ret = adapter->CreateRender(adapter, &devDesc, &attrs, render); + if (ret < 0 || *render == nullptr) { + manager.UnloadAdapter(&manager, adapter); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHdiRenderSceneTest::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; +} + +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 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; +} + +/** +* @tc.name Test AudioRenderCheckSceneCapability API and check scene's capability +* @tc.number SUB_Audio_HDI_RenderCheckSceneCapability_0001 +* @tc.desc Test AudioRenderCheckSceneCapability interface,return 0 if check scene's capability successful. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0001, TestSize.Level1) +{ + int32_t ret = -1; + bool supported = false; + struct AudioSceneDescriptor scenes = {}; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + 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); + } + + scenes.scene.id = 0; + scenes.desc.pins = PIN_OUT_SPEAKER; + ret = render->scene.CheckSceneCapability(render, &scenes, &supported); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_TRUE(supported); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test checking scene's capability where the scene is not configed in the josn. +* @tc.number SUB_Audio_HDI_RenderCheckSceneCapability_0002 +* @tc.desc Test RenderCheckSceneCapability interface,return -1 if the scene is not configed in the josn. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0002, TestSize.Level1) +{ + int32_t ret = -1; + bool supported = true; + struct AudioSceneDescriptor scenes = {}; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + 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); + } + + scenes.scene.id = 5; + scenes.desc.pins = PIN_OUT_SPEAKER; + ret = render->scene.CheckSceneCapability(render, &scenes, &supported); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test checking scene's capability where the render is empty +* @tc.number SUB_Audio_HDI_RenderCheckSceneCapability_0003 +* @tc.desc Test AudioRenderCheckSceneCapability,return -1 if the render is empty. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0003, TestSize.Level1) +{ + int32_t ret = -1; + bool supported = true; + struct AudioSceneDescriptor scenes = {}; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + 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); + } + + scenes.scene.id = 0; + scenes.desc.pins = PIN_OUT_SPEAKER; + ret = render->scene.CheckSceneCapability(renderNull, &scenes, &supported); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderCheckSceneCapability API and check scene's capability +* @tc.number SUB_Audio_HDI_RenderCheckSceneCapability_0004 +* @tc.desc Test AudioRenderCheckSceneCapability interface,return -1 if the scene is empty. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0004, TestSize.Level1) +{ + int32_t ret = -1; + bool supported = true; + struct AudioSceneDescriptor *scenes = nullptr; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + 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 = render->scene.CheckSceneCapability(render, scenes, &supported); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderCheckSceneCapability API and check scene's capability +* @tc.number SUB_Audio_HDI_RenderCheckSceneCapability_0005 +* @tc.desc Test AudioRenderCheckSceneCapability interface,return -1 if the supported is empty. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0005, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioSceneDescriptor scenes = {}; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + 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); + } + + scenes.scene.id = 0; + scenes.desc.pins = PIN_OUT_SPEAKER; + ret = render->scene.CheckSceneCapability(render, &scenes, nullptr); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderSelectScene API via legal input +* @tc.number SUB_Audio_HDI_AudioRenderSelectScene_0001 +* @tc.desc Test AudioRenderSelectScene interface,return 0 if select Render's scene successful. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioSceneDescriptor scenes = {}; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + 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); + } + + scenes.scene.id = 0; + scenes.desc.pins = PIN_OUT_SPEAKER; + + ret = render->scene.SelectScene(render, &scenes); + EXPECT_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); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderSelectScene API after Render start. +* @tc.number SUB_Audio_HDI_AudioRenderSelectScene_0002 +* @tc.desc Test AudioRenderSelectScene, return 0 if select Render's scene successful after Render start. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioSceneDescriptor scenes = {}; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + 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); + + scenes.scene.id = 0; + scenes.desc.pins = PIN_OUT_SPEAKER; + ret = render->scene.SelectScene(render, &scenes); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = render->control.Stop((AudioHandle)render); + EXPECT_EQ(HDF_SUCCESS, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderSelectScene API where the parameter handle is empty. +* @tc.number SUB_Audio_HDI_AudioRenderSelectScene_0003 +* @tc.desc Test AudioRenderSelectScene, return -1 if the parameter handle is empty. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioSceneDescriptor scenes = {}; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + 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); + } + + scenes.scene.id = 0; + scenes.desc.pins = PIN_IN_MIC; + ret = render->scene.SelectScene(renderNull, &scenes); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderSelectScene API where the parameter scene is empty. +* @tc.number SUB_Audio_HDI_AudioRenderSelectScene_0004 +* @tc.desc Test AudioRenderSelectScene, return -1 if the parameter scene is empty. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0004, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioSceneDescriptor *scenes = nullptr; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + 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 = render->scene.SelectScene(render, scenes); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderSelectScene API where the scene is not configed in the josn. +* @tc.number SUB_Audio_HDI_AudioRenderSelectScene_0005 +* @tc.desc Test AudioRenderSelectScene, return -1 if the scene is not configed in the josn. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0005, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioSceneDescriptor scenes = {}; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + 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); + } + + scenes.scene.id = 5; + scenes.desc.pins = PIN_OUT_HDMI; + ret = render->scene.SelectScene(render, &scenes); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +} \ No newline at end of file diff --git a/audio/test/systemtest/hdi/render/src/audio_hdirender_test.cpp b/audio/test/systemtest/hdi/render/src/audio_hdirender_test.cpp new file mode 100755 index 0000000000000000000000000000000000000000..d0b1cf7999ee2bc7f826c85ff6a865f270637c98 --- /dev/null +++ b/audio/test/systemtest/hdi/render/src/audio_hdirender_test.cpp @@ -0,0 +1,1571 @@ +/* + * 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 Defines audio-related APIs, including custom data types and functions for loading drivers, + * accessing a driver adapter, and rendering audios. + * + * @since 1.0 + * @version 1.0 + */ + +/** + * @file audio_hdi_common.h + * + * @brief Declares APIs for operations related to the audio render adapter. + * + * @since 1.0 + * @version 1.0 + */ + +#include "audio_hdi_common.h" +#include "audio_hdirender_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"; +const string ADAPTER_NAME2 = "usb"; +const string ADAPTER_NAME3 = "internal"; + +class AudioHdiRenderTest : public testing::Test { +public: + static void SetUpTestCase(void); + 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); +}; + +using THREAD_FUNC = void *(*)(void *); + +void AudioHdiRenderTest::SetUpTestCase(void) {} + +void AudioHdiRenderTest::TearDownTestCase(void) {} + +void AudioHdiRenderTest::SetUp(void) +{ + char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; + handleSo = dlopen(resolvedPath, RTLD_LAZY); + if (handleSo == nullptr) { + return; + } + GetAudioManager = (struct AudioManager* (*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); + if (GetAudioManager == 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]; + } + } + 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 AudioHdiRenderTest::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; + } + ret = InitDevDesc(devDesc, renderPort.portId, pins); + if (ret < 0) { + return HDF_FAILURE; + } + ret = adapter->CreateRender(adapter, &devDesc, &attrs, render); + if (ret < 0 || *render == nullptr) { + manager.UnloadAdapter(&manager, adapter); + return HDF_FAILURE; + } + 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; +} + +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 AudioHdiRenderTest::GetLoadAdapterAudioPara(struct PrepareAudioPara& audiopara) +{ + int32_t ret = -1; + int size = 0; + auto *inst = (AudioHdiRenderTest *)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 AudioHdiRenderTest::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; +} + +/** +* @tc.name Test RenderGetLatency API via legal +* @tc.number SUB_Audio_HDI_RenderGetLatency_0001 +* @tc.desc test RenderGetLatency interface, return 0 if GetLatency successful +* @tc.author: wangkang +*/ +HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetLatency_0001, TestSize.Level1) +{ + int32_t ret = -1; + uint32_t latencyTime = 0; + uint32_t hopeVolume = 0; + 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(); + ASSERT_NE(nullptr, GetAudioManager); + + ret = GetLoadAdapter(manager, audioPortType, ADAPTER_NAME2, &adapter, audioPort); + 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); + + ret = render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test RenderGetLatency API via Setting parameters render is empty +* @tc.number SUB_Audio_HDI_AudioRenderGetLatency_0002 +* @tc.desc test RenderGetLatency interface, return -1 if Setting parameters render is empty +* @tc.author: wangkang +*/ +HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetLatency_0002, TestSize.Level1) +{ + 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); + 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); + + ret = render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test RenderGetLatency API via Setting parameters ms is empty +* @tc.number SUB_Audio_HDI_AudioRenderGetLatency_0003 +* @tc.desc test RenderGetLatency interface,return -1 if Setting parameters ms is empty +* @tc.author: wangkang +*/ +HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetLatency_0003, TestSize.Level1) +{ + 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(); + ASSERT_NE(nullptr, GetAudioManager); + + ret = GetLoadAdapter(manager, audioPortType, ADAPTER_NAME2, &adapter, audioPort); + 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); + + ret = render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test SetRenderSpeed API via legal + * @tc.number SUB_Audio_HDI_AudioRenderSetRenderSpeed_0001 + * @tc.desc Test SetRenderSpeed interface,return -2 if setting RenderSpeed + * @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + 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); + + render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test SetRenderSpeed API via setting the incoming parameter handle is nullptr + * @tc.number SUB_Audio_HDI_AudioRenderSetRenderSpeed_0002 + * @tc.desc Test SetRenderSpeed interface,return -2 if the incoming parameter handle is nullptr + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetRenderSpeed_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager manager = {}; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + 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); + 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); + + render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test GetRenderSpeed API via legal + * @tc.number SUB_Audio_HDI_AudioRenderGetRenderSpeed_0001 + * @tc.desc Test GetRenderSpeed interface,return -2 if getting RenderSpeed + * @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + 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); + + render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test GetRenderSpeed API via setting the incoming parameter handle is nullptr + * @tc.number SUB_Audio_HDI_AudioRenderGetRenderSpeed_0002 + * @tc.desc Test GetRenderSpeed interface,return -2 if the incoming parameter handle is nullptr + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderSpeed_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager manager = {}; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + 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); + 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); + + render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test GetRenderSpeed API via setting the incoming parameter speed is nullptr + * @tc.number SUB_Audio_HDI_AudioRenderGetRenderSpeed_0002 + * @tc.desc Test GetRenderSpeed interface,return -2 if the incoming parameter speed is nullptr + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderSpeed_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager manager = {}; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + struct AudioRender *render = nullptr; + float *speedNull = nullptr; + + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + 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); + + render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderFrame API via legal input +* @tc.number SUB_Audio_HDI_AudioRenderFrame_0001 +* @tc.desc test AudioRenderFrame interface,Returns 0 if the data is written successfully +* @tc.author: liweiming +*/ +HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderFrame_0001, 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; + 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); + 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); + + ret = RenderFramePrepare(AUDIO_FILE, frame, requestBytes); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->RenderFrame(render, frame, requestBytes, &replyBytes); + EXPECT_EQ(HDF_SUCCESS, ret); + + render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); + if (frame != nullptr) { + free(frame); + frame = nullptr; + } +} +/** +* @tc.name Test AudioRenderFrame API via setting the incoming parameter render is nullptr +* @tc.number SUB_Audio_HDI_AudioRenderFrame_0002 +* @tc.desc Test AudioRenderFrame interface,Returns -1 if the incoming parameter render is nullptr +* @tc.author: liweiming +*/ +HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderFrame_0002, 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; + 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); + 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); + + ret = RenderFramePrepare(AUDIO_FILE, frame, requestBytes); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->RenderFrame(renderNull, frame, requestBytes, &replyBytes); + EXPECT_EQ(HDF_FAILURE, ret); + + ret = render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); + if (frame != nullptr) { + free(frame); + frame = nullptr; + } +} +/** +* @tc.name Test AudioRenderFrame API via setting the incoming parameter frame is nullptr +* @tc.number SUB_Audio_HDI_AudioRenderFrame_0003 +* @tc.desc Test AudioRenderFrame interface,Returns -1 if the incoming parameter frame is nullptr +* @tc.author: liweiming +*/ +HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderFrame_0003, 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; + 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); + 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); + + ret = render->RenderFrame(render, frame, requestBytes, &replyBytes); + EXPECT_EQ(HDF_FAILURE, ret); + ret = render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderFrame API via setting the incoming parameter replyBytes is nullptr +* @tc.number SUB_Audio_HDI_AudioRenderFrame_0004 +* @tc.desc Test AudioRenderFrame interface,Returns -1 if the incoming parameter replyBytes is nullptr +* @tc.author: liweiming +*/ +HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderFrame_0004, TestSize.Level1) +{ + 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); + 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); + + ret = RenderFramePrepare(AUDIO_FILE, frame, requestBytes); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->RenderFrame(render, frame, requestBytes, replyBytes); + EXPECT_EQ(HDF_FAILURE, ret); + + ret = render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); + if (frame != nullptr) { + free(frame); + frame = nullptr; + } +} +/** +* @tc.name Test AudioRenderFrame API without calling interface renderstart +* @tc.number SUB_Audio_HDI_AudioRenderFrame_0005 +* @tc.desc Test AudioRenderFrame interface,Returns -1 if without calling interface renderstart +* @tc.author: liweiming +*/ +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; + 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); + 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); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); + if (frame != nullptr) { + free(frame); + frame = nullptr; + } +} +/** + * @tc.name Test SetChannelMode API via setting channel mode to different enumeration values + * @tc.number SUB_Audio_HDI_AudioRenderSetChannelMode_0001 + * @tc.desc Test SetChannelMode interface,return 0 if set channel mode to different enumeration values + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetChannelMode_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager manager = {}; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + struct AudioRender *render = nullptr; + enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; + enum AudioChannelMode modeOne = AUDIO_CHANNEL_BOTH_LEFT; + enum AudioChannelMode modeSec = AUDIO_CHANNEL_BOTH_RIGHT; + enum AudioChannelMode modeTrd = AUDIO_CHANNEL_EXCHANGE; + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + 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); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode); + ret = render->SetChannelMode(render, modeOne); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetChannelMode(render, &modeOne); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_CHANNEL_BOTH_LEFT, modeOne); + ret = render->SetChannelMode(render, modeSec); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetChannelMode(render, &modeSec); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_CHANNEL_BOTH_RIGHT, modeSec); + ret = render->SetChannelMode(render, modeTrd); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetChannelMode(render, &modeTrd); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_CHANNEL_EXCHANGE, modeTrd); + render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test SetChannelMode API via setting channel mode to different values + * @tc.number SUB_Audio_HDI_AudioRenderSetChannelMode_0002 + * @tc.desc Test SetChannelMode interface,return 0 if set channel mode to different values + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetChannelMode_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager manager = {}; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + struct AudioRender *render = nullptr; + enum AudioChannelMode mode = AUDIO_CHANNEL_MIX; + enum AudioChannelMode modeOne = AUDIO_CHANNEL_LEFT_MUTE; + enum AudioChannelMode modeSec = AUDIO_CHANNEL_RIGHT_MUTE; + enum AudioChannelMode modeTrd = AUDIO_CHANNEL_BOTH_MUTE; + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + 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); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_CHANNEL_MIX, mode); + ret = render->SetChannelMode(render, modeOne); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetChannelMode(render, &modeOne); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_CHANNEL_LEFT_MUTE, modeOne); + ret = render->SetChannelMode(render, modeSec); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetChannelMode(render, &modeSec); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_CHANNEL_RIGHT_MUTE, modeSec); + ret = render->SetChannelMode(render, modeTrd); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetChannelMode(render, &modeTrd); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_CHANNEL_BOTH_MUTE, modeTrd); + render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test SetChannelMode API via setting channel mode after render object is created + * @tc.number SUB_Audio_HDI_AudioRenderSetChannelMode_0003 + * @tc.desc Test SetChannelMode interface,return 0 if set channel mode after render object is created + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetChannelMode_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager manager = {}; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + 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); + 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); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test SetChannelMode API via setting the parameter render is nullptr + * @tc.number SUB_Audio_HDI_AudioRenderSetChannelMode_0004 + * @tc.desc Test SetChannelMode interface,return -1 if set the parameter render is nullptr + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetChannelMode_0004, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager manager = {}; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + struct AudioRender *render = nullptr; + struct AudioRender *renderNull = nullptr; + enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; + + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + 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); +} +/** + * @tc.name Test GetChannelMode API via getting the channel mode after setting + * @tc.number SUB_Audio_HDI_AudioRenderGetChannelMode_0001 + * @tc.desc Test GetChannelMode interface,return 0 if getting the channel mode after setting + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetChannelMode_0001, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager manager = {}; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + 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); + 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); + ret = render->SetChannelMode(render, mode); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetChannelMode(render, &mode); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode); + + render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test GetChannelMode API via getting the parameter render is nullptr + * @tc.number SUB_Audio_HDI_AudioRenderGetChannelMode_0002 + * @tc.desc Test GetChannelMode interface,return -1 if getting the parameter render is nullptr + * @tc.author: tiansuli +*/ +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; + struct AudioRender *renderNull = nullptr; + enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL; + + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + 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); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test GetChannelMode API via getting the channel mode after the render object is created + * @tc.number SUB_Audio_HDI_AudioRenderGetChannelMode_0003 + * @tc.desc Test GetChannelMode interface,return 0 if getting the channel mode after the object is created + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetChannelMode_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager manager = {}; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + 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); + 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); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test GetRenderPosition API via legal input +* @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0001 +* @tc.desc Test GetRenderPosition interface,Returns 0 if get RenderPosition during playing. +* @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0001, 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); + 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(3); + 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 = (int32_t)result; + EXPECT_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 Test AudioRenderGetRenderPosition API via get RenderPosition after the audio file is Paused and resumed +* @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0002 +* @tc.desc Test GetRenderPosition interface,Returns 0 if get RenderPosition after Pause and resume during playing +* @tc.author: tiansuli +*/ +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}; + 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); + 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(3); + 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(frames, INITIAL_VALUE); + sleep(5); + 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(frames, INITIAL_VALUE); + + void *result = nullptr; + pthread_join(tids, &result); + ret = (int32_t)result; + EXPECT_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 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.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); + 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(3); + 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 = (int32_t)result; + EXPECT_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 Test AudioRenderGetRenderPosition API via setting the parameter render is nullptr + * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0004 + * @tc.desc Test AudioRenderGetRenderPosition interface, return -1 if setting the parameter render is nullptr + * @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + 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); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test AudioRenderGetRenderPosition API via setting the parameter render is nullptr + * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0005 + * @tc.desc Test AudioRenderGetRenderPosition interface, return -1 if setting the parameter render is nullptr + * @tc.author: tiansuli +*/ +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 = {}; + + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + 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); + + render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test AudioRenderGetRenderPosition API via setting the parameter frames is nullptr + * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0006 + * @tc.desc Test AudioRenderGetRenderPosition interface, return -1 if setting the parameter frames is nullptr + * @tc.author: tiansuli +*/ +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}; + + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + 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); + + render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test AudioRenderGetRenderPosition API via setting the parameter time is nullptr + * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0007 + * @tc.desc Test AudioRenderGetRenderPosition interface, return -1 if setting the parameter time is nullptr + * @tc.author: tiansuli +*/ +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; + struct AudioTimeStamp *timeNull = nullptr; + + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + 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); + + render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test AudioRenderGetRenderPosition API via get RenderPosition continuously + * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0008 + * @tc.desc Test AudioRenderGetRenderPosition interface, return 0 if the GetRenderPosition was called twice + * @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + 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(frames, INITIAL_VALUE); + + render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test GetRenderPosition API via define format to AUDIO_FORMAT_PCM_16_BIT + * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0009 + * @tc.desc Test GetRenderPosition interface,return 0 if get framesize define format to AUDIO_FORMAT_PCM_16_BIT + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0009, TestSize.Level1) +{ + int32_t ret = -1; + 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(); + ASSERT_NE(nullptr, GetAudioManager); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + 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); + 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 = AudioRenderStart(AUDIO_FILE, render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetRenderPosition(render, &frames, &time); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(time.tvSec, timeExp); + EXPECT_GT(frames, INITIAL_VALUE); + + render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test GetRenderPosition API via define format to AUDIO_FORMAT_PCM_24_BIT + * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0010 + * @tc.desc Test GetRenderPosition interface,return 0 if get framesize define format to AUDIO_FORMAT_PCM_24_BIT + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0010, TestSize.Level1) +{ + int32_t ret = -1; + 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(); + ASSERT_NE(nullptr, GetAudioManager); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + 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); + 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 = AudioRenderStart(AUDIO_FILE, render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetRenderPosition(render, &frames, &time); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(time.tvSec, timeExp); + EXPECT_GT(frames, INITIAL_VALUE); + + render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test GetRenderPosition API via define sampleRate and channelCount to different value + * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0011 + * @tc.desc Test GetRenderPosition interface,return 0 if get framesize define channelCount as different values + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0011, TestSize.Level1) +{ + int32_t ret = -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(); + ASSERT_NE(nullptr, GetAudioManager); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + 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); + 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 = AudioRenderStart(AUDIO_FILE, render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetRenderPosition(render, &frames, &time); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(time.tvSec, timeExp); + EXPECT_GT(frames, INITIAL_VALUE); + + render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test GetRenderPosition API via define sampleRate and channelCount to 1 + * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0012 + * @tc.desc Test GetRenderPosition interface,return 0 if get framesize define channelCount to 1 + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0012, TestSize.Level1) +{ + int32_t ret = -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(); + ASSERT_NE(nullptr, GetAudioManager); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + 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); + 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 = AudioRenderStart(AUDIO_FILE, render); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->GetRenderPosition(render, &frames, &time); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(time.tvSec, timeExp); + EXPECT_GT(frames, INITIAL_VALUE); + + render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +} \ No newline at end of file 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 new file mode 100755 index 0000000000000000000000000000000000000000..424101a1bf89acbc26528aebd66c6fb7f112cbdb --- /dev/null +++ b/audio/test/systemtest/hdi/render/src/audio_hdirender_volume_test.cpp @@ -0,0 +1,1015 @@ +/* + * 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 Defines audio-related APIs, including custom data types and functions for loading drivers, + * accessing a driver adapter, and rendering audios. + * + * @since 1.0 + * @version 1.0 + */ + +/** + * @file audio_hdi_common.h + * + * @brief Declares APIs for operations related to the audio render adapter. + * + * @since 1.0 + * @version 1.0 + */ + +#include "audio_hdi_common.h" +#include "audio_hdirender_volume_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"; +const string ADAPTER_NAME2 = "usb"; +const string ADAPTER_NAME3 = "internal"; + +class AudioHdiRenderVolumeTest : public testing::Test { +public: + static void SetUpTestCase(void); + 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; +}; + +void AudioHdiRenderVolumeTest::SetUpTestCase(void) {} + +void AudioHdiRenderVolumeTest::TearDownTestCase(void) {} + +void AudioHdiRenderVolumeTest::SetUp(void) +{ + char resolvedPath[] = "//system/lib/libaudio_hdi_proxy_server.z.so"; + handleSo = dlopen(resolvedPath, RTLD_LAZY); + if (handleSo == nullptr) { + return; + } + GetAudioManager = (struct AudioManager* (*)())(dlsym(handleSo, "GetAudioProxyManagerFuncs")); + if (GetAudioManager == 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]; + } + } + 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 AudioHdiRenderVolumeTest::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; + } + ret = InitDevDesc(devDesc, renderPort.portId, pins); + if (ret < 0) { + return HDF_FAILURE; + } + ret = adapter->CreateRender(adapter, &devDesc, &attrs, render); + if (ret < 0 || *render == nullptr) { + manager.UnloadAdapter(&manager, adapter); + return HDF_FAILURE; + } + 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; +} +/** + * @tc.name Test RenderGetGainThreshold API via legal input + * @tc.number SUB_Audio_HDI_RenderGetGainThreshold_0001 + * @tc.desc Test RenderGetGainThreshold interface,return 0 if the GetGainThreshold is obtained successfully + * @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + 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); + EXPECT_EQ(min, GAIN_MIN); + EXPECT_EQ(max, GAIN_MAX); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderGetGainThreshold API via set the parameter render to nullptr + * @tc.number SUB_Audio_HDI_RenderGetGainThreshold_0002 + * @tc.desc Test RenderGetGainThreshold interface, return -1 if set render to nullptr + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGainThreshold_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager manager = {}; + 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); + 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); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderGetGainThreshold API via set the parameter min to nullptr + * @tc.number SUB_Audio_HDI_RenderGetGainThreshold_0003 + * @tc.desc Test RenderGetGainThreshold interface, return -1 if set min to nullptr + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGainThreshold_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager manager = {}; + 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); + 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); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderGetGainThreshold API via set the parameter max to nullptr + * @tc.number SUB_Audio_HDI_RenderGetGainThreshold_0004 + * @tc.desc Test RenderGetGainThreshold interface, return -1 if set max to nullptr + * @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + 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); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderSetGain API via legal input + * @tc.number SUB_Audio_HDI_RenderSetGain_0001 + * @tc.desc Test RenderSetGain interface,return 0 if Set gain to normal value, maximum or minimum and get success + * @tc.author: tiansuli +*/ +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; + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + 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; + float gainMax = max; + float gainMin = min; + float gainExpc = 10; + float gainMaxExpc = max; + float gainMinExpc = min; + ret = render->volume.SetGain(render, gain); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->volume.GetGain(render, &gain); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(gainExpc, gain); + + ret = render->volume.SetGain(render, gainMax); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->volume.GetGain(render, &gainMax); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(gainMaxExpc, gainMax); + + ret = render->volume.SetGain(render, gainMin); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->volume.GetGain(render, &gainMin); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(gainMinExpc, gainMin); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderSetGain API via set gain to the boundary value + * @tc.number SUB_Audio_HDI_RenderSetGain_0002 + * @tc.desc Test RenderSetGain interface,return -1 if Set gain to exceed the boundary value + * @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + 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 gainOne = max+1; + float gainSec = min-1; + ret = render->volume.SetGain(render, gainOne); + EXPECT_EQ(HDF_FAILURE, ret); + + ret = render->volume.SetGain(render, gainSec); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderSetGain API via set gain to exception type + * @tc.number SUB_Audio_HDI_RenderSetGain_0003 + * @tc.desc Test RenderSetGain interface,return -1 if set gain to exception type + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderSetGain_0003, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager manager = {}; + 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); + 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); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderSetGain API via set the parameter render to nullptr + * @tc.number SUB_Audio_HDI_RenderSetGain_0004 + * @tc.desc Test RenderSetGain interface, return -1 if set render to nullptr + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderSetGain_0004, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager manager = {}; + 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); + 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); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderGetGain API via legal input + * @tc.number SUB_Audio_HDI_RenderGetGain_0001 + * @tc.desc Test RenderGetGain interface,return 0 if the RenderGetGain was obtained successfully + * @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + 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 = min+1; + float gainValue = min+1; + ret = render->volume.SetGain(render, gain); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->volume.GetGain(render, &gain); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(gainValue, gain); + + render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderGetGain API via set the parameter render to nullptr + * @tc.number SUB_Audio_HDI_RenderGetGain_0002 + * @tc.desc Test RenderGetGain interface, return -1 if get gain set render to nullptr + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGain_0002, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager manager = {}; + 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); + 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); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderGetGain API via legal input in difference scenes + * @tc.number SUB_Audio_HDI_RenderGetGain_0003 + * @tc.desc Test RenderGetGainThreshold interface, return 0 if get gain before start successfully + * @tc.author: tiansuli +*/ +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; + + ASSERT_NE(nullptr, GetAudioManager); + manager = *GetAudioManager(); + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME2, &adapter, renderPort); + 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); + ret = render->volume.GetGain(render, &gain); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(gain, gainOne); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** + * @tc.name Test RenderGetGain API via set the parameter gain to nullptr + * @tc.number SUB_Audio_HDI_RenderGetGain_0004 + * @tc.desc Test RenderGetGain interface, return -1 if get gain set gain to nullptr + * @tc.author: tiansuli +*/ +HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGain_0004, TestSize.Level1) +{ + int32_t ret = -1; + struct AudioManager manager = {}; + 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); + 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); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderSetMute API via legal input. +* @tc.number SUB_Audio_HDI_AudioRenderSetMute_0001 +* @tc.desc Test AudioRenderSetMute interface , return 0 if the audiorender object sets mute successfully. +* @tc.author:ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderSetMute_0001, TestSize.Level1) +{ + int32_t ret = -1; + bool muteFalse = false; + bool muteTrue = true; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + struct AudioRender *render = nullptr; + struct AudioManager manager = *GetAudioManager(); + ASSERT_NE(nullptr, GetAudioManager); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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); + ret = render->volume.GetMute(render, &muteFalse); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(false, muteFalse); + + ret = render->volume.SetMute(render, muteTrue); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->volume.GetMute(render, &muteTrue); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(true, muteTrue); + + muteTrue = false; + ret = render->volume.SetMute(render, muteTrue); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_FALSE(muteTrue); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderSetMute API via setting the incoming parameter render is empty . +* @tc.number SUB_Audio_HDI_AudioRenderSetMute_0002 +* @tc.desc Test AudioRenderSetMute interface, return -1 if the incoming parameter render is empty. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderSetMute_0002, TestSize.Level1) +{ + int32_t ret = -1; + bool mute = true; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + 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); + 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); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderSetMute API,when the parameter mutevalue equals 2. +* @tc.number SUB_Audio_HDI_AudioRenderSetMute_0003 +* @tc.desc Test AudioRenderSetMute interface and set the parameter mutevalue with 2. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderSetMute_0003, TestSize.Level1) +{ + int32_t ret = -1; + bool muteValue = 2; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + struct AudioRender *render = nullptr; + struct AudioManager manager = *GetAudioManager(); + ASSERT_NE(nullptr, GetAudioManager); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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); + ret = render->volume.GetMute(render, &muteValue); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(true, muteValue); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderGetMute API via legal input. +* @tc.number SUB_Audio_HDI_AudioRenderGetMute_0001 +* @tc.desc Test AudioRenderGetMute interface , return 0 if the audiocapture gets mute successfully. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderGetMute_0001, TestSize.Level1) +{ + int32_t ret = -1; + bool muteTrue = true; + bool muteFalse = false; + bool defaultmute = true; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + struct AudioRender *render = nullptr; + struct AudioManager manager = *GetAudioManager(); + ASSERT_NE(nullptr, GetAudioManager); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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); + EXPECT_EQ(muteTrue, defaultmute); + + ret = render->volume.SetMute(render, muteFalse); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = render->volume.GetMute(render, &muteFalse); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_FALSE(muteFalse); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test interface AudioRenderGetMute when incoming parameter render is empty. +* @tc.number SUB_Audio_HDI_AudioRenderGetMute_0002 +* @tc.desc Test AudioRenderGetMute interface, return -1 if the incoming parameter render is empty. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderGetMute_0002, TestSize.Level1) +{ + int32_t ret = -1; + bool muteTrue = true; + bool muteFalse = false; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + 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); + 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); + + ret = render->volume.GetMute(renderNull, &muteFalse); + EXPECT_EQ(HDF_FAILURE, ret); + + ret = render->volume.GetMute(render, nullptr); + EXPECT_EQ(HDF_FAILURE, ret); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderSetVolume API via legal input. +* @tc.number SUB_Audio_HDI_AudioRenderSetVolume_0001 +* @tc.desc Test AudioRenderSetVolume interface , return 0 if the audiocapture sets volume successfully. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderSetVolume_0001, TestSize.Level1) +{ + int32_t ret = -1; + float volumeInit = 0.30; + float volumeInitExpc = 0.30; + 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 = {}; + struct AudioRender *render = nullptr; + struct AudioManager manager = *GetAudioManager(); + ASSERT_NE(nullptr, GetAudioManager); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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); + ret = render->volume.GetVolume(render, &volumeInit); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(volumeInitExpc, volumeInit); + ret = render->volume.SetVolume(render, volumeLow); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->volume.GetVolume(render, &volumeLow); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(volumeLowExpc, volumeLow); + ret = render->volume.SetVolume(render, volumeMid); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->volume.GetVolume(render, &volumeMid); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(volumeMidExpc, volumeMid); + ret = render->volume.SetVolume(render, volumeHigh); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->volume.GetVolume(render, &volumeHigh); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(volumeHighExpc, volumeHigh); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderSetVolume,when volume is set maximum value or minimum value. +* @tc.number SUB_Audio_HDI_AudioRenderSetVolume_0002 +* @tc.desc Test AudioRenderSetVolume,return 0 if volume is set maximum value or minimum value. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderSetVolume_0002, TestSize.Level1) +{ + int32_t ret = -1; + float volumeMin = 0; + float volumeMinExpc = 0; + float volumeMax = 1.0; + float volumeMaxExpc = 1.0; + float volumeMinBoundary = -1; + float volumeMaxBoundary = 1.01; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + struct AudioRender *render = nullptr; + struct AudioManager manager = *GetAudioManager(); + ASSERT_NE(nullptr, GetAudioManager); + + ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort); + 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); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(volumeMinExpc, volumeMin); + + ret = render->volume.SetVolume(render, volumeMax); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->volume.GetVolume(render, &volumeMax); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(volumeMaxExpc, volumeMax); + + ret = render->volume.SetVolume(render, volumeMinBoundary); + EXPECT_EQ(HDF_FAILURE, ret); + + ret = render->volume.SetVolume(render, volumeMaxBoundary); + EXPECT_EQ(HDF_FAILURE, ret); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderSetVolume,when incoming parameter render is empty. +* @tc.number SUB_Audio_HDI_AudioRenderSetVolume_0003 +* @tc.desc Test AudioRenderSetVolume,return -1 when incoming parameter render is empty. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderSetVolume_0003, TestSize.Level1) +{ + int32_t ret = -1; + float volume = 0; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + 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); + 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); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderGetVolume API via legal input. +* @tc.number SUB_Audio_HDI_AudioRenderGetVolume_001 +* @tc.desc Test AudioRenderGetVolume interface , return 0 if the audiocapture is get successful. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderGetVolume_001, TestSize.Level1) +{ + int32_t ret = -1; + float volume = 0.30; + float volumeDefault = 0.30; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + 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 = render->volume.SetVolume(render, volume); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->volume.GetVolume(render, &volume); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(volumeDefault, volume); + + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderGetVolume when when capturing is in progress. +* @tc.number SUB_Audio_HDI_AudioRenderGetVolume_002. +* @tc.desc Test AudioRenderGetVolume,return 0 when when capturing is in progress. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderGetVolume_002, TestSize.Level1) +{ + int32_t ret = -1; + float volume = 0.30; + float defaultVolume = 0.30; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + 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); + + ret = render->volume.SetVolume(render, volume); + EXPECT_EQ(HDF_SUCCESS, ret); + ret = render->volume.GetVolume(render, &volume); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_EQ(defaultVolume, volume); + + ret = render->control.Stop((AudioHandle)render); + EXPECT_EQ(HDF_SUCCESS, ret); + adapter->DestroyRender(adapter, render); + manager.UnloadAdapter(&manager, adapter); +} +/** +* @tc.name Test AudioRenderGetVolume,when incoming parameter render is empty. +* @tc.number SUB_Audio_HDI_AudioRenderGetVolume_0003 +* @tc.desc Test AudioRenderGetVolume,return -1 when incoming parameter render is empty. +* @tc.author: ZHANGHAILIN +*/ +HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderGetVolume_0003, TestSize.Level1) +{ + int32_t ret = -1; + float volume = 0; + struct AudioPort renderPort = {}; + struct AudioAdapter *adapter = {}; + 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); + 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); + manager.UnloadAdapter(&manager, adapter); +} +} \ No newline at end of file diff --git a/audio/test/unittest/BUILD.gn b/audio/test/unittest/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..51f10aa81c1e06c7b78ff255c916b2c8c177d01f --- /dev/null +++ b/audio/test/unittest/BUILD.gn @@ -0,0 +1,56 @@ +# Copyright (c) Huawei Technologies Co., Ltd. 2019-2019. All rights reserved. + +import("//build/test.gni") +import("//drivers/adapter/uhdf2/uhdf.gni") + +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" + ] + + include_dirs = [ + "//drivers/peripheral/audio/test/unittest/common", + "//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/adapter/uhdf2/osal/include", + ] + + 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", + ] + + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] +} + +group("unittest") { + testonly = true + deps = [ ":AudioHdiTest" ] +} diff --git a/audio/test/unittest/common/audio_adapter_test.cpp b/audio/test/unittest/common/audio_adapter_test.cpp new file mode 100755 index 0000000000000000000000000000000000000000..1b090e06b4444b708dc0472547523274dd831261 --- /dev/null +++ b/audio/test/unittest/common/audio_adapter_test.cpp @@ -0,0 +1,258 @@ +/* + * 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_internal.h" +#include +#include + +using namespace std; +using namespace testing::ext; +namespace { +class AudioAdapterTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); +}; + +void AudioAdapterTest::SetUpTestCase() +{ +} + +void AudioAdapterTest::TearDownTestCase() +{ +} + +HWTEST_F(AudioAdapterTest, AudioAdapterCreateRenderWhenAdapterIsNull, TestSize.Level0) +{ + struct AudioAdapter *adapter = nullptr; + const struct AudioDeviceDescriptor *desc = new AudioDeviceDescriptor; + const struct AudioSampleAttributes *attrs = new AudioSampleAttributes; + struct AudioRender *render; + int32_t ret = AudioAdapterCreateRender(adapter, desc, attrs, &render); + EXPECT_EQ(HDF_FAILURE, ret); + delete(desc); + desc = nullptr; + delete(attrs); + attrs = nullptr; +} + +HWTEST_F(AudioAdapterTest, AudioAdapterCreateRenderWhenDescIsNull, TestSize.Level0) +{ + struct AudioAdapter *adapter = new AudioAdapter; + const struct AudioDeviceDescriptor *desc = nullptr; + const struct AudioSampleAttributes *attrs = new AudioSampleAttributes; + struct AudioRender *render; + int32_t ret = AudioAdapterCreateRender(adapter, desc, attrs, &render); + EXPECT_EQ(HDF_FAILURE, ret); + delete(adapter); + adapter = nullptr; + delete(attrs); + attrs = nullptr; +} + +HWTEST_F(AudioAdapterTest, AudioAdapterCreateRenderWhenAttrsIsNull, TestSize.Level0) +{ + struct AudioAdapter *adapter = new AudioAdapter; + const struct AudioDeviceDescriptor *desc = new AudioDeviceDescriptor; + const struct AudioSampleAttributes *attrs = nullptr; + struct AudioRender *render; + int32_t ret = AudioAdapterCreateRender(adapter, desc, attrs, &render); + EXPECT_EQ(HDF_FAILURE, ret); + delete(adapter); + adapter = nullptr; + delete(desc); + desc = nullptr; +} + +HWTEST_F(AudioAdapterTest, AudioAdapterCreateRenderWhenRenderIsNull, TestSize.Level0) +{ + struct AudioAdapter *adapter = new AudioAdapter; + const struct AudioDeviceDescriptor *desc = new AudioDeviceDescriptor; + const struct AudioSampleAttributes *attrs = new AudioSampleAttributes; + struct AudioRender **render = nullptr; + int32_t ret = AudioAdapterCreateRender(adapter, desc, attrs, render); + EXPECT_EQ(HDF_FAILURE, ret); + delete(adapter); + adapter = nullptr; + delete(desc); + desc = nullptr; + delete(attrs); + attrs = nullptr; +} + +HWTEST_F(AudioAdapterTest, AudioAdapterCreateRenderWhenParamIsVaild, TestSize.Level0) +{ + struct AudioManager *managerFuncs = GetAudioManagerFuncs(); + struct AudioAdapterDescriptor *desc = new AudioAdapterDescriptor; + desc->adapterName = "usb"; + struct AudioAdapter *adapter; + managerFuncs->LoadAdapter(managerFuncs, desc, &adapter); + struct AudioDeviceDescriptor *desc1 = new AudioDeviceDescriptor; + desc1->pins = PIN_OUT_SPEAKER; + const struct AudioSampleAttributes *attrs = new AudioSampleAttributes; + struct AudioRender *render; + int32_t ret = AudioAdapterCreateRender(adapter, desc1, attrs, &render); + EXPECT_EQ(HDF_SUCCESS, ret); + delete(desc); + desc = nullptr; + delete(desc1); + desc1 = nullptr; + delete(attrs); + attrs = nullptr; +} + +HWTEST_F(AudioAdapterTest, AudioAdapterDestroyRenderWhenAdapterIsNull, TestSize.Level0) +{ + struct AudioAdapter *adapter = nullptr; + struct AudioRender *render = new AudioRender; + int32_t ret = AudioAdapterDestroyRender(adapter, render); + EXPECT_EQ(HDF_FAILURE, ret); + delete(render); + render = nullptr; +} + +HWTEST_F(AudioAdapterTest, AudioAdapterDestroyRenderWhenRenderIsNull, TestSize.Level0) +{ + struct AudioAdapter *adapter = new AudioAdapter; + struct AudioRender *render = nullptr; + int32_t ret = AudioAdapterDestroyRender(adapter, render); + EXPECT_EQ(HDF_FAILURE, ret); + delete(adapter); + adapter = nullptr; +} + +HWTEST_F(AudioAdapterTest, AudioAdapterDestroyRenderWhenParamIsVaild, TestSize.Level0) +{ + struct AudioAdapter *adapter = new AudioAdapter; + struct AudioRender *render = new AudioRender; + int32_t ret = AudioAdapterDestroyRender(adapter, render); + EXPECT_EQ(HDF_SUCCESS, ret); + delete(adapter); + adapter = nullptr; + delete(render); + render = nullptr; +} + +HWTEST_F(AudioAdapterTest, AudioAdapterCreateCaptureWhenAdapterIsNull, TestSize.Level0) +{ + struct AudioAdapter *adapter = nullptr; + const struct AudioDeviceDescriptor *desc = new AudioDeviceDescriptor; + const struct AudioSampleAttributes *attrs = new AudioSampleAttributes; + struct AudioCapture *capture; + int32_t ret = AudioAdapterCreateCapture(adapter, desc, attrs, &capture); + EXPECT_EQ(HDF_FAILURE, ret); + delete(desc); + desc = nullptr; + delete(attrs); + attrs = nullptr; +} + +HWTEST_F(AudioAdapterTest, AudioAdapterCreateCaptureWhenDescIsNull, TestSize.Level0) +{ + struct AudioAdapter *adapter = new AudioAdapter; + const struct AudioDeviceDescriptor *desc = nullptr; + const struct AudioSampleAttributes *attrs = new AudioSampleAttributes; + struct AudioCapture *capture; + int32_t ret = AudioAdapterCreateCapture(adapter, desc, attrs, &capture); + EXPECT_EQ(HDF_FAILURE, ret); + delete(adapter); + adapter = nullptr; + delete(attrs); + attrs = nullptr; +} + +HWTEST_F(AudioAdapterTest, AudioAdapterCreateCaptureWhenAttrsIsNull, TestSize.Level0) +{ + struct AudioAdapter *adapter = new AudioAdapter; + const struct AudioDeviceDescriptor *desc = new AudioDeviceDescriptor; + const struct AudioSampleAttributes *attrs = nullptr; + struct AudioCapture *capture; + int32_t ret = AudioAdapterCreateCapture(adapter, desc, attrs, &capture); + EXPECT_EQ(HDF_FAILURE, ret); + delete(adapter); + adapter = nullptr; + delete(desc); + desc = nullptr; +} + +HWTEST_F(AudioAdapterTest, AudioAdapterCreateCaptureWhenCaptureIsNull, TestSize.Level0) +{ + struct AudioAdapter *adapter = new AudioAdapter; + const struct AudioDeviceDescriptor *desc = new AudioDeviceDescriptor; + const struct AudioSampleAttributes *attrs = new AudioSampleAttributes; + struct AudioCapture **capture = nullptr; + int32_t ret = AudioAdapterCreateCapture(adapter, desc, attrs, capture); + EXPECT_EQ(HDF_FAILURE, ret); + delete(adapter); + adapter = nullptr; + delete(desc); + desc = nullptr; + delete(attrs); + attrs = nullptr; +} + +HWTEST_F(AudioAdapterTest, AudioAdapterCreateCaptureWhenParamIsVaild, TestSize.Level0) +{ + struct AudioManager *managerFuncs = GetAudioManagerFuncs(); + struct AudioAdapterDescriptor *desc = new AudioAdapterDescriptor; + desc->adapterName = "usb"; + struct AudioAdapter *adapter; + managerFuncs->LoadAdapter(managerFuncs, desc, &adapter); + struct AudioDeviceDescriptor *desc1 = new AudioDeviceDescriptor; + desc1->pins = PIN_IN_MIC; + const struct AudioSampleAttributes *attrs = new AudioSampleAttributes; + struct AudioCapture *capture; + int32_t ret = AudioAdapterCreateCapture(adapter, desc1, attrs, &capture); + EXPECT_EQ(HDF_SUCCESS, ret); + delete(desc); + desc = nullptr; + delete(desc1); + desc1 = nullptr; + delete(attrs); + attrs = nullptr; +} + +HWTEST_F(AudioAdapterTest, AudioAdapterDestroyCaptureWhenAdapterIsNull, TestSize.Level0) +{ + struct AudioAdapter *adapter = nullptr; + struct AudioCapture *capture = new AudioCapture; + int32_t ret = AudioAdapterDestroyCapture(adapter, capture); + EXPECT_EQ(HDF_FAILURE, ret); + delete(capture); + capture = nullptr; +} + +HWTEST_F(AudioAdapterTest, AudioAdapterDestroyCaptureWhenCaptureIsNull, TestSize.Level0) +{ + struct AudioAdapter *adapter = new AudioAdapter; + struct AudioCapture *capture = nullptr; + int32_t ret = AudioAdapterDestroyCapture(adapter, capture); + EXPECT_EQ(HDF_FAILURE, ret); + delete(adapter); + adapter = nullptr; +} + +HWTEST_F(AudioAdapterTest, AudioAdapterDestroyCaptureWhenParamIsVaild, TestSize.Level0) +{ + struct AudioAdapter *adapter = new AudioAdapter; + struct AudioCapture *capture = new AudioCapture; + int32_t ret = AudioAdapterDestroyCapture(adapter, capture); + EXPECT_EQ(HDF_SUCCESS, ret); + delete(adapter); + adapter = nullptr; + delete(capture); + capture = nullptr; +} +} diff --git a/audio/test/unittest/common/audio_capture_test.cpp b/audio/test/unittest/common/audio_capture_test.cpp new file mode 100755 index 0000000000000000000000000000000000000000..d110affd279cffd186a1d7f3f071cda0067bfc11 --- /dev/null +++ b/audio/test/unittest/common/audio_capture_test.cpp @@ -0,0 +1,159 @@ +/* + * 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_internal.h" +#include +#include + +using namespace std; +using namespace testing::ext; +namespace { +class AudioCaptureTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); +}; + +void AudioCaptureTest::SetUpTestCase() +{ +} + +void AudioCaptureTest::TearDownTestCase() +{ +} + +HWTEST_F(AudioCaptureTest, AudioCaptureStopWhenHandleIsNull, TestSize.Level0) +{ + struct AudioHwCapture *hwCapture = nullptr; + AudioHandle handle = (AudioHandle)hwCapture; + int32_t ret = AudioCaptureStop(handle); + EXPECT_EQ(HDF_FAILURE, ret); +} + +HWTEST_F(AudioCaptureTest, AudioCaptureStopWhenParamIsVaild, TestSize.Level0) +{ + struct AudioHwCapture *hwCapture = new AudioHwCapture; + AudioHandle handle = (AudioHandle)hwCapture; + int32_t ret = AudioCaptureStop(handle); + EXPECT_EQ(HDF_SUCCESS, ret); + delete(hwCapture); + hwCapture = nullptr; +} + +HWTEST_F(AudioCaptureTest, AudioCaptureResumeWhenHandleIsNull, TestSize.Level0) +{ + struct AudioHwCapture *hwCapture = nullptr; + AudioHandle handle = (AudioHandle)hwCapture; + int32_t ret = AudioCaptureResume(handle); + EXPECT_EQ(HDF_FAILURE, ret); +} + +HWTEST_F(AudioCaptureTest, AudioCaptureResumeWhenParamIsVaild, TestSize.Level0) +{ + struct AudioHwCapture *hwCapture = new AudioHwCapture; + AudioHandle handle = (AudioHandle)hwCapture; + int32_t ret = AudioCaptureResume(handle); + EXPECT_EQ(HDF_SUCCESS, ret); + delete(hwCapture); + hwCapture = nullptr; +} + +HWTEST_F(AudioCaptureTest, AudioCaptureSetSampleAttributesWhenHandleIsNull, TestSize.Level0) +{ + struct AudioHwCapture *hwCapture = nullptr; + AudioHandle handle = (AudioHandle)hwCapture; + AudioSampleAttributes *attrs = new AudioSampleAttributes; + int32_t ret = AudioCaptureSetSampleAttributes(handle, attrs); + EXPECT_EQ(HDF_FAILURE, ret); + delete(attrs); + attrs = nullptr; +} + +HWTEST_F(AudioCaptureTest, AudioCaptureSetSampleAttributesWhenAttrsIsNull, TestSize.Level0) +{ + struct AudioHwCapture *hwCapture = new AudioHwCapture; + AudioHandle handle = (AudioHandle)hwCapture; + AudioSampleAttributes *attrs = nullptr; + int32_t ret = AudioCaptureSetSampleAttributes(handle, attrs); + EXPECT_EQ(HDF_FAILURE, ret); + delete(hwCapture); + hwCapture = nullptr; +} + +HWTEST_F(AudioCaptureTest, AudioCaptureSetSampleAttributesWhenParamIsVaild, TestSize.Level0) +{ + struct AudioHwCapture *hwCapture = new AudioHwCapture; + AudioHandle handle = (AudioHandle)hwCapture; + AudioSampleAttributes *attrs = new AudioSampleAttributes; + int32_t ret = AudioCaptureSetSampleAttributes(handle, attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + delete(hwCapture); + hwCapture = nullptr; + delete(attrs); + attrs = nullptr; +} + +HWTEST_F(AudioCaptureTest, AudioCaptureGetSampleAttributesWhenHandleIsNull, TestSize.Level0) +{ + AudioSampleAttributes *attrs = new AudioSampleAttributes; + int32_t ret = AudioCaptureGetSampleAttributes(nullptr, attrs); + EXPECT_EQ(HDF_FAILURE, ret); + delete(attrs); + attrs = nullptr; +} + +HWTEST_F(AudioCaptureTest, AudioCaptureGetSampleAttributesWhenAttrsIsNull, TestSize.Level0) +{ + struct AudioHwCapture *hwCapture = new AudioHwCapture; + AudioHandle handle = (AudioHandle)hwCapture; + int32_t ret = AudioCaptureGetSampleAttributes(handle, nullptr); + EXPECT_EQ(HDF_FAILURE, ret); + delete(hwCapture); + hwCapture = nullptr; +} + +HWTEST_F(AudioCaptureTest, AudioCaptureGetSampleAttributesWhenParamIsVaild, TestSize.Level0) +{ + struct AudioHwCapture *hwCapture = new AudioHwCapture; + AudioHandle handle = (AudioHandle)hwCapture; + AudioSampleAttributes *attrs = new AudioSampleAttributes; + int32_t ret = AudioCaptureGetSampleAttributes(handle, attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + delete(hwCapture); + hwCapture = nullptr; + delete(attrs); + attrs = nullptr; +} + +HWTEST_F(AudioCaptureTest, AudioCaptureSetMuteWhenHandleIsNull, TestSize.Level0) +{ + struct AudioHwCapture *hwCapture = nullptr; + AudioHandle handle = (AudioHandle)hwCapture; + bool mute = true; + int32_t ret = AudioCaptureSetMute(handle, mute); + EXPECT_EQ(HDF_FAILURE, ret); +} + +HWTEST_F(AudioCaptureTest, AudioCaptureSetMuteParamIsVaild, TestSize.Level0) +{ + struct AudioHwCapture *hwCapture = new AudioHwCapture; + AudioHandle handle = (AudioHandle)hwCapture; + bool mute = false; + int32_t ret = AudioCaptureSetMute(handle, mute); + EXPECT_EQ(HDF_SUCCESS, ret); + delete(hwCapture); + hwCapture = nullptr; +} +} diff --git a/audio/test/unittest/common/audio_interface_lib_capture_test.cpp b/audio/test/unittest/common/audio_interface_lib_capture_test.cpp new file mode 100755 index 0000000000000000000000000000000000000000..a42b5d92e9721421bc0744298b7b096ed3fa4bdf --- /dev/null +++ b/audio/test/unittest/common/audio_interface_lib_capture_test.cpp @@ -0,0 +1,381 @@ +/* + * 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_interface_lib_capture.h" +#include +#include + +using namespace std; +using namespace testing::ext; +namespace { +extern "C" { +struct HdfSBuf *AudioCapturebtainHdfSBuf(); +int32_t AudioServiceCaptureDispatch(struct HdfIoService *service, + int cmdId, + struct HdfSBuf *sBuf, + struct HdfSBuf *reply); +int32_t SetHwParamsCapture(const struct AudioHwCaptureParam *handleData); +int32_t ParamsSbufWriteBufferCapture(struct HdfSBuf *sBuf); +int32_t AudioCtlCaptureSetPauseBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData); +int32_t AudioCtlCaptureSetPauseStu(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData); +int32_t AudioCtlCaptureGetVolumeSBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData); +int32_t AudioCtlCaptureGetVolume(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData); +int32_t AudioCtlCaptureSetVolumeSBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData); +int32_t AudioCtlCaptureSetVolume(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData); +int32_t AudioCtlCaptureSetMuteSBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData); +int32_t AudioCtlCaptureSetMuteStu(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData); +int32_t AudioCtlCaptureGetMuteSBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData); +int32_t AudioCtlCaptureGetMuteStu(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData); +int32_t AudioCtlCaptureSetGainSBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData); +int32_t AudioCtlCaptureSetGainStu(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData); +int32_t AudioCtlCaptureGetGainSBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData); +int32_t AudioCtlCaptureGetGainStu(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData); +int32_t AudioCtlCaptureSceneSelectSBuf(struct HdfSBuf *sBuf, + struct AudioHwCaptureParam *handleData, + int32_t deviceIndex); +int32_t AudioCtlCaptureSceneSelect(struct DevHandleCapture *handle, int cmdId, struct AudioHwCaptureParam *handleData); +int32_t AudioCtlCaptureGetGainThresholdSBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData); +int32_t AudioCtlCaptureGetGainThreshold(struct DevHandleCapture *handle, + int cmdId, + struct AudioHwCaptureParam *handleData); +int32_t AudioInterfaceLibCtlCapture(struct DevHandleCapture *handle, + int cmdId, + struct AudioHwCaptureParam *handleData); +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 AudioInterfaceLibOutputCapture(struct DevHandleCapture *handle, int cmdId, + struct AudioHwCaptureParam *handleData); +struct HdfIoService *HdfIoServiceBindName(const char *serviceName); +} + +class AudioInterfaceLibCaptureTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); +}; + +void AudioInterfaceLibCaptureTest::SetUpTestCase() +{ +} + +void AudioInterfaceLibCaptureTest::TearDownTestCase() +{ +} + +HWTEST_F(AudioInterfaceLibCaptureTest, SetHwParamsWhenHandleIsNull, TestSize.Level0) +{ + const struct AudioHwCaptureParam *handleData = nullptr; + int32_t ret = SetHwParamsCapture(handleData); + EXPECT_EQ(HDF_FAILURE, ret); +} + +HWTEST_F(AudioInterfaceLibCaptureTest, SetHwParamsWhenHandleIsVaild, TestSize.Level0) +{ + const struct AudioHwCaptureParam *handleData = new AudioHwCaptureParam; + int32_t ret = SetHwParamsCapture(handleData); + EXPECT_EQ(HDF_SUCCESS, ret); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibCaptureTest, ParamsSbufWriteBufferWhenSbufIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = nullptr; + int32_t ret = ParamsSbufWriteBufferCapture(sBuf); + EXPECT_EQ(HDF_FAILURE, ret); +} + +HWTEST_F(AudioInterfaceLibCaptureTest, ParamsSbufWriteBufferWhenParamIsVaild, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + int32_t ret = ParamsSbufWriteBufferCapture(sBuf); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureSetPauseBufWhenSbufIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = nullptr; + AudioHwCaptureParam *handleData = new AudioHwCaptureParam; + int32_t ret = AudioCtlCaptureSetPauseBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureSetPauseBufWhenHandleDataIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + AudioHwCaptureParam *handleData = nullptr; + int32_t ret = AudioCtlCaptureSetPauseBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(sBuf); +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureSetPauseBufWhenParamIsVaild, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + AudioHwCaptureParam *handleData = new AudioHwCaptureParam; + int32_t ret = AudioCtlCaptureSetPauseBuf(sBuf, handleData); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureGetVolumeSBufWhenSbuffIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = nullptr; + AudioHwCaptureParam *handleData = new AudioHwCaptureParam; + int32_t ret = AudioCtlCaptureGetVolumeSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureGetVolumeSBufWhenHandleDataIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + AudioHwCaptureParam *handleData = nullptr; + int32_t ret = AudioCtlCaptureGetVolumeSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(sBuf); +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureGetVolumeSBufWhenParamIsVaild, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + AudioHwCaptureParam *handleData = new AudioHwCaptureParam; + int32_t ret = AudioCtlCaptureGetVolumeSBuf(sBuf, handleData); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureSetVolumeSBufWhenSbuffIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = nullptr; + AudioHwCaptureParam *handleData = new AudioHwCaptureParam; + int32_t ret = AudioCtlCaptureSetVolumeSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureSetVolumeSBufWhenHandleDataIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + AudioHwCaptureParam *handleData = nullptr; + int32_t ret = AudioCtlCaptureSetVolumeSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(sBuf); +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureSetVolumeSBufWhenParamIsVaild, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + AudioHwCaptureParam *handleData = new AudioHwCaptureParam; + int32_t ret = AudioCtlCaptureSetVolumeSBuf(sBuf, handleData); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureSetMuteBufWhenSbufIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = nullptr; + AudioHwCaptureParam *handleData = new AudioHwCaptureParam; + int32_t ret = AudioCtlCaptureSetMuteSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureSetMuteBufWhenHandleDataIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + AudioHwCaptureParam *handleData = nullptr; + int32_t ret = AudioCtlCaptureSetMuteSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(sBuf); +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureSetMuteBufWhenParamIsVaild, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + AudioHwCaptureParam *handleData = new AudioHwCaptureParam; + int32_t ret = AudioCtlCaptureSetMuteSBuf(sBuf, handleData); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureGetMuteSBufWhenSbufIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = nullptr; + AudioHwCaptureParam *handleData = new AudioHwCaptureParam; + int32_t ret = AudioCtlCaptureGetMuteSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureGetMuteSBufWhenHandleDataIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + AudioHwCaptureParam *handleData = nullptr; + int32_t ret = AudioCtlCaptureGetMuteSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(sBuf); +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureGetMuteSBufWhenParamIsVaild, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + AudioHwCaptureParam *handleData = new AudioHwCaptureParam; + int32_t ret = AudioCtlCaptureGetMuteSBuf(sBuf, handleData); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureSetGainSBufWhenSbufIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = nullptr; + AudioHwCaptureParam *handleData = new AudioHwCaptureParam; + int32_t ret = AudioCtlCaptureSetGainSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureSetGainSBufWhenHandleDataIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + AudioHwCaptureParam *handleData = nullptr; + int32_t ret = AudioCtlCaptureSetGainSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(sBuf); +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureSetGainSBufWhenParamIsVaild, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + AudioHwCaptureParam *handleData = new AudioHwCaptureParam; + int32_t ret = AudioCtlCaptureSetGainSBuf(sBuf, handleData); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureGetGainSBufWhenSbufIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = nullptr; + AudioHwCaptureParam *handleData = new AudioHwCaptureParam; + int32_t ret = AudioCtlCaptureGetGainSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureGetGainSBufWhenHandleDataIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + AudioHwCaptureParam *handleData = nullptr; + int32_t ret = AudioCtlCaptureGetGainSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(sBuf); +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureGetGainSBufWhenParamIsVaild, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + AudioHwCaptureParam *handleData = new AudioHwCaptureParam; + int32_t ret = AudioCtlCaptureGetGainSBuf(sBuf, handleData); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureSceneSelectSBufWhenSbufIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = nullptr; + AudioHwCaptureParam *handleData = new AudioHwCaptureParam; + int32_t deviceIndex = 0; + int32_t ret = AudioCtlCaptureSceneSelectSBuf(sBuf, handleData, deviceIndex); + EXPECT_EQ(HDF_FAILURE, ret); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureSceneSelectSBufWhenHandleDataIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + AudioHwCaptureParam *handleData = nullptr; + int32_t deviceIndex = 0; + int32_t ret = AudioCtlCaptureSceneSelectSBuf(sBuf, handleData, deviceIndex); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(sBuf); +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureSceneSelectSBufWhenParamIsVaild, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + AudioHwCaptureParam *handleData = new AudioHwCaptureParam; + int32_t deviceIndex = 0; + int32_t ret = AudioCtlCaptureSceneSelectSBuf(sBuf, handleData, deviceIndex); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureGetGainThresholdSBufWhenSbufIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = nullptr; + AudioHwCaptureParam *handleData = new AudioHwCaptureParam; + int32_t ret = AudioCtlCaptureGetGainThresholdSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureGetGainThresholdSBufWhenHandleDataIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + AudioHwCaptureParam *handleData = nullptr; + int32_t ret = AudioCtlCaptureGetGainThresholdSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(sBuf); +} + +HWTEST_F(AudioInterfaceLibCaptureTest, AudioCtlCaptureGetGainThresholdSBufWhenParamIsVaild, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioCapturebtainHdfSBuf(); + AudioHwCaptureParam *handleData = new AudioHwCaptureParam; + int32_t ret = AudioCtlCaptureGetGainThresholdSBuf(sBuf, handleData); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + delete(handleData); + handleData = nullptr; +} +} diff --git a/audio/test/unittest/common/audio_interface_lib_render_test.cpp b/audio/test/unittest/common/audio_interface_lib_render_test.cpp new file mode 100755 index 0000000000000000000000000000000000000000..81e223f6b098f806ef71edd3775ce999c04d8f13 --- /dev/null +++ b/audio/test/unittest/common/audio_interface_lib_render_test.cpp @@ -0,0 +1,492 @@ +/* + * 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_interface_lib_render.h" +#include +#include + +using namespace std; +using namespace testing::ext; +namespace { +extern "C" { +struct HdfSBuf *AudioRenderObtainHdfSBuf(); +int32_t IoctlWrite(const struct AudioHwRenderParam *handleData); +int32_t AudioServiceRenderDispatch(struct HdfIoService *service, + int cmdId, + struct HdfSBuf *sBuf, + struct HdfSBuf *reply); +int32_t SetHwParams(const struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderSetVolumeSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderGetVolumeSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderSetVolume(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderGetVolume(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); +int32_t AudioOutputRenderSetSpeedSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData); +int32_t AudioOutputRenderSetSpeed(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderSetPauseBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderSetPauseStu(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderSetMuteBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderSetMuteStu(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderGetMuteSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderGetMuteStu(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderSetGainBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderSetGainStu(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderGetGainSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderGetGainStu(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderSceneSelectSBuf(struct HdfSBuf *sBuf, + struct AudioHwRenderParam *handleData, + int32_t deviceIndex); +int32_t AudioCtlRenderSceneSelect(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderSceneGetGainThresholdSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderSceneGetGainThreshold(struct DevHandle *handle, + int cmdId, + struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderSetChannelModeBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderSetChannelMode(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderGetChannelModeSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData); +int32_t AudioCtlRenderGetChannelMode(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); +int32_t AudioInterfaceLibCtlRender(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); +int32_t ParamsSbufWriteBuffer(struct HdfSBuf *sBuf); +int32_t FrameSbufWriteBuffer(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData); +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 AudioInterfaceLibOutputRender(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData); +struct HdfIoService *HdfIoServiceBindName(const char *serviceName); +} + +class AudioInterfaceLibRenderTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); +}; + +void AudioInterfaceLibRenderTest::SetUpTestCase() +{ +} + +void AudioInterfaceLibRenderTest::TearDownTestCase() +{ +} + +HWTEST_F(AudioInterfaceLibRenderTest, IoctlWriteWhenHandleIsNull, TestSize.Level0) +{ + const struct AudioHwRenderParam *handleData = nullptr; + int32_t ret = IoctlWrite(handleData); + EXPECT_EQ(HDF_FAILURE, ret); +} + +HWTEST_F(AudioInterfaceLibRenderTest, IoctlWriteWhenParamIsVaild, TestSize.Level0) +{ + const struct AudioHwRenderParam *handleData = new AudioHwRenderParam; + int32_t ret = IoctlWrite(handleData); + EXPECT_EQ(HDF_SUCCESS, ret); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibRenderTest, SetHwParamsWhenHandleIsNull, TestSize.Level0) +{ + const struct AudioHwRenderParam *handleData = nullptr; + int32_t ret = SetHwParams(handleData); + EXPECT_EQ(HDF_FAILURE, ret); +} + +HWTEST_F(AudioInterfaceLibRenderTest, SetHwParamsWhenHandleIsVaild, TestSize.Level0) +{ + const struct AudioHwRenderParam *handleData = new AudioHwRenderParam; + int32_t ret = SetHwParams(handleData); + EXPECT_EQ(HDF_SUCCESS, ret); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetVolumeSBufWhenSbuffIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = nullptr; + AudioHwRenderParam *handleData = new AudioHwRenderParam; + int32_t ret = AudioCtlRenderSetVolumeSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetVolumeSBufWhenHandleDataIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + AudioHwRenderParam *handleData = nullptr; + int32_t ret = AudioCtlRenderSetVolumeSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(sBuf); +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetVolumeSBufWhenParamIsVaild, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + AudioHwRenderParam *handleData = new AudioHwRenderParam; + int32_t ret = AudioCtlRenderSetVolumeSBuf(sBuf, handleData); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderGetVolumeSBufWhenSbuffIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = nullptr; + AudioHwRenderParam *handleData = new AudioHwRenderParam; + int32_t ret = AudioCtlRenderGetVolumeSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderGetVolumeSBufWhenHandleDataIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + AudioHwRenderParam *handleData = nullptr; + int32_t ret = AudioCtlRenderGetVolumeSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(sBuf); +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderGetVolumeSBufWhenParamIsVaild, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + AudioHwRenderParam *handleData = new AudioHwRenderParam; + int32_t ret = AudioCtlRenderGetVolumeSBuf(sBuf, handleData); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioOutputRenderSetSpeedSBufWhenSbuffIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = nullptr; + AudioHwRenderParam *handleData = new AudioHwRenderParam; + int32_t ret = AudioOutputRenderSetSpeedSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioOutputRenderSetSpeedSBufWhenHandleDataIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + AudioHwRenderParam *handleData = nullptr; + int32_t ret = AudioOutputRenderSetSpeedSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(sBuf); +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioOutputRenderSetSpeedSBufWhenParamIsVaild, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + AudioHwRenderParam *handleData = new AudioHwRenderParam; + int32_t ret = AudioOutputRenderSetSpeedSBuf(sBuf, handleData); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetPauseBufWhenSbufIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = nullptr; + AudioHwRenderParam *handleData = new AudioHwRenderParam; + int32_t ret = AudioCtlRenderSetPauseBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetPauseBufWhenHandleDataIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + AudioHwRenderParam *handleData = nullptr; + int32_t ret = AudioCtlRenderSetPauseBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(sBuf); +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetPauseBufWhenParamIsVaild, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + AudioHwRenderParam *handleData = new AudioHwRenderParam; + int32_t ret = AudioCtlRenderSetPauseBuf(sBuf, handleData); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetMuteBufWhenSbufIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = nullptr; + AudioHwRenderParam *handleData = new AudioHwRenderParam; + int32_t ret = AudioCtlRenderSetMuteBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetMuteBufWhenHandleDataIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + AudioHwRenderParam *handleData = nullptr; + int32_t ret = AudioCtlRenderSetMuteBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(sBuf); +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetMuteBufWhenParamIsVaild, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + AudioHwRenderParam *handleData = new AudioHwRenderParam; + int32_t ret = AudioCtlRenderSetMuteBuf(sBuf, handleData); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderGetMuteSBufWhenSbufIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = nullptr; + AudioHwRenderParam *handleData = new AudioHwRenderParam; + int32_t ret = AudioCtlRenderGetMuteSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderGetMuteSBufWhenHandleDataIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + AudioHwRenderParam *handleData = nullptr; + int32_t ret = AudioCtlRenderGetMuteSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(sBuf); +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderGetMuteSBufWhenParamIsVaild, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + AudioHwRenderParam *handleData = new AudioHwRenderParam; + int32_t ret = AudioCtlRenderGetMuteSBuf(sBuf, handleData); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetGainBufWhenSbufIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = nullptr; + AudioHwRenderParam *handleData = new AudioHwRenderParam; + int32_t ret = AudioCtlRenderSetGainBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetGainBufWhenHandleDataIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + AudioHwRenderParam *handleData = nullptr; + int32_t ret = AudioCtlRenderSetGainBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(sBuf); +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetGainBufWhenParamIsVaild, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + AudioHwRenderParam *handleData = new AudioHwRenderParam; + int32_t ret = AudioCtlRenderSetGainBuf(sBuf, handleData); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderGetGainSBufWhenSbufIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = nullptr; + AudioHwRenderParam *handleData = new AudioHwRenderParam; + int32_t ret = AudioCtlRenderGetGainSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderGetGainSBufWhenHandleDataIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + AudioHwRenderParam *handleData = nullptr; + int32_t ret = AudioCtlRenderGetGainSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(sBuf); +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderGetGainSBufWhenParamIsVaild, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + AudioHwRenderParam *handleData = new AudioHwRenderParam; + int32_t ret = AudioCtlRenderGetGainSBuf(sBuf, handleData); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSceneSelectSBufWhenSbufIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = nullptr; + AudioHwRenderParam *handleData = new AudioHwRenderParam; + int32_t deviceIndex = 0; + int32_t ret = AudioCtlRenderSceneSelectSBuf(sBuf, handleData, deviceIndex); + EXPECT_EQ(HDF_FAILURE, ret); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSceneSelectSBufWhenHandleDataIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + AudioHwRenderParam *handleData = nullptr; + int32_t deviceIndex = 0; + int32_t ret = AudioCtlRenderSceneSelectSBuf(sBuf, handleData, deviceIndex); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(sBuf); +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSceneSelectSBufWhenParamIsVaild, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + AudioHwRenderParam *handleData = new AudioHwRenderParam; + int32_t deviceIndex = 0; + int32_t ret = AudioCtlRenderSceneSelectSBuf(sBuf, handleData, deviceIndex); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSceneGetGainThresholdSBufWhenSbufIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = nullptr; + AudioHwRenderParam *handleData = new AudioHwRenderParam; + int32_t ret = AudioCtlRenderSceneGetGainThresholdSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSceneGetGainThresholdSBufWhenHandleDataIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + AudioHwRenderParam *handleData = nullptr; + int32_t ret = AudioCtlRenderSceneGetGainThresholdSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(sBuf); +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSceneGetGainThresholdSBufWhenParamIsVaild, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + AudioHwRenderParam *handleData = new AudioHwRenderParam; + int32_t ret = AudioCtlRenderSceneGetGainThresholdSBuf(sBuf, handleData); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetChannelModeBufWhenSbufIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = nullptr; + AudioHwRenderParam *handleData = new AudioHwRenderParam; + int32_t ret = AudioCtlRenderSetChannelModeBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetChannelModeBufWhenHandleDataIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + AudioHwRenderParam *handleData = nullptr; + int32_t ret = AudioCtlRenderSetChannelModeBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(sBuf); +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetChannelModeBufWhenParamIsVaild, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + AudioHwRenderParam *handleData = new AudioHwRenderParam; + int32_t ret = AudioCtlRenderSetChannelModeBuf(sBuf, handleData); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderGetChannelModeSBufWhenSbufIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = nullptr; + AudioHwRenderParam *handleData = new AudioHwRenderParam; + int32_t ret = AudioCtlRenderGetChannelModeSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderGetChannelModeSBufWhenHandleDataIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + AudioHwRenderParam *handleData = nullptr; + int32_t ret = AudioCtlRenderGetChannelModeSBuf(sBuf, handleData); + EXPECT_EQ(HDF_FAILURE, ret); + HdfSBufRecycle(sBuf); +} + +HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderGetChannelModeSBufWhenParamIsVaild, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + AudioHwRenderParam *handleData = new AudioHwRenderParam; + int32_t ret = AudioCtlRenderGetChannelModeSBuf(sBuf, handleData); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); + delete(handleData); + handleData = nullptr; +} + +HWTEST_F(AudioInterfaceLibRenderTest, ParamsSbufWriteBufferWhenSbufIsNull, TestSize.Level0) +{ + struct HdfSBuf *sBuf = nullptr; + int32_t ret = ParamsSbufWriteBuffer(sBuf); + EXPECT_EQ(HDF_FAILURE, ret); +} + +HWTEST_F(AudioInterfaceLibRenderTest, ParamsSbufWriteBufferWhenParamIsVaild, TestSize.Level0) +{ + struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf(); + int32_t ret = ParamsSbufWriteBuffer(sBuf); + EXPECT_EQ(HDF_SUCCESS, ret); + HdfSBufRecycle(sBuf); +} +} diff --git a/audio/test/unittest/common/audio_manager_test.cpp b/audio/test/unittest/common/audio_manager_test.cpp new file mode 100755 index 0000000000000000000000000000000000000000..2d71ed6495a29223c0986600af01bafda3015349 --- /dev/null +++ b/audio/test/unittest/common/audio_manager_test.cpp @@ -0,0 +1,126 @@ +/* + * 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_internal.h" +#include +#include + +using namespace std; +using namespace testing::ext; +namespace { +class AudioManagerTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); +}; + +void AudioManagerTest::SetUpTestCase() +{ +} + +void AudioManagerTest::TearDownTestCase() +{ +} + +HWTEST_F(AudioManagerTest, AudioManagerGetAllAdaptersWhenManagerIsNull, TestSize.Level0) +{ + struct AudioManager *managerFuncs = GetAudioManagerFuncs(); + int32_t size = 0; + struct AudioManager *manager = nullptr; + struct AudioAdapterDescriptor *descs; + int32_t ret = managerFuncs->GetAllAdapters(manager, &descs, &size); + EXPECT_EQ(HDF_FAILURE, ret); +} + +HWTEST_F(AudioManagerTest, AudioManagerGetAllAdaptersWhenDescsIsNull, TestSize.Level0) +{ + struct AudioManager *managerFuncs = GetAudioManagerFuncs(); + int32_t size = 0; + int32_t ret = managerFuncs->GetAllAdapters(managerFuncs, nullptr, &size); + EXPECT_EQ(HDF_FAILURE, ret); +} + +HWTEST_F(AudioManagerTest, AudioManagerGetAllAdaptersWhenSizeIsNull, TestSize.Level0) +{ + struct AudioManager *managerFuncs = GetAudioManagerFuncs(); + int32_t *size = nullptr; + struct AudioAdapterDescriptor *descs; + int32_t ret = managerFuncs->GetAllAdapters(managerFuncs, &descs, size); + EXPECT_EQ(HDF_FAILURE, ret); +} + +HWTEST_F(AudioManagerTest, AudioManagerGetAllAdaptersWhenParamIsVaild, TestSize.Level0) +{ + struct AudioManager *managerFuncs = GetAudioManagerFuncs(); + int32_t size = 0; + struct AudioAdapterDescriptor *descs; + int32_t ret = managerFuncs->GetAllAdapters(managerFuncs, &descs, &size); + EXPECT_EQ(HDF_SUCCESS, ret); +} + +HWTEST_F(AudioManagerTest, AudioManagerLoadAdapterWhenManagerIsNull, TestSize.Level0) +{ + struct AudioManager *managerFuncs = GetAudioManagerFuncs(); + struct AudioManager *manager = nullptr; + const struct AudioAdapterDescriptor *desc = new AudioAdapterDescriptor; + struct AudioAdapter *adapter; + int32_t ret = managerFuncs->LoadAdapter(manager, desc, &adapter); + EXPECT_EQ(HDF_FAILURE, ret); + delete(desc); + desc = nullptr; +} + +HWTEST_F(AudioManagerTest, AudioManagerLoadAdapterWhenDescIsNull, TestSize.Level0) +{ + struct AudioManager *managerFuncs = GetAudioManagerFuncs(); + const struct AudioAdapterDescriptor *desc = nullptr; + struct AudioAdapter *adapter; + int32_t ret = managerFuncs->LoadAdapter(managerFuncs, desc, &adapter); + EXPECT_EQ(HDF_FAILURE, ret); +} + +HWTEST_F(AudioManagerTest, AudioManagerLoadAdapterWhenAdapterNameIsNull, TestSize.Level0) +{ + struct AudioManager *managerFuncs = GetAudioManagerFuncs(); + struct AudioAdapterDescriptor descTemp; + descTemp.adapterName = nullptr; + const struct AudioAdapterDescriptor *desc = &descTemp; + struct AudioAdapter *adapter; + int32_t ret = managerFuncs->LoadAdapter(managerFuncs, desc, &adapter); + EXPECT_EQ(HDF_FAILURE, ret); +} + +HWTEST_F(AudioManagerTest, AudioManagerLoadAdapterWhenAdapterIsNull, TestSize.Level0) +{ + struct AudioManager *managerFuncs = GetAudioManagerFuncs(); + const struct AudioAdapterDescriptor *desc = new AudioAdapterDescriptor; + int32_t ret = managerFuncs->LoadAdapter(managerFuncs, desc, nullptr); + EXPECT_EQ(HDF_FAILURE, ret); + delete(desc); + desc = nullptr; +} + +HWTEST_F(AudioManagerTest, AudioManagerLoadAdapterWhenParamIsVaild, TestSize.Level0) +{ + struct AudioManager *managerFuncs = GetAudioManagerFuncs(); + struct AudioAdapterDescriptor *desc = new AudioAdapterDescriptor; + desc->adapterName = "usb"; + static struct AudioAdapter *adapter; + int32_t ret = managerFuncs->LoadAdapter(managerFuncs, desc, &adapter); + EXPECT_EQ(HDF_SUCCESS, ret); + delete(desc); + desc = nullptr; +} +} diff --git a/audio/test/unittest/common/audio_render_test.cpp b/audio/test/unittest/common/audio_render_test.cpp new file mode 100755 index 0000000000000000000000000000000000000000..16fbe1500c291a26f9483fa0cc465a0c218a22c8 --- /dev/null +++ b/audio/test/unittest/common/audio_render_test.cpp @@ -0,0 +1,446 @@ +/* + * 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_internal.h" +#include +#include + +using namespace std; +using namespace testing::ext; +namespace { +class AudioRenderTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); +}; + +void AudioRenderTest::SetUpTestCase() +{ +} + +void AudioRenderTest::TearDownTestCase() +{ +} + +HWTEST_F(AudioRenderTest, AudioRenderStopWhenHandleIsNull, TestSize.Level0) +{ + AudioHwRender *hwRender = nullptr; + AudioHandle handle = (AudioHandle)hwRender; + int32_t ret = AudioRenderStop(handle); + EXPECT_EQ(HDF_FAILURE, ret); +} + +HWTEST_F(AudioRenderTest, AudioRenderStopWhenParamIsVaild, TestSize.Level0) +{ + AudioHwRender *hwRender = new AudioHwRender; + AudioHandle handle = (AudioHandle)hwRender; + int32_t ret = AudioRenderStop(handle); + EXPECT_EQ(HDF_SUCCESS, ret); + delete(hwRender); + hwRender = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderResumeWhenHandleIsNull, TestSize.Level0) +{ + AudioHwRender *hwRender = nullptr; + AudioHandle handle = (AudioHandle)hwRender; + int32_t ret = AudioRenderResume(handle); + EXPECT_EQ(HDF_FAILURE, ret); +} + +HWTEST_F(AudioRenderTest, AudioRenderResumeWhenParamIsVaild, TestSize.Level0) +{ + AudioHwRender *hwRender = new AudioHwRender; + AudioHandle handle = (AudioHandle)hwRender; + int32_t ret = AudioRenderResume(handle); + EXPECT_EQ(HDF_SUCCESS, ret); + delete(hwRender); + hwRender = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderFlushWhenHandleIsNull, TestSize.Level0) +{ + AudioHwRender *hwRender = nullptr; + AudioHandle handle = (AudioHandle)hwRender; + int32_t ret = AudioRenderFlush(handle); + EXPECT_EQ(HDF_FAILURE, ret); +} + +HWTEST_F(AudioRenderTest, AudioRenderFlushWhenParamIsVaild, TestSize.Level0) +{ + AudioHwRender *hwRender = new AudioHwRender; + AudioHandle handle = (AudioHandle)hwRender; + int32_t ret = AudioRenderFlush(handle); + EXPECT_EQ(HDF_SUCCESS, ret); + delete hwRender; + hwRender = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderGetFrameSizeWhenHandleIsNull, TestSize.Level0) +{ + AudioHwRender *hwRender = nullptr; + AudioHandle handle = (AudioHandle)hwRender; + uint64_t sizeTmp = FREAM_DATA; + uint64_t *size = &sizeTmp; + int32_t ret = AudioRenderGetFrameSize(handle, size); + EXPECT_EQ(HDF_FAILURE, ret); +} + +HWTEST_F(AudioRenderTest, AudioRenderGetFrameSizeWhenSizeIsNull, TestSize.Level0) +{ + AudioHwRender *hwRender = new AudioHwRender; + AudioHandle handle = (AudioHandle)hwRender; + uint64_t *size = nullptr; + int32_t ret = AudioRenderGetFrameSize(handle, size); + EXPECT_EQ(HDF_FAILURE, ret); + delete(hwRender); + hwRender = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderGetFrameSizeWhenParamIsVaild, TestSize.Level0) +{ + AudioHwRender *hwRender = new AudioHwRender; + AudioHandle handle = (AudioHandle)hwRender; + uint64_t sizeTmp = FREAM_DATA; + uint64_t *size = &sizeTmp; + int32_t ret = AudioRenderGetFrameSize(handle, size); + EXPECT_EQ(HDF_SUCCESS, ret); + delete(hwRender); + hwRender = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderGetFrameCountWhenHandleIsNull, TestSize.Level0) +{ + AudioHwRender *hwRender = nullptr; + AudioHandle handle = (AudioHandle)hwRender; + uint64_t countTmp = FREAM_DATA; + uint64_t *count = &countTmp; + int32_t ret = AudioRenderGetFrameCount(handle, count); + EXPECT_EQ(HDF_FAILURE, ret); +} + +HWTEST_F(AudioRenderTest, AudioRenderGetFrameCountWhenCountIsNull, TestSize.Level0) +{ + AudioHwRender *hwRender = new AudioHwRender; + AudioHandle handle = (AudioHandle)hwRender; + uint64_t *count = nullptr; + int32_t ret = AudioRenderGetFrameCount(handle, count); + EXPECT_EQ(HDF_FAILURE, ret); + delete(hwRender); + hwRender = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderGetFrameCountWhenParamIsVaild, TestSize.Level0) +{ + AudioHwRender *hwRender = new AudioHwRender; + AudioHandle handle = (AudioHandle)hwRender; + uint64_t countTmp = FREAM_DATA; + uint64_t *count = &countTmp; + int32_t ret = AudioRenderGetFrameCount(handle, count); + EXPECT_EQ(HDF_SUCCESS, ret); + delete(hwRender); + hwRender = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderSetSampleAttributesWhenHandleIsNull, TestSize.Level0) +{ + AudioHwRender *hwRender = nullptr; + AudioHandle handle = (AudioHandle)hwRender; + AudioSampleAttributes *attrs = new AudioSampleAttributes; + int32_t ret = AudioRenderSetSampleAttributes(handle, attrs); + EXPECT_EQ(HDF_FAILURE, ret); + delete(attrs); + attrs = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderSetSampleAttributesWhenAttrsIsNull, TestSize.Level0) +{ + AudioHwRender *hwRender = new AudioHwRender; + AudioHandle handle = (AudioHandle)hwRender; + AudioSampleAttributes *attrs = nullptr; + int32_t ret = AudioRenderSetSampleAttributes(handle, attrs); + EXPECT_EQ(HDF_FAILURE, ret); + delete(hwRender); + hwRender = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderSetSampleAttributesWhenParamIsVaild, TestSize.Level0) +{ + AudioHwRender *hwRender = new AudioHwRender; + AudioHandle handle = (AudioHandle)hwRender; + AudioSampleAttributes *attrs = new AudioSampleAttributes; + int32_t ret = AudioRenderSetSampleAttributes(handle, attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + delete(hwRender); + hwRender = nullptr; + delete(attrs); + attrs = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderGetSampleAttributesWhenHandleIsNull, TestSize.Level0) +{ + AudioSampleAttributes *attrs = new AudioSampleAttributes; + int32_t ret = AudioRenderGetSampleAttributes(nullptr, attrs); + EXPECT_EQ(HDF_FAILURE, ret); + delete(attrs); + attrs = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderGetSampleAttributesWhenAttrsIsNull, TestSize.Level0) +{ + AudioHwRender *hwRender = new AudioHwRender; + AudioHandle handle = (AudioHandle)hwRender; + int32_t ret = AudioRenderGetSampleAttributes(handle, nullptr); + EXPECT_EQ(HDF_FAILURE, ret); + delete(hwRender); + hwRender = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderGetSampleAttributesWhenParamIsVaild, TestSize.Level0) +{ + AudioHwRender *hwRender = new AudioHwRender; + AudioHandle handle = (AudioHandle)hwRender; + AudioSampleAttributes *attrs = new AudioSampleAttributes; + int32_t ret = AudioRenderGetSampleAttributes(handle, attrs); + EXPECT_EQ(HDF_SUCCESS, ret); + delete(hwRender); + hwRender = nullptr; + delete(attrs); + attrs = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderGetCurrentChannelIdWhenHandleIsNull, TestSize.Level0) +{ + AudioHwRender *hwRender = nullptr; + AudioHandle handle = (AudioHandle)hwRender; + uint32_t channelIdOne = 1; + uint32_t *channelId = &channelIdOne; + int32_t ret = AudioRenderGetCurrentChannelId(handle, channelId); + EXPECT_EQ(HDF_FAILURE, ret); +} + +HWTEST_F(AudioRenderTest, AudioRenderGetCurrentChannelIdWhenChannelIdIsNull, TestSize.Level0) +{ + AudioHwRender *hwRender = new AudioHwRender; + AudioHandle handle = (AudioHandle)hwRender; + uint32_t *channelId = nullptr; + int32_t ret = AudioRenderGetCurrentChannelId(handle, channelId); + EXPECT_EQ(HDF_FAILURE, ret); + delete hwRender; + hwRender = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderGetCurrentChannelIdWhenParamIsVaild, TestSize.Level0) +{ + AudioHwRender *hwRender = new AudioHwRender; + AudioHandle handle = (AudioHandle)hwRender; + uint32_t channelIdOne = 1; + uint32_t *channelId = &channelIdOne; + int32_t ret = AudioRenderGetCurrentChannelId(handle, channelId); + EXPECT_EQ(HDF_SUCCESS, ret); + delete hwRender; + hwRender = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderSetMuteWhenHandleIsNull, TestSize.Level0) +{ + AudioHwRender *hwRender = nullptr; + AudioHandle handle = (AudioHandle)hwRender; + bool mute = true; + int32_t ret = AudioRenderSetMute(handle, mute); + EXPECT_EQ(HDF_FAILURE, ret); +} + +HWTEST_F(AudioRenderTest, AudioRenderSetMuteParamIsVaild, TestSize.Level0) +{ + AudioHwRender *hwRender = new AudioHwRender; + AudioHandle handle = (AudioHandle)hwRender; + bool mute = false; + int32_t ret = AudioRenderSetMute(handle, mute); + EXPECT_EQ(HDF_SUCCESS, ret); + delete(hwRender); + hwRender = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderGetLatencyWhenRenderIsNull, TestSize.Level0) +{ + struct AudioRender *render = nullptr; + uint32_t msTmp = 96; + uint32_t *ms = &msTmp; + int32_t ret = AudioRenderGetLatency(render, ms); + EXPECT_EQ(HDF_FAILURE, ret); +} + +HWTEST_F(AudioRenderTest, AudioRenderGetLatencyWhenMsIsNull, TestSize.Level0) +{ + struct AudioHwRender *hwRender = new AudioHwRender; + struct AudioRender *render = static_cast(hwRender); + uint32_t *ms = nullptr; + int32_t ret = AudioRenderGetLatency(render, ms); + EXPECT_EQ(HDF_FAILURE, ret); + delete(render); + render = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderGetLatencyParamIsVaild, TestSize.Level0) +{ + struct AudioHwRender *hwRender = new AudioHwRender; + struct AudioRender *render = static_cast(hwRender); + uint32_t msTmp = 96; + uint32_t *ms = &msTmp; + int32_t ret = AudioRenderGetLatency(render, ms); + EXPECT_EQ(HDF_SUCCESS, ret); + delete(render); + render = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderRenderFrameWhenRenderIsNull, TestSize.Level0) +{ + struct AudioRender *render = nullptr; + void *frame = (void *)calloc(1, FREAM_DATA); + uint64_t requestBytes = FREAM_DATA; + uint64_t replyBytes; + int32_t ret = AudioRenderRenderFrame(render, (const void*)frame, requestBytes, &replyBytes); + EXPECT_EQ(HDF_FAILURE, ret); + free(frame); + frame = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderRenderFrameWhenFrameIsNull, TestSize.Level0) +{ + struct AudioRender *render = new AudioRender; + const void *frame = nullptr; + uint64_t requestBytes = FREAM_DATA; + uint64_t replyBytes; + int32_t ret = AudioRenderRenderFrame(render, frame, requestBytes, &replyBytes); + EXPECT_EQ(HDF_FAILURE, ret); + delete(render); + render = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderRenderFrameWhenReplyBytesIsNull, TestSize.Level0) +{ + struct AudioRender *render = new AudioRender; + void *frame = (void *)calloc(1, FREAM_DATA); + uint64_t requestBytes = FREAM_DATA; + uint64_t *replyBytes = nullptr; + int32_t ret = AudioRenderRenderFrame(render, (const void*)frame, requestBytes, replyBytes); + EXPECT_EQ(HDF_FAILURE, ret); + delete(render); + render = nullptr; + free(frame); + frame = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderRenderFrameWhenParamIsVaild, TestSize.Level0) +{ + struct AudioRender *render = new AudioRender; + void *frame = (void *)calloc(1, FREAM_DATA); + uint64_t requestBytes = FREAM_DATA; + uint64_t replyBytes; + int32_t ret = AudioRenderRenderFrame(render, (const void*)frame, requestBytes, &replyBytes); + EXPECT_EQ(HDF_SUCCESS, ret); + delete(render); + render = nullptr; + free(frame); + frame = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderGetRenderPositionWhenRenderIsNull, TestSize.Level0) +{ + struct AudioRender *render = nullptr; + uint64_t frameTmp = 1024; + uint64_t *frames = &frameTmp; + struct AudioTimeStamp *time = new AudioTimeStamp; + int32_t ret = AudioRenderGetRenderPosition(render, frames, time); + EXPECT_EQ(HDF_FAILURE, ret); + delete(time); + time = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderGetRenderPositionWhenFramesIsNull, TestSize.Level0) +{ + struct AudioHwRender *hwRender = new AudioHwRender; + struct AudioRender *render = static_cast(hwRender); + uint64_t *frames = nullptr; + struct AudioTimeStamp *time = new AudioTimeStamp; + int32_t ret = AudioRenderGetRenderPosition(render, frames, time); + EXPECT_EQ(HDF_FAILURE, ret); + delete(render); + render = nullptr; + delete(time); + time = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderGetRenderPositionWhenTimeIsNull, TestSize.Level0) +{ + struct AudioHwRender *hwRender = new AudioHwRender; + struct AudioRender *render = static_cast(hwRender); + uint64_t frameTmp = 1024; + uint64_t *frames = &frameTmp; + struct AudioTimeStamp *time = nullptr; + int32_t ret = AudioRenderGetRenderPosition(render, frames, time); + EXPECT_EQ(HDF_FAILURE, ret); + delete(render); + render = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderGetRenderPositionWhenParamIsVaild, TestSize.Level0) +{ + struct AudioHwRender *hwRender = new AudioHwRender; + struct AudioRender *render = static_cast(hwRender); + uint64_t frameTmp = 1024; + uint64_t *frames = &frameTmp; + struct AudioTimeStamp *time = new AudioTimeStamp; + int32_t ret = AudioRenderGetRenderPosition(render, frames, time); + EXPECT_EQ(HDF_SUCCESS, ret); + delete(render); + render = nullptr; + free(time); + time = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderGetRenderSpeedWhenRenderIsNull, TestSize.Level0) +{ + struct AudioRender *render = nullptr; + float speedTmp = 1.0; + float *speed = &speedTmp; + int32_t ret = AudioRenderGetRenderSpeed(render, speed); + EXPECT_EQ(HDF_FAILURE, ret); +} + +HWTEST_F(AudioRenderTest, AudioRenderGetRenderSpeedWhenSpeedIsNull, TestSize.Level0) +{ + struct AudioHwRender *hwRender = new AudioHwRender; + struct AudioRender *render = static_cast(hwRender); + float *speed = nullptr; + int32_t ret = AudioRenderGetRenderSpeed(render, speed); + EXPECT_EQ(HDF_FAILURE, ret); + delete(render); + render = nullptr; +} + +HWTEST_F(AudioRenderTest, AudioRenderGetRenderSpeedWhenParamIsVaild, TestSize.Level0) +{ + struct AudioHwRender *hwRender = new AudioHwRender; + struct AudioRender *render = static_cast(hwRender); + float speedTmp = 1.0; + float *speed = &speedTmp; + int32_t ret = AudioRenderGetRenderSpeed(render, speed); + EXPECT_EQ(HDF_SUCCESS, ret); + delete(render); + render = nullptr; +} +} diff --git a/base/hdf_peripheral.rc b/base/hdf_peripheral.rc index fda0f366c34e5f8082ff23b361ac19a204cf16c4..e22e7a49725a4f976474b8211d16ae7f9e8e3cf9 100644 --- a/base/hdf_peripheral.rc +++ b/base/hdf_peripheral.rc @@ -20,3 +20,8 @@ on post-fs-data chown system system /dev/hdf_input_event4 chown system system /dev/hdf_input_event5 chown system system /dev/hdf_input_event6 + chown system system /dev/hdf_audio_render + chown system system /dev/hdf_audio_capture + chown system system /dev/hdf_audio_control + chown system system /dev/hdf_audio_codec_dev0 + chown system system /dev/hdf_audio_smartpa_dev0