From a54c27481e89941ddb19d2b05da14306136e5a76 Mon Sep 17 00:00:00 2001 From: xiesicong Date: Fri, 22 Sep 2023 10:09:29 +0800 Subject: [PATCH 01/14] =?UTF-8?q?=E6=9B=B4=E6=96=B0BUILD.gn,=E5=B9=B6?= =?UTF-8?q?=E5=A2=9E=E5=8A=A0=E4=B8=80=E4=B8=AA=E5=AE=9E=E7=94=A8=E5=AE=8F?= =?UTF-8?q?=EF=BC=8C=E5=A2=9E=E5=8A=A0=E4=B8=80=E4=B8=AA=E7=BB=93=E6=9E=84?= =?UTF-8?q?=E4=BD=93=E5=8F=98=E9=87=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xiesicong --- audio/hdi_service/supportlibs/BUILD.gn | 12 ++++++++---- .../vendor_interface/utils/audio_uhdf_log.h | 10 ++++++++++ .../interfaces/include/audio_if_lib_common.h | 1 + 3 files changed, 19 insertions(+), 4 deletions(-) diff --git a/audio/hdi_service/supportlibs/BUILD.gn b/audio/hdi_service/supportlibs/BUILD.gn index c5baa5a31d..385878a8a6 100644 --- a/audio/hdi_service/supportlibs/BUILD.gn +++ b/audio/hdi_service/supportlibs/BUILD.gn @@ -76,8 +76,9 @@ if (defined(ohos_lite)) { if (drivers_peripheral_audio_feature_alsa_lib) { sources += [ "$hdf_audio_path/supportlibs/alsa_adapter/src/alsa_lib_capture.c", - "$hdf_audio_path/supportlibs/alsa_adapter/src/alsa_lib_common.c", - "$hdf_audio_path/supportlibs/alsa_adapter/src/alsa_mixer_path.c", + "$hdf_audio_path/supportlibs/alsa_adapter/src/alsa_snd_capture.c", + "$hdf_audio_path/supportlibs/alsa_adapter/src/alsa_soundcard.c", + "//device/board/${product_company}/${device_name}/audio_alsa/vendor_capture.c", "//third_party/cJSON/cJSON.c", ] } else { @@ -99,6 +100,7 @@ if (defined(ohos_lite)) { "//third_party/cJSON", "//third_party/alsa-lib/include", "$hdf_audio_path/supportlibs/alsa_adapter/include", + "//device/board/${product_company}/${device_name}/audio_alsa", ] public_deps += [ "//third_party/alsa-lib:libasound" ] } else { @@ -131,9 +133,10 @@ if (defined(ohos_lite)) { sources = [ "$hdf_hdi_service_path/primary_impl/src/audio_common.c" ] if (drivers_peripheral_audio_feature_alsa_lib) { sources += [ - "$hdf_audio_path/supportlibs/alsa_adapter/src/alsa_lib_common.c", "$hdf_audio_path/supportlibs/alsa_adapter/src/alsa_lib_render.c", - "$hdf_audio_path/supportlibs/alsa_adapter/src/alsa_mixer_path.c", + "$hdf_audio_path/supportlibs/alsa_adapter/src/alsa_snd_render.c", + "$hdf_audio_path/supportlibs/alsa_adapter/src/alsa_soundcard.c", + "//device/board/${product_company}/${device_name}/audio_alsa/vendor_render.c", "//third_party/cJSON/cJSON.c", ] } else { @@ -156,6 +159,7 @@ if (defined(ohos_lite)) { "//third_party/cJSON", "//third_party/alsa-lib/include", "$hdf_audio_path/supportlibs/alsa_adapter/include", + "//device/board/${product_company}/${device_name}/audio_alsa", ] public_deps += [ "//third_party/alsa-lib:libasound" ] } else { diff --git a/audio/hdi_service/vendor_interface/utils/audio_uhdf_log.h b/audio/hdi_service/vendor_interface/utils/audio_uhdf_log.h index 4e90f0990d..3a970a6389 100644 --- a/audio/hdi_service/vendor_interface/utils/audio_uhdf_log.h +++ b/audio/hdi_service/vendor_interface/utils/audio_uhdf_log.h @@ -51,6 +51,16 @@ #endif +#ifndef CHECK_NULL_PTR_RETURN_DEFAULT +#define CHECK_NULL_PTR_RETURN_DEFAULT(pointer) \ + do { \ + if ((pointer) == NULL) { \ + AUDIO_FUNC_LOGE("%{public}s is null and return INVALID_PARAM", #pointer); \ + return HDF_ERR_INVALID_PARAM; \ + } \ + } while (0) +#endif + #ifndef CHECK_NULL_PTR_RETURN_VALUE #define CHECK_NULL_PTR_RETURN_VALUE(pointer, ret) \ do { \ diff --git a/audio/supportlibs/interfaces/include/audio_if_lib_common.h b/audio/supportlibs/interfaces/include/audio_if_lib_common.h index 4dcfca9073..0491c12d50 100644 --- a/audio/supportlibs/interfaces/include/audio_if_lib_common.h +++ b/audio/supportlibs/interfaces/include/audio_if_lib_common.h @@ -30,6 +30,7 @@ struct AudioPcmHwParams { uint32_t periodCount; uint32_t period; uint32_t frameSize; + uint32_t bitsPerFrame; uint32_t startThreshold; uint32_t stopThreshold; uint32_t silenceThreshold; -- Gitee From f4a5200bd649fa2541679ec7d24afb99fd4c6d36 Mon Sep 17 00:00:00 2001 From: xiesicong Date: Fri, 22 Sep 2023 10:10:35 +0800 Subject: [PATCH 02/14] =?UTF-8?q?=E4=B8=8A=E4=BC=A0=E5=A3=B0=E5=8D=A1?= =?UTF-8?q?=E7=B1=BB=E5=AE=9E=E7=8E=B0=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xiesicong --- .../alsa_adapter/include/alsa_soundcard.h | 139 ++ .../alsa_adapter/src/alsa_soundcard.c | 1356 +++++++++++++++++ 2 files changed, 1495 insertions(+) create mode 100755 audio/supportlibs/alsa_adapter/include/alsa_soundcard.h create mode 100755 audio/supportlibs/alsa_adapter/src/alsa_soundcard.c diff --git a/audio/supportlibs/alsa_adapter/include/alsa_soundcard.h b/audio/supportlibs/alsa_adapter/include/alsa_soundcard.h new file mode 100755 index 0000000000..2cbc40407c --- /dev/null +++ b/audio/supportlibs/alsa_adapter/include/alsa_soundcard.h @@ -0,0 +1,139 @@ +/* + * Copyright (c) 2022 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 ALSA_SOUNDCARD_H +#define ALSA_SOUNDCARD_H + +#include "audio_common.h" +#include "audio_if_lib_common.h" +#include "hdf_io_service_if.h" +#include "asoundlib.h" +#include "osal_mem.h" +#include "osal_time.h" +#include "hdf_sbuf.h" +#include "audio_uhdf_log.h" +#include "securec.h" +#include "local.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define SERVIC_NAME_MAX_LEN 32 +#define MAX_VOLUME 100 +#define MIN_VOLUME 0 +#define AUDIO_MIN_CARD_NUM 1 +#define AUDIO_MAX_CARD_NUM 8 +#define CARD_ID_LEN_MAX 32 +#define MAX_CARD_NAME_LEN 64 +#define MAX_CARD_NUM (4 * (AUDIO_MAX_CARD_NUM)) +#define MAX_CTL_NAME_LEN 64 +#define MAX_CTL_VALUE_LEN 32 +#define AUDIO_ALSALIB_IOCTRL_RESUME 0 +#define AUDIO_ALSALIB_IOCTRL_PAUSE 1 +#define AUDIO_ALSALIB_MMAP_MAX 10 +#define AUDIO_ALSALIB_RETYR 3 +#define ALSA_CTL_NAME_LEN 64 +#define MIXER_CTL_MAX_NUM 64 + +enum SndCardType { + SND_CARD_UNKNOWN = -1, + SND_CARD_PRIMARY = 0, + SND_CARD_HDMI, + SND_CARD_USB, + SND_CARD_BT, + SND_CARD_MAX +}; + +enum SndIfaceType { + IFACE_CARD = 0, + IFACE_MIXER, + IFACE_PCM, + IFACE_RAWMIDI, + IFACE_TIMER, + IFACE_SEQUENCER +}; + +struct AlsaMixerCtlElement { + unsigned int numid; + enum SndIfaceType iface; + char *name; + char *value; + unsigned int index; + unsigned int device; + unsigned int subdevice; +}; + +typedef struct AlsaSoundCard AlsaSoundCard; +struct AlsaSoundCard{ + /* + save alsa soundcard base info and hardware params + */ + enum SndCardType cardType; + char adapterName[MAX_CARD_NAME_LEN + 1]; //save adapterName + char devName[MAX_CARD_NAME_LEN + 1]; //device name hw:x + char alsaCardId[MAX_CARD_NAME_LEN + 1]; + char ctrlName[MAX_CARD_NAME_LEN + 1]; + struct AudioPcmHwParams hwParams; + + /* + alsa soundcard driver handle + */ + snd_pcm_t *pcmHandle; + snd_mixer_t *mixerHandle; + + /* + alsa soundcard public variable + */ + uint8_t cardStatus; + bool canPause; + bool pauseState; + int32_t muteValue; + bool mmapFlag; + uint64_t mmapFrames; +}; + +struct DevHandle *AudioBindService(const char *name); +void AudioCloseService(const struct DevHandle *handle); +struct HdfIoService *HdfIoServiceBindName(const char *serviceName); + +int32_t SndMatchSelAdapter(struct AlsaSoundCard *cardIns, const char *adapterName); +int32_t SndConverAlsaPcmFormat(const struct AudioPcmHwParams *hwParams, snd_pcm_format_t *alsaPcmFormat); +int32_t SndSaveCardListInfo(snd_pcm_stream_t stream); +bool SndisBusy(struct AlsaSoundCard *cardIns); +int32_t SndOpenMixer(struct AlsaSoundCard *cardIns); +int32_t SndPcmPrepare(struct AlsaSoundCard *cardIns); +int32_t SndPcmPause(struct AlsaSoundCard *cardIns, bool state); +snd_pcm_state_t SndGetRunState(struct AlsaSoundCard *cardIns); +void SndCloseHandle(struct AlsaSoundCard *cardIns); + +void SndElementItemInit(struct AlsaMixerCtlElement *m); +int32_t SndElementReadInt(struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, long *value); +int32_t SndElementReadEnum(struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, unsigned int *item); +int32_t SndElementReadRange(struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, long *mix, long *max); +int32_t SndElementReadSwitch(struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, bool *on); +int32_t SndElementWriteInt(struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, long value); +int32_t SndElementWriteEnum(struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, unsigned int item); +int32_t SndElementWriteSwitch(struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, bool on); +int32_t SndElementWrite(struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem); +int32_t SndElementGroupWrite(struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement* elemGroup, int32_t groupSize); +int32_t SndTraversalMixerElement(struct AlsaSoundCard *cardIns, + bool (*callback)(void *data, snd_ctl_elem_id_t *elem_id), void *data); + +#ifdef __cplusplus +} +#endif + +#endif /* ALSA_SOUNDCARD_H */ \ No newline at end of file diff --git a/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c b/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c new file mode 100755 index 0000000000..4f1979eb31 --- /dev/null +++ b/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c @@ -0,0 +1,1356 @@ +/* + * Copyright (c) 2022 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 "alsa_soundcard.h" +#include +#include "cJSON.h" + +#define HDF_LOG_TAG HDF_AUDIO_HAL_SND + +#define ALSA_CARD_CONFIG_FILE HDF_CONFIG_DIR "/alsa_adapter.json" +#define ALSA_CONFIG_FILE_MAX (2 * 1024) // 2KB +#define USB_AUDIO "USB Audio" +#define SUPPORT_CAPTURE_OR_RENDER 1 +#define SUPPORT_CAPTURE_AND_RENDER 2 + +/* Define structure description alsa_adapter.hson information */ +struct AlsaAdapterCfgInfo { + char adapterName[MAX_CARD_NAME_LEN]; + int32_t cardId; + char cardName[MAX_CARD_NAME_LEN]; +}; +struct AlsaAdapterList { + int32_t num; + struct AlsaAdapterCfgInfo list[AUDIO_MAX_CARD_NUM]; +}; +static struct AlsaAdapterList g_alsaAdapterList[SND_CARD_MAX]; + +struct AlsaDevInfo { + char cardId[MAX_CARD_NAME_LEN + 1]; + char pcmInfoId[MAX_CARD_NAME_LEN + 1]; + int32_t card; + int32_t device; +}; +struct AlsaCardsList { + int32_t num; + struct AlsaDevInfo alsaDevIns[MAX_CARD_NUM]; +}; +static struct AlsaCardsList g_alsaCardsDevList; + + +static char *CfgReadAdapterFile(const char *fpath) +{ + int32_t jsonStrSize; + FILE *fp = NULL; + char *pJsonStr = NULL; + char pathBuf[PATH_MAX] = {0}; + + if (fpath == NULL) { + AUDIO_FUNC_LOGE("Parameter is null!!!"); + return NULL; + } + if (realpath(fpath, pathBuf) == NULL) { + AUDIO_FUNC_LOGE("File path invalid!"); + return NULL; + } + + fp = fopen(pathBuf, "r"); + if (fp == NULL) { + AUDIO_FUNC_LOGE("Can not open config file [ %{public}s ].", fpath); + return NULL; + } + if (fseek(fp, 0, SEEK_END) != 0) { + AUDIO_FUNC_LOGE("fseek configuration file error!"); + (void)fclose(fp); + return NULL; + } + jsonStrSize = ftell(fp); + if (jsonStrSize <= 0) { + AUDIO_FUNC_LOGE("The configuration file size <= 0!"); + (void)fclose(fp); + return NULL; + } + rewind(fp); + if (jsonStrSize > ALSA_CONFIG_FILE_MAX) { + AUDIO_FUNC_LOGE("The configuration file is too large to load!"); + (void)fclose(fp); + return NULL; + } + pJsonStr = (char *)OsalMemCalloc((uint32_t)jsonStrSize + 1); + if (pJsonStr == NULL) { + AUDIO_FUNC_LOGE("OsalMemCalloc pJsonStr failed!"); + (void)fclose(fp); + return NULL; + } + if (fread(pJsonStr, jsonStrSize, 1, fp) != 1) { + AUDIO_FUNC_LOGE("Read to config file failed!!!"); + (void)fclose(fp); + AudioMemFree((void **)&pJsonStr); + return NULL; + } + (void)fclose(fp); + + return pJsonStr; +} + +static int32_t CfgGetAdapterCount() +{ + int32_t num = 0; + for(enum SndCardType type = SND_CARD_PRIMARY; type < SND_CARD_MAX; ++type) { + num += g_alsaAdapterList[type].num; + } + return num; +} + +static enum SndCardType CfgGetAdapterCardType(const char* adapterName) +{ + if(adapterName == NULL) { + return SND_CARD_UNKNOWN; + } + + struct AlsaAdapterCfgInfo *info; + for(enum SndCardType type = SND_CARD_PRIMARY; type < SND_CARD_MAX; ++type) { + for(int32_t i = 0; i < g_alsaAdapterList[type].num; ++i) { + info = &g_alsaAdapterList[type].list[i]; + if(strcmp(adapterName, info->adapterName) == 0) { + return type; + } + } + } + return SND_CARD_UNKNOWN; +} + +static struct AlsaAdapterCfgInfo *CfgGetAdapterInfo(const char* adapterName) +{ + if(adapterName == NULL) { + return NULL; + } + + struct AlsaAdapterCfgInfo *info; + for(enum SndCardType type = SND_CARD_PRIMARY; type < SND_CARD_MAX; ++type) { + for(int32_t i = 0; i < g_alsaAdapterList[type].num; ++i) { + info = &g_alsaAdapterList[type].list[i]; + if(strcmp(adapterName, info->adapterName) == 0) { + return info; + } + } + } + return NULL; +} + +static int32_t CfgDumpAdapterInfo(struct AlsaAdapterCfgInfo *info) +{ + int32_t ret, idx; + enum SndCardType cardType = SND_CARD_UNKNOWN; + CHECK_NULL_PTR_RETURN_DEFAULT(info); + + if (strcmp(info->adapterName, "primary") == 0) { + cardType = SND_CARD_PRIMARY; + } else if (strcmp(info->adapterName, "hdmi") == 0) { + cardType = SND_CARD_HDMI; + } else if (strcmp(info->adapterName, "usb") == 0) { + cardType = SND_CARD_USB; + } else if (strcmp(info->adapterName, "bt") == 0) { + cardType = SND_CARD_BT; + } + + if(cardType == SND_CARD_UNKNOWN) { + AUDIO_FUNC_LOGE("Error: %{public}s is unspupported adapter name", info->adapterName); + } + + idx = g_alsaAdapterList[cardType].num; + ret = memcpy_s((void*)&g_alsaAdapterList[cardType].list[idx], sizeof(struct AlsaAdapterCfgInfo), + (void*)info, sizeof(struct AlsaAdapterCfgInfo)); + if (ret != EOK) { + AUDIO_FUNC_LOGE("memcpy_s g_alsaAdapterList fail!"); + return HDF_FAILURE; + } + g_alsaAdapterList[cardType].num++; + + AUDIO_FUNC_LOGI("cardId:%{public}d: adapterName:%{public}s, cardName:%{public}s", + g_alsaAdapterList[cardType].list[idx].cardId, + g_alsaAdapterList[cardType].list[idx].adapterName, + g_alsaAdapterList[cardType].list[idx].cardName); + return HDF_SUCCESS; +} + +static int32_t CfgSaveAdapterStruct(cJSON *adapter, struct AlsaAdapterCfgInfo *info) +{ + int32_t ret; + cJSON *item; + CHECK_NULL_PTR_RETURN_DEFAULT(adapter); + CHECK_NULL_PTR_RETURN_DEFAULT(info); + + item = cJSON_GetObjectItem(adapter, "name"); + if (item == NULL || item->valuestring == NULL) { + AUDIO_FUNC_LOGE("adapter name is null!"); + return HDF_FAILURE; + } + ret = memcpy_s(info->adapterName, MAX_CARD_NAME_LEN - 1, item->valuestring, MAX_CARD_NAME_LEN - 1); + if (ret != EOK) { + AUDIO_FUNC_LOGE("memcpy_s adapterName fail!"); + return HDF_FAILURE; + } + + item = cJSON_GetObjectItem(adapter, "cardId"); + if (item == NULL) { + AUDIO_FUNC_LOGE("cardId not set!"); + return HDF_FAILURE; + } + info->cardId = item->valuedouble; + + item = cJSON_GetObjectItem(adapter, "cardName"); + if (item == NULL || item->valuestring == NULL) { + AUDIO_FUNC_LOGE("cardName is null!"); + return HDF_FAILURE; + } + ret = memcpy_s(info->cardName, MAX_CARD_NAME_LEN - 1, item->valuestring, MAX_CARD_NAME_LEN - 1); + if (ret != EOK) { + AUDIO_FUNC_LOGE("memcpy_s cardName fail!"); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t CfgSaveAdapterFromFile(void) +{ + int32_t ret, adapterNum; + cJSON *adapterObj = NULL; + cJSON *adapterItems = NULL; + char *configBuf = NULL; + + configBuf = CfgReadAdapterFile(ALSA_CARD_CONFIG_FILE); + if (configBuf == NULL) { + AUDIO_FUNC_LOGE("CfgReadAdapterFile failed!"); + return HDF_FAILURE; + } + adapterObj = cJSON_Parse(configBuf); + if (adapterObj == NULL) { + AUDIO_FUNC_LOGE("Parse json file failed!"); + AudioMemFree((void **)&configBuf); + return HDF_FAILURE; + } + AudioMemFree((void **)&configBuf); + + adapterItems = cJSON_GetObjectItem(adapterObj, "adapters"); + if (adapterItems == NULL) { + AUDIO_FUNC_LOGE("Get adapterItems from json failed!\n"); + cJSON_Delete(adapterObj); + return HDF_FAILURE; + } + adapterNum = cJSON_GetArraySize(adapterItems); + if (adapterNum <= 0) { + AUDIO_FUNC_LOGE("Get adapter number failed!"); + cJSON_Delete(adapterObj); + return HDF_FAILURE; + } + else if (adapterNum > MAX_CARD_NUM) { + AUDIO_FUNC_LOGE("Read adapters number is %{public}d over max num %{public}d!", adapterNum, MAX_CARD_NUM); + cJSON_Delete(adapterObj); + return HDF_FAILURE; + } + + for(int32_t i = 0; i < adapterNum; ++i) { + cJSON *adapter; + struct AlsaAdapterCfgInfo info; + adapter = cJSON_GetArrayItem(adapterItems, i); + if(adapter == NULL) { + AUDIO_FUNC_LOGE("Get adapter item from array failed!"); + cJSON_Delete(adapterObj); + } + + ret = CfgSaveAdapterStruct(adapter, &info); + if(ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("CfgSaveAdapterStruct failed!"); + cJSON_Delete(adapterObj); + return HDF_FAILURE; + } + + ret = CfgDumpAdapterInfo(&info); + if(ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("CfgDumpAdapterInfo failed!"); + cJSON_Delete(adapterObj); + return HDF_FAILURE; + } + } + + return HDF_SUCCESS; +} + +static struct AlsaDevInfo *DevGetInfoByCardId(int32_t cardId) +{ + struct AlsaDevInfo * info = NULL; + int num = g_alsaCardsDevList.num; + for(int i = 0; i < num; ++i) { + info = &g_alsaCardsDevList.alsaDevIns[i]; + if(info->card == cardId) { + return info; + } + } + return NULL; +} + +static struct AlsaDevInfo *DevGetInfoByPcmInfoId(const char * name) +{ + struct AlsaDevInfo *info = NULL; + int num = g_alsaCardsDevList.num; + for(int i = 0; i < num; ++i) { + info = &g_alsaCardsDevList.alsaDevIns[i]; + if(strcmp(name, info->pcmInfoId) == 0) { + return info; + } + } + + return NULL; +} + +static int32_t DevSaveCardPcmInfo(snd_ctl_t *handle, snd_pcm_stream_t stream, int card, const char *deviceName) +{ + int32_t ret; + int pcmDev = -1; + snd_ctl_card_info_t *info = NULL; + snd_pcm_info_t *pcminfo = NULL; + + snd_ctl_card_info_alloca(&info); + snd_pcm_info_alloca(&pcminfo); + + ret = snd_ctl_card_info(handle, info); + if(ret != 0) { + AUDIO_FUNC_LOGE("snd_ctl_card_info failed."); + return HDF_FAILURE; + } + + ret = snd_ctl_pcm_next_device(handle, &pcmDev); + if(ret < 0 || pcmDev < 0) { + AUDIO_FUNC_LOGE("No pcm device found: %{public}s.", snd_strerror(ret)); + return HDF_FAILURE; + } + + while(pcmDev >= 0) { + snd_pcm_info_set_device(pcminfo, pcmDev); + snd_pcm_info_set_subdevice(pcminfo, 0); + snd_pcm_info_set_stream(pcminfo, stream); + ret = snd_ctl_pcm_info(handle, pcminfo); + if(ret < 0) { + if (ret != -ENOENT) { + AUDIO_FUNC_LOGE("control digital audio info (%{public}d): %{public}s", pcmDev, snd_strerror(ret)); + } + continue; + } + + struct AlsaDevInfo *devInfo = &g_alsaCardsDevList.alsaDevIns[g_alsaCardsDevList.num]; + const char *cardId = snd_ctl_card_info_get_id(info); + const char *pcmInfoId = snd_pcm_info_get_id(pcminfo); + CHECK_NULL_PTR_RETURN_DEFAULT(cardId); + CHECK_NULL_PTR_RETURN_DEFAULT(pcmInfoId); + AUDIO_FUNC_LOGE("card %{public}s: pcm: %{public}s", cardId, pcmInfoId); + + devInfo->card = card; + devInfo->device = pcmDev; + ret = strncpy_s(devInfo->cardId, MAX_CARD_NAME_LEN + 1, cardId, strlen(cardId)); + if (ret != 0) { + AUDIO_FUNC_LOGE("strncpy_s failed!"); + return HDF_FAILURE; + } + ret = strncpy_s(devInfo->pcmInfoId, MAX_CARD_NAME_LEN + 1, pcmInfoId, strlen(pcmInfoId)); + if (ret != 0) { + AUDIO_FUNC_LOGE("strncpy_s failed!"); + return HDF_FAILURE; + } + g_alsaCardsDevList.num++; + + ret = snd_ctl_pcm_next_device(handle, &pcmDev); + if(ret < 0) { + AUDIO_FUNC_LOGE("snd_ctl_pcm_next_device error: %{public}s.", snd_strerror(ret)); + return HDF_FAILURE; + } + } + + return HDF_SUCCESS; +} + +static int32_t DevSaveDriverInfo(snd_pcm_stream_t stream) +{ + int32_t ret; + snd_ctl_t *handle; + int card = -1; + char deviceName[MAX_CARD_NAME_LEN] = {0}; + + ret = snd_card_next(&card); + if (ret < 0 || card < 0) { + AUDIO_FUNC_LOGE("No soundcards found: %{public}s.", snd_strerror(ret)); + return HDF_FAILURE; + } + + while (card >= 0) { + (void)memset_s(deviceName, MAX_CARD_NAME_LEN, 0, MAX_CARD_NAME_LEN); + ret = snprintf_s(deviceName, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "hw:%d", card); + if (ret < 0) { + AUDIO_FUNC_LOGE("snprintf_s failed"); + snd_ctl_close(handle); + return HDF_FAILURE; + } + + ret = snd_ctl_open(&handle, deviceName, 0); + if(ret != 0) { + AUDIO_FUNC_LOGE("snd_ctl_open failed."); + return HDF_FAILURE; + } + + ret = DevSaveCardPcmInfo(handle, stream, card, deviceName); + if(ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("save alsa sound cards %{public}s pcm info failed!",deviceName); + } + + ret = snd_ctl_close(handle); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_ctl_close error: %{public}s.", snd_strerror(ret)); + return HDF_FAILURE; + } + + ret = snd_card_next(&card); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_card_next error: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + } + + return HDF_SUCCESS; +} + +int32_t SndSaveCardListInfo(snd_pcm_stream_t stream) +{ + int32_t ret; + + (void)memset_s(&g_alsaAdapterList, sizeof(struct AlsaAdapterList) * SND_CARD_MAX, + 0, sizeof(struct AlsaAdapterList) * SND_CARD_MAX); + (void)memset_s(&g_alsaCardsDevList, sizeof(struct AlsaCardsList), + 0, sizeof(struct AlsaCardsList)); + + /* Parse sound card from configuration file */ + ret = CfgSaveAdapterFromFile(); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("parse config file failed! ret = %{public}d", ret); + return HDF_FAILURE; + } + + /* Read sound card list from alsa hardware */ + ret = DevSaveDriverInfo(stream); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("failed to save alsa sound cards driver info"); + return HDF_FAILURE; + } + + /* if the alsa hardware include usb then add to adapter list */ + struct AlsaDevInfo *devInfo = DevGetInfoByPcmInfoId(USB_AUDIO); + if(devInfo != NULL) { + g_alsaAdapterList[SND_CARD_USB].num = 1; + ret = memcpy_s((void*)&g_alsaAdapterList[SND_CARD_USB].list[0].adapterName, MAX_CARD_NAME_LEN, + USB_AUDIO, sizeof(USB_AUDIO)); + if (ret != EOK) { + AUDIO_FUNC_LOGE("memcpy_s adapterName fail!"); + return HDF_FAILURE; + } + } + + return HDF_SUCCESS; +} + +int32_t SndMatchSelAdapter(struct AlsaSoundCard *cardIns, const char *adapterName) +{ + int32_t ret; + enum SndCardType cardType; + struct AlsaAdapterCfgInfo *info = NULL; + struct AlsaDevInfo * devInfo = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(adapterName); + + cardType = CfgGetAdapterCardType(adapterName); + if(cardType == SND_CARD_UNKNOWN) { + AUDIO_FUNC_LOGE("unknow card type error."); + return HDF_FAILURE; + } + cardIns->cardType = cardType; + + info = CfgGetAdapterInfo(adapterName); + if(info == NULL) { + AUDIO_FUNC_LOGE("adapter %{public}s is not exits.", cardIns->adapterName); + return HDF_FAILURE; + } + + devInfo = DevGetInfoByCardId(info->cardId); + if(devInfo == NULL) { + AUDIO_FUNC_LOGE("adapter %{public}s cant not find sound card device.", cardIns->adapterName); + return HDF_FAILURE; + } + + ret = snprintf_s(cardIns->devName, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "hw:%d,%d", devInfo->card, devInfo->device); + if(ret < 0) { + AUDIO_FUNC_LOGE("%{public}s snprintf_s devName failed",cardIns->adapterName); + return HDF_FAILURE; + } + ret = snprintf_s(cardIns->ctrlName, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "hw:%d", devInfo->card); + if(ret < 0) { + AUDIO_FUNC_LOGE("%{public}s snprintf_s ctrlName failed",cardIns->adapterName); + return HDF_FAILURE; + } + ret = snprintf_s(cardIns->alsaCardId, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "%s", devInfo->cardId); + if(ret < 0) { + AUDIO_FUNC_LOGE("%{public}s snprintf_s alsaCardId failed",cardIns->adapterName); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t SndConverAlsaPcmFormat(const struct AudioPcmHwParams *hwParams, snd_pcm_format_t *alsaPcmFormat) +{ + CHECK_NULL_PTR_RETURN_DEFAULT(hwParams); + CHECK_NULL_PTR_RETURN_DEFAULT(alsaPcmFormat); + enum AudioFormat audioFormat = hwParams->format; + bool isBigEndian = hwParams->isBigEndian; + + /** Little Endian */ + if (!isBigEndian) { + switch (audioFormat) { + case AUDIO_FORMAT_TYPE_PCM_8_BIT: + *alsaPcmFormat = SND_PCM_FORMAT_S8; /** Signed 8 bit */ + break; + case AUDIO_FORMAT_TYPE_PCM_16_BIT: + *alsaPcmFormat = SND_PCM_FORMAT_S16_LE; /** Signed 16 bit Little Endian */ + break; + case AUDIO_FORMAT_TYPE_PCM_24_BIT: + *alsaPcmFormat = SND_PCM_FORMAT_S24_LE; /** Signed 24 bit Little Endian */ + break; + case AUDIO_FORMAT_TYPE_PCM_32_BIT: + *alsaPcmFormat = SND_PCM_FORMAT_S32_LE; /** Signed 32 bit Little Endian */ + break; + default: + AUDIO_FUNC_LOGE("not support format %{public}d",audioFormat); + return HDF_ERR_NOT_SUPPORT; + } + } else { /** Big Endian */ + switch (audioFormat) { + case AUDIO_FORMAT_TYPE_PCM_8_BIT: + *alsaPcmFormat = SND_PCM_FORMAT_S8; /** Signed 8 bit */ + break; + case AUDIO_FORMAT_TYPE_PCM_16_BIT: + *alsaPcmFormat = SND_PCM_FORMAT_S16_BE; /** Signed 16 bit Big Endian */ + break; + case AUDIO_FORMAT_TYPE_PCM_24_BIT: + *alsaPcmFormat = SND_PCM_FORMAT_S24_BE; /** Signed 24 bit Big Endian */ + break; + case AUDIO_FORMAT_TYPE_PCM_32_BIT: + *alsaPcmFormat = SND_PCM_FORMAT_S32_BE; /** Signed 32 bit Big Endian */ + break; + default: + AUDIO_FUNC_LOGE("not support format %{public}d",audioFormat); + return HDF_ERR_NOT_SUPPORT; + } + } + + return HDF_SUCCESS; +} + +int32_t SndPcmPrepare(struct AlsaSoundCard *cardIns) +{ + int32_t ret; + ret = snd_pcm_prepare(cardIns->pcmHandle); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_pcm_prepare fail: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t SndPcmPause(struct AlsaSoundCard *cardIns, bool state) +{ + int32_t ret; + int enable = state ? AUDIO_ALSALIB_IOCTRL_PAUSE : AUDIO_ALSALIB_IOCTRL_RESUME; + + if (cardIns->canPause) { + ret = snd_pcm_pause(cardIns->pcmHandle, enable); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_pcm_pause failed!"); + return HDF_FAILURE; + } + } else { + if(enable == AUDIO_ALSALIB_IOCTRL_PAUSE) { + snd_pcm_drop(cardIns->pcmHandle); + } else { + snd_pcm_prepare(cardIns->pcmHandle); + } + } + cardIns->pauseState = state; + + return HDF_SUCCESS; +} + +bool SndisBusy(struct AlsaSoundCard *cardIns) +{ + return (cardIns->pcmHandle == NULL) ? false : true; +} + +int32_t SndOpenMixer(struct AlsaSoundCard *cardIns) +{ + int32_t ret; + + if (strlen(cardIns->ctrlName) == 0) { + AUDIO_FUNC_LOGE("The soundcard ctrname is null."); + return HDF_FAILURE; + } + + ret = snd_mixer_open(&cardIns->mixerHandle, 0); + if (ret < 0) { + AUDIO_FUNC_LOGE("Failed to open mixer: %{public}s.", snd_strerror(ret)); + return HDF_FAILURE; + } + + ret = snd_mixer_attach(cardIns->mixerHandle, cardIns->ctrlName); + if (ret < 0) { + AUDIO_FUNC_LOGE("Failed to attach mixer: %{public}s.", snd_strerror(ret)); + snd_mixer_close(cardIns->mixerHandle); + return HDF_FAILURE; + } + + ret = snd_mixer_selem_register(cardIns->mixerHandle, NULL, NULL); + if (ret < 0) { + AUDIO_FUNC_LOGE("Failed to register mixer element: %{public}s.", snd_strerror(ret)); + snd_mixer_close(cardIns->mixerHandle); + return HDF_FAILURE; + } + + ret = snd_mixer_load(cardIns->mixerHandle); + if (ret < 0) { + AUDIO_FUNC_LOGE("Failed to load mixer element: %{public}s.", snd_strerror(ret)); + snd_mixer_close(cardIns->mixerHandle); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +snd_pcm_state_t SndGetRunState(struct AlsaSoundCard * cardIns) +{ + return snd_pcm_state(cardIns->pcmHandle); +} + +void SndCloseHandle(struct AlsaSoundCard *cardIns) +{ + int32_t ret; + if (cardIns->cardStatus > 0) { + cardIns->cardStatus -= 1; + } + if (cardIns->cardStatus == 0) { + if (cardIns->pcmHandle != NULL) { + ret = snd_pcm_close(cardIns->pcmHandle); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_pcm_close fail: %{public}s", snd_strerror(ret)); + } + cardIns->pcmHandle = NULL; + } + if (cardIns->mixerHandle != NULL) { + ret = snd_mixer_close(cardIns->mixerHandle); + if (ret < 0) { + AUDIO_FUNC_LOGE("mixer close error: %{public}s.", snd_strerror(ret)); + } + cardIns->mixerHandle = NULL; + } + (void)memset_s(cardIns, sizeof(struct AlsaSoundCard), 0, sizeof(struct AlsaSoundCard)); + } +} + +static void AudioInitPortOut(struct AudioPort *audioPort) +{ + audioPort->dir = PORT_OUT; + audioPort->portId = 0; + audioPort->portName = strdup("AOP"); +} + +static void AudioInitPortIn(struct AudioPort *audioPort) +{ + audioPort->dir = PORT_IN; + audioPort->portId = 0; + audioPort->portName = strdup("AIP"); +} + +static void AudioInitPortOutAndIn(struct AudioPort *audioPort) +{ + audioPort->dir = PORT_OUT_IN; + audioPort->portId = 0; + audioPort->portName = strdup("AIOP"); +} + +static int32_t AudioInitPorts(struct AudioAdapterDescriptor *desc, enum SndCardType type) +{ + uint8_t portNum; + CHECK_NULL_PTR_RETURN_DEFAULT(desc); + + switch(type) + { + case SND_CARD_PRIMARY: + portNum = PORT_OUT_IN; + break; + case SND_CARD_HDMI: + portNum = PORT_OUT; + break; + case SND_CARD_USB: + portNum = PORT_IN; + break; + default: + AUDIO_FUNC_LOGE("Unknown sound card type does not support this sound card temporarily!"); + return HDF_FAILURE; + } + +#ifndef AUDIO_HDI_SERVICE_MODE + desc->portNum = portNum; +#else + desc->portsLen = portNum; +#endif + + desc->ports = (struct AudioPort *)OsalMemCalloc(sizeof(struct AudioPort) * portNum); + if (desc->ports == NULL) { + AUDIO_FUNC_LOGE("OsalMemCalloc failed!"); + return HDF_ERR_MALLOC_FAIL; + } + + if(type == SND_CARD_PRIMARY) { + AudioInitPortOut(&desc->ports[0]); + AudioInitPortIn(&desc->ports[SUPPORT_CAPTURE_OR_RENDER]); + AudioInitPortOutAndIn(&desc->ports[SUPPORT_CAPTURE_AND_RENDER]); + } else if (type == SND_CARD_HDMI) { + AudioInitPortOut(&desc->ports[0]); + } else if (type == SND_CARD_USB) { + AudioInitPortOut(&desc->ports[0]); + AudioInitPortIn(&desc->ports[SUPPORT_CAPTURE_OR_RENDER]); + } else { + AUDIO_FUNC_LOGE("adapter list not support sound card type %{public}d", type); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioGetAllCardInfo(struct AudioAdapterDescriptor **descs, int32_t *sndCardNum) +{ + int32_t ret, idx; + int32_t adapterNum; + CHECK_NULL_PTR_RETURN_DEFAULT(descs); + CHECK_NULL_PTR_RETURN_DEFAULT(sndCardNum); + + ret = SndSaveCardListInfo(SND_PCM_STREAM_PLAYBACK); + if (ret != HDF_SUCCESS) { + return HDF_FAILURE; + } + + adapterNum = CfgGetAdapterCount(); + if (*descs == NULL) { + AUDIO_FUNC_LOGW("*descs is null, need memcalloc."); + *descs = (struct AudioAdapterDescriptor *)OsalMemCalloc(sizeof(struct AudioAdapterDescriptor) * adapterNum); + if (*descs == NULL) { + AUDIO_FUNC_LOGE("OsalMemCalloc descs is NULL"); + return HDF_ERR_MALLOC_FAIL; + } + } + *sndCardNum = adapterNum; + + idx = 0; + for(enum SndCardType type = SND_CARD_PRIMARY; type < SND_CARD_MAX; ++type) { + for(int32_t i = 0; i < g_alsaAdapterList[type].num; ++i) { + (*descs)[idx].adapterName = strdup(g_alsaAdapterList[type].list[i].adapterName); + AudioInitPorts(&(*descs)[idx], type); + AUDIO_FUNC_LOGI("adapter name : %{public}s", (*descs)[idx].adapterName); + idx++; + } + } + + return HDF_SUCCESS; +} + +struct HdfIoService *HdfIoServiceBindName(const char *serviceName) +{ + (void)serviceName; + /* Nothing to do */ + static struct HdfIoService hdfIoService; + return &hdfIoService; +} + +struct DevHandle *AudioBindService(const char *name) +{ + struct DevHandle *handle = NULL; + + if (name == NULL) { + AUDIO_FUNC_LOGE("service name NULL!"); + return NULL; + } + + handle = (struct DevHandle *)OsalMemCalloc(sizeof(struct DevHandle)); + if (handle == NULL) { + AUDIO_FUNC_LOGE("OsalMemCalloc handle failed!!!"); + return NULL; + } + + AUDIO_FUNC_LOGI("BIND SERVICE SUCCESS!"); + return handle; +} + +void AudioCloseService(const struct DevHandle *handle) +{ + if (handle != NULL) { + AudioMemFree((void **)&handle); + } +} + +void SndElementItemInit(struct AlsaMixerCtlElement *m) +{ + m->iface = IFACE_MIXER; + m->index = -1; + m->device = -1; + m->subdevice = -1; +} + +static int32_t SetElementInfo(snd_ctl_t *alsaHandle, const struct AlsaMixerCtlElement *ctlElem, + snd_ctl_elem_info_t *info, snd_ctl_elem_id_t *id) +{ + int32_t ret; + snd_ctl_elem_iface_t ifaceType; + CHECK_NULL_PTR_RETURN_DEFAULT(alsaHandle); + CHECK_NULL_PTR_RETURN_DEFAULT(ctlElem); + CHECK_NULL_PTR_RETURN_DEFAULT(info); + CHECK_NULL_PTR_RETURN_DEFAULT(id); + + if (ctlElem->numid >= 0) { + snd_ctl_elem_id_set_numid(id, ctlElem->numid); + } + if (ctlElem->index >= 0){ + snd_ctl_elem_id_set_index(id, ctlElem->index); + } + if (ctlElem->device >= 0){ + snd_ctl_elem_id_set_index(id, ctlElem->device); + } + if (ctlElem->subdevice >= 0){ + snd_ctl_elem_id_set_index(id, ctlElem->subdevice); + } + + switch(ctlElem->iface) { + case IFACE_CARD: + ifaceType = SND_CTL_ELEM_IFACE_CARD; + break; + case IFACE_MIXER: + ifaceType = SND_CTL_ELEM_IFACE_MIXER; + break; + case IFACE_PCM: + ifaceType = SND_CTL_ELEM_IFACE_PCM; + break; + case IFACE_RAWMIDI: + ifaceType = SND_CTL_ELEM_IFACE_RAWMIDI; + break; + case IFACE_TIMER: + ifaceType = SND_CTL_ELEM_IFACE_TIMER; + break; + case IFACE_SEQUENCER: + ifaceType = SND_CTL_ELEM_IFACE_SEQUENCER; + break; + default: + break; + } + + snd_ctl_elem_id_set_interface(id, ifaceType); + if (ctlElem->name) { + snd_ctl_elem_id_set_name(id, ctlElem->name); + } + snd_ctl_elem_info_set_id(info, id); + ret = snd_ctl_elem_info(alsaHandle, info); + if (ret < 0) { + AUDIO_FUNC_LOGE("Cannot find the given element from elem_value\n"); + return HDF_FAILURE; + } + snd_ctl_elem_info_get_id(info, id); + + return HDF_SUCCESS; +} + +int32_t SndElementReadInt + (struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, long *value) +{ + int ret; + snd_ctl_t *alsaHandle = NULL; + snd_ctl_elem_id_t *elem_id; + snd_ctl_elem_info_t *elem_info; + snd_ctl_elem_value_t *elem_value; + snd_ctl_elem_type_t type; + + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(ctlElem); + + ret = snd_ctl_open(&alsaHandle, cardIns->ctrlName, 0); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_ctl_open error: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + + snd_ctl_elem_id_alloca(&elem_id); + snd_ctl_elem_info_alloca(&elem_info); + snd_ctl_elem_value_alloca(&elem_value); + ret = SetElementInfo(alsaHandle, ctlElem, elem_info, elem_id); + if(ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Set element %{public}s elem_info failed!\n",ctlElem->name); + return HDF_FAILURE; + } + snd_ctl_elem_value_set_id(elem_value, elem_id); + + if(!snd_ctl_elem_info_is_readable(elem_info)) { + AUDIO_FUNC_LOGE("Element read enable\n"); + return HDF_FAILURE; + } + ret = snd_ctl_elem_read(alsaHandle, elem_value); + if (ret < 0) { + AUDIO_FUNC_LOGE("Cannot read the given element from elem_value \n"); + return HDF_FAILURE; + } + + type = snd_ctl_elem_info_get_type(elem_info); + if (type == SND_CTL_ELEM_TYPE_INTEGER) { + *value = snd_ctl_elem_value_get_integer(elem_value, 0); + } else if (type == SND_CTL_ELEM_TYPE_INTEGER64) { + *value = (long)snd_ctl_elem_value_get_integer64(elem_value, 0); + } else { + AUDIO_FUNC_LOGE("Element type is not interger\n"); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t SndElementReadEnum + (struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, unsigned int *item) +{ + int ret; + snd_ctl_t *alsaHandle = NULL; + snd_ctl_elem_id_t *elem_id; + snd_ctl_elem_info_t *elem_info; + snd_ctl_elem_value_t *elem_value; + snd_ctl_elem_type_t type; + + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(ctlElem); + + ret = snd_ctl_open(&alsaHandle, cardIns->ctrlName, 0); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_ctl_open error: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + + snd_ctl_elem_id_alloca(&elem_id); + snd_ctl_elem_info_alloca(&elem_info); + snd_ctl_elem_value_alloca(&elem_value); + ret = SetElementInfo(alsaHandle, ctlElem, elem_info, elem_id); + if(ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Set element %{public}s elem_info failed!\n",ctlElem->name); + return HDF_FAILURE; + } + snd_ctl_elem_value_set_id(elem_value, elem_id); + + if(!snd_ctl_elem_info_is_readable(elem_info)) { + AUDIO_FUNC_LOGE("Element read enable\n"); + return HDF_FAILURE; + } + ret = snd_ctl_elem_read(alsaHandle, elem_value); + if (ret < 0) { + AUDIO_FUNC_LOGE("Cannot read the given element from elem_value \n"); + return HDF_FAILURE; + } + + type = snd_ctl_elem_info_get_type(elem_info); + if(type == SND_CTL_ELEM_TYPE_ENUMERATED) { + *item = snd_ctl_elem_value_get_enumerated(elem_value, 0); + } else { + AUDIO_FUNC_LOGE("Element type is not enumerated\n"); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t SndElementReadRange + (struct AlsaSoundCard * cardIns, const struct AlsaMixerCtlElement * ctlElem, long * mix, long * max) +{ + int ret; + snd_ctl_t *alsaHandle = NULL; + snd_ctl_elem_id_t *elem_id; + snd_ctl_elem_info_t *elem_info; + snd_ctl_elem_value_t *elem_value; + snd_ctl_elem_type_t type; + + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(ctlElem); + + ret = snd_ctl_open(&alsaHandle, cardIns->ctrlName, 0); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_ctl_open error: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + + snd_ctl_elem_id_alloca(&elem_id); + snd_ctl_elem_info_alloca(&elem_info); + snd_ctl_elem_value_alloca(&elem_value); + ret = SetElementInfo(alsaHandle, ctlElem, elem_info, elem_id); + if(ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Set element %{public}s elem_info failed!\n",ctlElem->name); + return HDF_FAILURE; + } + snd_ctl_elem_value_set_id(elem_value, elem_id); + + if(!snd_ctl_elem_info_is_readable(elem_info)) { + AUDIO_FUNC_LOGE("Element read enable\n"); + return HDF_FAILURE; + } + ret = snd_ctl_elem_read(alsaHandle, elem_value); + if (ret < 0) { + AUDIO_FUNC_LOGE("Cannot read the given element from elem_value \n"); + return HDF_FAILURE; + } + + type = snd_ctl_elem_info_get_type(elem_info); + if(type == SND_CTL_ELEM_TYPE_INTEGER) { + *mix = snd_ctl_elem_info_get_min(elem_info); + *max = snd_ctl_elem_info_get_max(elem_info); + } else if (type == SND_CTL_ELEM_TYPE_INTEGER64) { + *mix = (long)snd_ctl_elem_info_get_min64(elem_info); + *max = (long)snd_ctl_elem_info_get_max64(elem_info); + } else { + AUDIO_FUNC_LOGE("Element value is not integer type!\n"); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t SndElementReadSwitch + (struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, bool *on) +{ + int ret; + snd_ctl_t *alsaHandle = NULL; + snd_ctl_elem_id_t *elem_id; + snd_ctl_elem_info_t *elem_info; + snd_ctl_elem_value_t *elem_value; + snd_ctl_elem_type_t type; + + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(ctlElem); + + ret = snd_ctl_open(&alsaHandle, cardIns->ctrlName, 0); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_ctl_open error: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + + snd_ctl_elem_id_alloca(&elem_id); + snd_ctl_elem_info_alloca(&elem_info); + snd_ctl_elem_value_alloca(&elem_value); + ret = SetElementInfo(alsaHandle, ctlElem, elem_info, elem_id); + if(ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Set element %{public}s elem_info failed!\n",ctlElem->name); + return HDF_FAILURE; + } + snd_ctl_elem_value_set_id(elem_value, elem_id); + + if(!snd_ctl_elem_info_is_readable(elem_info)) { + AUDIO_FUNC_LOGE("Element read enable\n"); + return HDF_FAILURE; + } + ret = snd_ctl_elem_read(alsaHandle, elem_value); + if (ret < 0) { + AUDIO_FUNC_LOGE("Cannot read the given element from elem_value \n"); + return HDF_FAILURE; + } + + type = snd_ctl_elem_info_get_type(elem_info); + if(type == SND_CTL_ELEM_TYPE_BOOLEAN) { + ret = snd_ctl_elem_value_get_boolean(elem_value, 0); + *on = (ret > 0) ? true : false; + } else { + AUDIO_FUNC_LOGE("Element type is not boolean\n"); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t SndElementWriteInt + (struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, long value) +{ + int ret; + snd_ctl_t *alsaHandle = NULL; + snd_ctl_elem_id_t *elem_id; + snd_ctl_elem_info_t *elem_info; + snd_ctl_elem_value_t *elem_value; + snd_ctl_elem_type_t type; + + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(ctlElem); + + ret = snd_ctl_open(&alsaHandle, cardIns->ctrlName, 0); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_ctl_open error: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + + snd_ctl_elem_id_alloca(&elem_id); + snd_ctl_elem_info_alloca(&elem_info); + snd_ctl_elem_value_alloca(&elem_value); + ret = SetElementInfo(alsaHandle, ctlElem, elem_info, elem_id); + if(ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Set element %{public}s elem_info failed!\n", ctlElem->name); + return HDF_FAILURE; + } + + if(!snd_ctl_elem_info_is_writable(elem_info)) { + AUDIO_FUNC_LOGE("Element write enable\n"); + return HDF_FAILURE; + } + + snd_ctl_elem_value_set_id(elem_value, elem_id); + type = snd_ctl_elem_info_get_type(elem_info); + if(type == SND_CTL_ELEM_TYPE_INTEGER) { + snd_ctl_elem_value_set_integer(elem_value, 0, value); + } else if (type == SND_CTL_ELEM_TYPE_INTEGER64) { + snd_ctl_elem_value_set_integer64(elem_value, 0, (long long)value); + } else { + AUDIO_FUNC_LOGE("Element value is not integer type!\n"); + return HDF_FAILURE; + } + + ret = snd_ctl_elem_write(alsaHandle, elem_value); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_ctl_elem_write failed!\n"); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t SndElementWriteEnum + (struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, unsigned int item) +{ + int ret; + snd_ctl_t *alsaHandle = NULL; + snd_ctl_elem_id_t *elem_id; + snd_ctl_elem_info_t *elem_info; + snd_ctl_elem_value_t *elem_value; + snd_ctl_elem_type_t type; + + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(ctlElem); + + ret = snd_ctl_open(&alsaHandle, cardIns->ctrlName, 0); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_ctl_open error: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + + snd_ctl_elem_id_alloca(&elem_id); + snd_ctl_elem_info_alloca(&elem_info); + snd_ctl_elem_value_alloca(&elem_value); + ret = SetElementInfo(alsaHandle, ctlElem, elem_info, elem_id); + if(ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Set element %{public}s elem_info failed!\n",ctlElem->name); + return HDF_FAILURE; + } + + if(!snd_ctl_elem_info_is_writable(elem_info)) { + AUDIO_FUNC_LOGE("Element write enable\n"); + return HDF_FAILURE; + } + + snd_ctl_elem_value_set_id(elem_value, elem_id); + type = snd_ctl_elem_info_get_type(elem_info); + if(type == SND_CTL_ELEM_TYPE_ENUMERATED) { + snd_ctl_elem_value_set_enumerated(elem_value, 0, item); + } else { + AUDIO_FUNC_LOGE("Element value is not enum type!\n"); + return HDF_FAILURE; + } + + ret = snd_ctl_elem_write(alsaHandle, elem_value); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_ctl_elem_write failed!\n"); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t SndElementWriteSwitch + (struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, bool on) +{ + int ret; + int value; + snd_ctl_t *alsaHandle = NULL; + snd_ctl_elem_id_t *elem_id; + snd_ctl_elem_info_t *elem_info; + snd_ctl_elem_value_t *elem_value; + snd_ctl_elem_type_t type; + + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(ctlElem); + + ret = snd_ctl_open(&alsaHandle, cardIns->ctrlName, 0); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_ctl_open error: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + + snd_ctl_elem_id_alloca(&elem_id); + snd_ctl_elem_info_alloca(&elem_info); + snd_ctl_elem_value_alloca(&elem_value); + ret = SetElementInfo(alsaHandle, ctlElem, elem_info, elem_id); + if(ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Set element %{public}s elem_info failed!\n", ctlElem->name); + return HDF_FAILURE; + } + + if(!snd_ctl_elem_info_is_writable(elem_info)) { + AUDIO_FUNC_LOGE("Element write enable\n"); + return HDF_FAILURE; + } + + snd_ctl_elem_value_set_id(elem_value, elem_id); + type = snd_ctl_elem_info_get_type(elem_info); + if(type == SND_CTL_ELEM_TYPE_BOOLEAN) { + value = on ? 1 : 0; + snd_ctl_elem_value_set_boolean(elem_value, 0, value); + } else { + AUDIO_FUNC_LOGE("Element value is not boolean type!\n"); + return HDF_FAILURE; + } + + ret = snd_ctl_elem_write(alsaHandle, elem_value); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_ctl_elem_write failed!\n"); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t SndElementWrite + (struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem) +{ + int ret; + snd_ctl_t *alsaHandle = NULL; + snd_ctl_elem_id_t *elem_id; + snd_ctl_elem_info_t *elem_info; + snd_ctl_elem_value_t *elem_value; + + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(ctlElem); + + ret = snd_ctl_open(&alsaHandle, cardIns->ctrlName, 0); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_ctl_open error: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + + snd_ctl_elem_id_alloca(&elem_id); + snd_ctl_elem_info_alloca(&elem_info); + snd_ctl_elem_value_alloca(&elem_value); + ret = SetElementInfo(alsaHandle, ctlElem, elem_info, elem_id); + if(ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Set element %{public}s elem_info failed!\n",ctlElem->name); + return HDF_FAILURE; + } + + if(!snd_ctl_elem_info_is_writable(elem_info)) { + AUDIO_FUNC_LOGE("Element write enable\n"); + return HDF_FAILURE; + } + + snd_ctl_elem_value_set_id(elem_value, elem_id); + ret = snd_ctl_ascii_value_parse(alsaHandle, elem_value, elem_info, ctlElem->value); + if (ret < 0) { + AUDIO_FUNC_LOGE("Control parse error: %s\n", snd_strerror(ret)); + return HDF_FAILURE; + } + ret = snd_ctl_elem_write(alsaHandle, elem_value); + if (ret < 0) { + AUDIO_FUNC_LOGE("Control element write error: %s\n", snd_strerror(ret)); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t SndElementGroupWrite + (struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement* elemGroup, int32_t groupSize) +{ + int err; + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + + for(int i = 0; i < groupSize; ++i){ + err = SndElementWrite(cardIns, &elemGroup[i]); + if(err < 0){ + AUDIO_FUNC_LOGE("Cant't set element %{public}s", elemGroup[i].name); + } + } + + return HDF_SUCCESS; +} + +int32_t SndTraversalMixerElement(struct AlsaSoundCard *cardIns, + bool (*callback)(void *data, snd_ctl_elem_id_t *elem_id), void *data) +{ + int ret; + snd_hctl_t *handle; + snd_hctl_elem_t *elem; + snd_ctl_elem_id_t *elem_id; + snd_ctl_elem_info_t *elem_info; + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(callback); + + ret = snd_hctl_open(&handle, cardIns->ctrlName, 0); + if (ret < 0) { + AUDIO_FUNC_LOGE("Control %{public}s open error: %{public}s", + cardIns->ctrlName, snd_strerror(ret)); + return HDF_FAILURE; + } + ret = snd_hctl_load(handle); + if (ret < 0) { + AUDIO_FUNC_LOGE("Control %{public}s local error: %{public}s\n", + cardIns->ctrlName, snd_strerror(ret)); + return HDF_FAILURE; + } + + snd_ctl_elem_id_alloca(&elem_id); + snd_ctl_elem_info_alloca(&elem_info); + for (elem = snd_hctl_first_elem(handle); elem; elem = snd_hctl_elem_next(elem)) { + ret = snd_hctl_elem_info(elem, elem_info); + if (ret < 0) { + AUDIO_FUNC_LOGE("Control %{public}s snd_hctl_elem_info error: %{public}s\n", + cardIns->ctrlName, snd_strerror(ret)); + return HDF_FAILURE; + } + if (snd_ctl_elem_info_is_inactive(elem_info)) { + continue; + } + snd_hctl_elem_get_id(elem, elem_id); + if (callback(data, elem_id)) { + (void)snd_hctl_close(handle); + return HDF_SUCCESS; + } + } + (void)snd_hctl_close(handle); + return HDF_FAILURE; +} -- Gitee From e831e15e902fad764bedea1e9e709c25e721f333 Mon Sep 17 00:00:00 2001 From: xiesicong Date: Fri, 22 Sep 2023 10:11:52 +0800 Subject: [PATCH 03/14] =?UTF-8?q?=E5=88=A0=E9=99=A4=E6=97=A0=E7=94=A8?= =?UTF-8?q?=E5=A4=B4=E6=96=87=E4=BB=B6=E5=92=8Cc=E6=96=87=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xiesicong --- .../alsa_adapter/include/alsa_lib_common.h | 143 -------------- .../alsa_adapter/src/alsa_mixer_path.c | 181 ------------------ 2 files changed, 324 deletions(-) delete mode 100644 audio/supportlibs/alsa_adapter/include/alsa_lib_common.h delete mode 100644 audio/supportlibs/alsa_adapter/src/alsa_mixer_path.c diff --git a/audio/supportlibs/alsa_adapter/include/alsa_lib_common.h b/audio/supportlibs/alsa_adapter/include/alsa_lib_common.h deleted file mode 100644 index fabf2fa95c..0000000000 --- a/audio/supportlibs/alsa_adapter/include/alsa_lib_common.h +++ /dev/null @@ -1,143 +0,0 @@ -/* - * Copyright (c) 2022-2023 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 ALSA_LIB_COMMON_H -#define ALSA_LIB_COMMON_H - -#include "asoundlib.h" -#include "audio_if_lib_common.h" -#include "audio_uhdf_log.h" -#include "hdf_io_service_if.h" -#include "hdf_sbuf.h" -#include "osal_mem.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#define SERVIC_NAME_MAX_LEN 32 - -#define MAX_VOLUME 100 -#define MIN_VOLUME 0 -#define AUDIO_MIN_CARD_NUM 1 -#define AUDIO_MAX_CARD_NUM 8 -#define CARD_ID_LEN_MAX 32 -#define MAX_CARD_NAME_LEN 64 -#define MAX_CARD_NUM (4 * (AUDIO_MAX_CARD_NUM)) - -#define AUDIO_ALSALIB_IOCTRL_RESUME 0 -#define AUDIO_ALSALIB_IOCTRL_PAUSE 1 -#define AUDIO_ALSALIB_MMAP_MAX 10 -#define AUDIO_ALSALIB_RETYR 3 - -#define ALSA_CTL_NAME_LEN 64 -#define MIXER_CTL_MAX_NUM 64 - -enum SndCardType { - SND_CARD_UNKNOWN = -1, - SND_CARD_PRIMARY = 0, - SND_CARD_HDMI, - SND_CARD_USB, - SND_CARD_BT, - SND_CARD_MAX -}; - -struct MixerCtlVolumeName { - char name[ALSA_CTL_NAME_LEN]; /* name part of simple element identifier */ -}; - -struct DevProcInfo { - char cardName[CARD_ID_LEN_MAX]; /* adapter name */ - char cid[CARD_ID_LEN_MAX]; /* cardX/id match */ - char did[CARD_ID_LEN_MAX]; /* dai id match */ - struct MixerCtlVolumeName *ctlRenderNameList; /* Simple mixer control list */ - struct MixerCtlVolumeName *ctlCaptureNameList; /* Simple mixer control list */ - uint32_t ctlRenderVolNameCount; - uint32_t ctlCaptureVolNameCount; -}; - -struct AlsaDevInfo { - char cardId[MAX_CARD_NAME_LEN + 1]; - char pcmInfoId[MAX_CARD_NAME_LEN + 1]; - int32_t card; - int32_t device; -}; - -struct AlsaCardsList { - struct AlsaDevInfo alsaDevIns[MAX_CARD_NUM]; -}; - -struct AlsaMixerPath { - const char *pathName; /* ASCII name of item */ - uint32_t numId; /* numeric identifier */ - uint32_t item; /* item number */ -}; - -struct AlsaMixerElem { - snd_mixer_elem_t *elem; /* Simple mixer control */ -}; - -struct AudioCardInfo { - uint8_t cardStatus; - snd_pcm_t *capturePcmHandle; - snd_pcm_t *renderPcmHandle; - snd_mixer_t *mixer; - struct AlsaMixerElem *volElemList; /* Simple mixer control list for primary */ - uint32_t volElemCount; /* Simple mixer control list count for primary */ - snd_mixer_elem_t *usbCtlVolume; - bool renderMmapFlag; - bool captureMmapFlag; - int32_t renderMuteValue; - int32_t captureMuteValue; - float tempVolume; - uint64_t renderMmapFrames; - uint64_t capMmapFrames; - uint64_t mmapFrames; - char cardName[MAX_CARD_NAME_LEN + 1]; - char devName[MAX_CARD_NAME_LEN + 1]; - char alsaCardId[MAX_CARD_NAME_LEN + 1]; - char ctrlName[MAX_CARD_NAME_LEN + 1]; - char alsaPcmInfoId[MAX_CARD_NAME_LEN + 1]; - struct AudioPcmHwParams hwRenderParams; - struct AudioPcmHwParams hwCaptureParams; - struct AlsaMixerPath renderMixerPath; - struct AlsaMixerPath captureMixerPath; -}; - -struct DevHandle *AudioBindService(const char *name); -void AudioCloseService(const struct DevHandle *handle); -void InitSound(snd_mixer_t **mixer, char *hwCtlName); -int32_t CloseMixerHandle(snd_mixer_t *alsaMixHandle); -int32_t InitCardIns(void); -struct AudioCardInfo *GetCardIns(const char *cardName); -struct AudioCardInfo *AudioGetCardInstance(const char *adapterName); -int32_t AudioGetCardInfo(struct AudioCardInfo *cardIns, const char *adapterName, snd_pcm_stream_t stream); -int32_t InitMixerCtlElement( - const char *adapterName, struct AudioCardInfo *cardIns, snd_mixer_t *mixer, snd_pcm_stream_t stream); -void CheckCardStatus(struct AudioCardInfo *cardIns); -int32_t CheckParaFormat(struct AudioPcmHwParams hwParams, snd_pcm_format_t *alsaPcmFormat); -int32_t DestroyCardList(void); -int32_t GetSelCardInfo(struct AudioCardInfo *cardIns, struct AlsaDevInfo *devInsHandle); -int32_t MatchSelAdapter(const char *adapterName, struct AudioCardInfo *cardIns); -int32_t GetPriMixerCtlElement(struct AudioCardInfo *cardIns, snd_mixer_t *mixer, snd_pcm_stream_t stream); -int32_t AudioSetCtrlVolumeRange(struct AudioCardInfo *cardIns, const char *adapterName, snd_pcm_stream_t stream); -int32_t CardInfoParseFromConfig(void); -int32_t AudioMixerSetCtrlMode(struct AudioCardInfo *cardIns, const char *adapterName, snd_pcm_stream_t stream); -int32_t EnableAudioRenderRoute(const struct AudioHwRenderParam *renderData); -int32_t EnableAudioCaptureRoute(const struct AudioHwCaptureParam *captureData); -#ifdef __cplusplus -} -#endif -#endif /* ALSA_LIB_COMMON_H */ diff --git a/audio/supportlibs/alsa_adapter/src/alsa_mixer_path.c b/audio/supportlibs/alsa_adapter/src/alsa_mixer_path.c deleted file mode 100644 index f3ce046042..0000000000 --- a/audio/supportlibs/alsa_adapter/src/alsa_mixer_path.c +++ /dev/null @@ -1,181 +0,0 @@ -/* - * Copyright (c) 2023 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 "alsa_lib_common.h" - -#define HDF_LOG_TAG HDF_AUDIO_HAL_LIB - -static int32_t AlsaControls(char *cardCtlName, const char *pathName, uint32_t *numId) -{ - int ret; - snd_hctl_t *handle = NULL; - snd_hctl_elem_t *elem = NULL; - snd_ctl_elem_id_t *id = NULL; - snd_ctl_elem_info_t *info = NULL; - - if (cardCtlName == NULL || pathName == NULL || numId == NULL) { - AUDIO_FUNC_LOGE("The parameter is NULL!"); - return HDF_FAILURE; - } - - snd_ctl_elem_id_alloca(&id); - snd_ctl_elem_info_alloca(&info); - if (id == NULL || info == NULL) { - AUDIO_FUNC_LOGE("alloca failed!"); - return HDF_FAILURE; - } - if ((ret = snd_hctl_open(&handle, cardCtlName, 0)) < 0) { - AUDIO_FUNC_LOGE("Control %{public}s open error: %{public}s", cardCtlName, snd_strerror(ret)); - return ret; - } - if ((ret = snd_hctl_load(handle)) < 0) { - AUDIO_FUNC_LOGE("Control %{public}s local error: %{public}s\n", cardCtlName, snd_strerror(ret)); - return ret; - } - /* Obtain the path information of the sound card in the control node */ - for (elem = snd_hctl_first_elem(handle); elem != NULL; elem = snd_hctl_elem_next(elem)) { - if ((ret = snd_hctl_elem_info(elem, info)) < 0) { - AUDIO_FUNC_LOGE("Control %{public}s snd_hctl_elem_info error: %{public}s.", cardCtlName, snd_strerror(ret)); - return ret; - } - if (snd_ctl_elem_info_is_inactive(info)) { - continue; - } - snd_hctl_elem_get_id(elem, id); - const char *name = snd_ctl_elem_id_get_name(id); - if (strncmp(name, pathName, strlen(pathName)) == 0) { - *numId = snd_ctl_elem_id_get_numid(id); - (void)snd_hctl_close(handle); - return ret; - } - } - AUDIO_FUNC_LOGE("The set ctlName was not found!"); - (void)snd_hctl_close(handle); - return HDF_FAILURE; -} - -static int32_t AudioCtlElemWrite(const char *ctlName, uint32_t numId, uint32_t item) -{ - int32_t ret; - snd_ctl_t *ctlHandle = NULL; - snd_ctl_elem_value_t *ctlElemValue = NULL; - - if (ctlName == NULL) { - AUDIO_FUNC_LOGE("The parameter is NULL!"); - return HDF_FAILURE; - } - ret = snd_ctl_elem_value_malloc(&ctlElemValue); - if (ret < 0) { - AUDIO_FUNC_LOGE("snd_ctl_elem_value_malloc error: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - - ret = snd_ctl_open(&ctlHandle, ctlName, 0); - if (ret < 0) { - AUDIO_FUNC_LOGE("snd_ctl_open error: %{public}s", snd_strerror(ret)); - snd_ctl_elem_value_free(ctlElemValue); - return HDF_FAILURE; - } - snd_ctl_elem_value_set_numid(ctlElemValue, numId); - snd_ctl_elem_value_set_interface(ctlElemValue, SND_CTL_ELEM_IFACE_MIXER); - snd_ctl_elem_value_set_integer(ctlElemValue, 0, item); // 0 is index of the member - ret = snd_ctl_elem_write(ctlHandle, ctlElemValue); - if (ret < 0) { - AUDIO_FUNC_LOGE("snd_ctl_elem_write error: %{public}s", snd_strerror(ret)); - } - - snd_ctl_elem_value_free(ctlElemValue); - (void)snd_ctl_close(ctlHandle); - return ret; -} - -int32_t EnableAudioRenderRoute(const struct AudioHwRenderParam *renderData) -{ - struct AudioCardInfo *cardIns = NULL; - uint32_t numId; - const char *pathName = NULL; - int32_t itemValue; - if (renderData == NULL) { - AUDIO_FUNC_LOGE("The parameter is NULL!"); - return HDF_FAILURE; - } - - const char *adapterName = renderData->renderMode.hwInfo.adapterName; - cardIns = AudioGetCardInstance(adapterName); - if (cardIns == NULL) { - AUDIO_FUNC_LOGE("AudioRenderGetCardIns failed."); - return HDF_FAILURE; - } - - int32_t devCount = renderData->renderMode.hwInfo.pathSelect.deviceInfo.deviceNum; - if (devCount < 0 || devCount > PATHPLAN_COUNT - 1) { - AUDIO_FUNC_LOGE("devCount is error!"); - return HDF_FAILURE; - } - for (int32_t i = 0; i < devCount; i++) { - pathName = renderData->renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[i].deviceSwitch; - itemValue = renderData->renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[i].value; - if (AlsaControls(cardIns->ctrlName, pathName, &numId) < 0) { - AUDIO_FUNC_LOGE("AlsaControls failed, pathName: %{public}s.", pathName); - return HDF_FAILURE; - } - if (AudioCtlElemWrite(cardIns->ctrlName, numId, itemValue) != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("AudioCtlElemWrite failed."); - return HDF_FAILURE; - } - } - - return HDF_SUCCESS; -} - -int32_t EnableAudioCaptureRoute(const struct AudioHwCaptureParam *captureData) -{ - uint32_t numId; - int32_t itemValue; - struct AudioCardInfo *cardIns = NULL; - const char *capturePathName = NULL; - - if (captureData == NULL) { - AUDIO_FUNC_LOGE("The parameter is NULL!"); - return HDF_FAILURE; - } - - const char *adapterName = captureData->captureMode.hwInfo.adapterName; - cardIns = AudioGetCardInstance(adapterName); - if (cardIns == NULL) { - AUDIO_FUNC_LOGE("AudioCaptureGetCardIns failed."); - return HDF_FAILURE; - } - - int32_t devCount = captureData->captureMode.hwInfo.pathSelect.deviceInfo.deviceNum; - if (devCount < 0 || devCount > PATHPLAN_COUNT - 1) { - AUDIO_FUNC_LOGE("deviceIndex is error!"); - return HDF_FAILURE; - } - for (int32_t i = 0; i < devCount; i++) { - capturePathName = captureData->captureMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[i].deviceSwitch; - itemValue = captureData->captureMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[i].value; - if (AlsaControls(cardIns->ctrlName, capturePathName, &numId) < 0) { - AUDIO_FUNC_LOGE("AlsaControls failed, pathName: %{public}s!", capturePathName); - return HDF_FAILURE; - } - if (AudioCtlElemWrite(cardIns->ctrlName, numId, itemValue) != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("AudioCtlElemWrite failed!"); - return HDF_FAILURE; - } - } - - return HDF_SUCCESS; -} -- Gitee From 21eaa0d930531d13498c377e4d3b3ca87ee2d53c Mon Sep 17 00:00:00 2001 From: xiesicong Date: Fri, 22 Sep 2023 10:12:26 +0800 Subject: [PATCH 04/14] =?UTF-8?q?=E5=88=A0=E9=99=A4=E5=B7=B2=E5=BA=9F?= =?UTF-8?q?=E5=BC=83=E7=9A=84c=E6=96=87=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xiesicong --- .../alsa_adapter/src/alsa_lib_common.c | 1799 ----------------- 1 file changed, 1799 deletions(-) delete mode 100644 audio/supportlibs/alsa_adapter/src/alsa_lib_common.c diff --git a/audio/supportlibs/alsa_adapter/src/alsa_lib_common.c b/audio/supportlibs/alsa_adapter/src/alsa_lib_common.c deleted file mode 100644 index 3b95657cfa..0000000000 --- a/audio/supportlibs/alsa_adapter/src/alsa_lib_common.c +++ /dev/null @@ -1,1799 +0,0 @@ -/* - * Copyright (c) 2022-2023 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 "alsa_lib_common.h" -#include -#include -#include "audio_common.h" -#include "audio_internal.h" -#include "cJSON.h" -#include "osal_mem.h" -#include "securec.h" - -#define HDF_LOG_TAG HDF_AUDIO_HAL_LIB - -#define USB_AUDIO "USB Audio" -#define MIXER_CTL_VOLUME "simple_mixer_ctl_volume" -#define PLAYBACK "playback" -#define CAPTURE "capture" -#define MAX_ELEMENT 100 -#define ALSA_CARD_CONFIG_FILE HDF_CONFIG_DIR "/alsa_adapter.json" -#define ALSA_CONFIG_FILE_MAX (2 * 1024) // 2KB - -#define SUPPORT_CAPTURE_OR_RENDER 1 -#define SUPPORT_CAPTURE_AND_RENDER 2 - -struct CardStream { - int card; - snd_pcm_stream_t stream; /** Playback stream or Capture stream */ -}; - -static struct AudioCardInfo *g_audioCardIns = NULL; -struct AlsaDevInfo *g_alsadevInfo = NULL; -static bool g_parseFlag = false; - -/* Record the list of sound cards read from the alsa device */ -static struct AlsaCardsList g_alsaCardsList; -/* Record the number of sound cards configured in the sound card configuration file, - * which is different from the sound cards read from the alsa device. - */ -static uint8_t g_sndCardsNum = 0; - -char *g_usbSimpleRenderCtlVol[] = { - "Earpiece", - "Speaker", - "Headphone", - "PCM", - "Mic", -}; - -char *g_usbSimpleCapCtlVol[] = { - "Earpiece", - "Headset", - "Headphone", - "Mic", -}; - -static struct DevProcInfo *g_sndCardList[SND_CARD_MAX][AUDIO_MAX_CARD_NUM] = {{NULL}}; - -static struct DevProcInfo **AudioGetSoundCardsInfo(enum SndCardType cardType) -{ - return (struct DevProcInfo **)(g_sndCardList + cardType); -} - -int32_t InitCardIns(void) -{ - if (g_audioCardIns == NULL) { - g_audioCardIns = (struct AudioCardInfo *)OsalMemCalloc(MAX_CARD_NUM * sizeof(struct AudioCardInfo)); - if (g_audioCardIns == NULL) { - AUDIO_FUNC_LOGE("Failed to allocate memory!"); - return HDF_FAILURE; - } - } - - return HDF_SUCCESS; -} - -static struct AudioCardInfo *AddCardIns(const char *cardName) -{ - int32_t i; - int32_t ret; - - if (cardName == NULL || strlen(cardName) == 0) { - AUDIO_FUNC_LOGE("Invalid cardName!"); - return NULL; - } - - if (g_audioCardIns == NULL) { - AUDIO_FUNC_LOGE("g_audioCardIns is NULL!"); - return NULL; - } - - for (i = 0; i < MAX_CARD_NUM; i++) { - if (g_audioCardIns[i].cardStatus == 0) { - (void)memset_s(&g_audioCardIns[i], sizeof(struct AudioCardInfo), 0, sizeof(struct AudioCardInfo)); - ret = strncpy_s(g_audioCardIns[i].cardName, MAX_CARD_NAME_LEN + 1, cardName, strlen(cardName)); - if (ret != 0) { - AUDIO_FUNC_LOGE("strncpy_s failed!"); - return NULL; - } - g_audioCardIns[i].cardStatus++; - return &(g_audioCardIns[i]); - } - } - AUDIO_FUNC_LOGE("Failed to AddCardIns!"); - - return NULL; -} - -static struct AudioCardInfo *FindCardIns(const char *cardName) -{ - int32_t i; - - if (cardName == NULL || strlen(cardName) == 0) { - AUDIO_FUNC_LOGE("Invalid cardName!"); - return NULL; - } - - if (g_audioCardIns == NULL) { - AUDIO_FUNC_LOGE("g_audioCardIns is NULL!"); - return NULL; - } - - for (i = 0; i < MAX_CARD_NUM; i++) { - if (strcmp(g_audioCardIns[i].cardName, cardName) == 0) { - return &(g_audioCardIns[i]); - } - } - - return NULL; -} - -static int32_t AudioAddCardIns(const char *cardName) -{ - struct AudioCardInfo *cardInfo = NULL; - - if (cardName == NULL) { - AUDIO_FUNC_LOGE("Invalid cardName!"); - return HDF_FAILURE; - } - - cardInfo = FindCardIns(cardName); - if (cardInfo == NULL) { - cardInfo = AddCardIns(cardName); - if (cardInfo == NULL) { - AUDIO_FUNC_LOGE("AddCardIns failed!"); - return HDF_FAILURE; - } - } - - return HDF_SUCCESS; -} - -struct AudioCardInfo *GetCardIns(const char *cardName) -{ - if (cardName == NULL) { - AUDIO_FUNC_LOGE("Invalid cardName!"); - return NULL; - } - - return FindCardIns(cardName); -} - -void CheckCardStatus(struct AudioCardInfo *cardIns) -{ - int32_t ret; - if (cardIns == NULL) { - AUDIO_FUNC_LOGE("The parameter is empty!"); - return; - } - if (cardIns->cardStatus > 0) { - cardIns->cardStatus -= 1; - } - if (cardIns->cardStatus == 0) { - if (cardIns->renderPcmHandle != NULL) { - ret = snd_pcm_close(cardIns->renderPcmHandle); - if (ret < 0) { - AUDIO_FUNC_LOGE("snd_pcm_close fail: %{public}s", snd_strerror(ret)); - } - cardIns->renderPcmHandle = NULL; - } - if (cardIns->capturePcmHandle != NULL) { - ret = snd_pcm_close(cardIns->capturePcmHandle); - if (ret < 0) { - AUDIO_FUNC_LOGE("snd_pcm_close fail: %{public}s", snd_strerror(ret)); - } - cardIns->capturePcmHandle = NULL; - } - (void)memset_s(cardIns->cardName, MAX_CARD_NAME_LEN + 1, 0, MAX_CARD_NAME_LEN + 1); - } -} - -static void CardInfoRelease(void) -{ - for (int i = 0; i < SND_CARD_MAX; i++) { - for (int j = 0; j < AUDIO_MAX_CARD_NUM; j++) { - if (g_sndCardList[i][j] == NULL) { - continue; - } - if (g_sndCardList[i][j]->ctlRenderNameList != NULL) { - AudioMemFree((void **)&(g_sndCardList[i][j]->ctlRenderNameList)); - } - if (g_sndCardList[i][j]->ctlCaptureNameList != NULL) { - AudioMemFree((void **)&(g_sndCardList[i][j]->ctlCaptureNameList)); - } - AudioMemFree((void **)&(g_sndCardList[i][j])); - } - } - g_parseFlag = false; -} - -int32_t DestroyCardList(void) -{ - int32_t i; - - if (g_audioCardIns != NULL) { - for (i = 0; i < MAX_CARD_NUM; i++) { - if (g_audioCardIns[i].cardStatus != 0) { - AUDIO_FUNC_LOGE("refCount is not zero, Sound card in use!"); - return HDF_ERR_DEVICE_BUSY; - } - } - AudioMemFree((void **)&g_audioCardIns); - g_audioCardIns = NULL; - - /* Release the sound card configuration space */ - CardInfoRelease(); - } - - return HDF_SUCCESS; -} - -static int32_t GetDevIns(struct AlsaCardsList *cardIns, int card, const char *cardId, int dev, const char *pcmInfoId) -{ - int32_t i; - int32_t ret; - - if (cardIns == NULL || cardId == NULL || pcmInfoId == NULL || strlen(cardId) == 0) { - AUDIO_FUNC_LOGE("The parameter is empty!"); - return HDF_FAILURE; - } - - for (i = 0; i < MAX_CARD_NUM; i++) { - if (strlen(cardIns->alsaDevIns[i].cardId) == 0) { - cardIns->alsaDevIns[i].card = card; - cardIns->alsaDevIns[i].device = dev; - ret = strncpy_s(cardIns->alsaDevIns[i].cardId, MAX_CARD_NAME_LEN + 1, cardId, strlen(cardId)); - if (ret != 0) { - AUDIO_FUNC_LOGE("strncpy_s failed!"); - return HDF_FAILURE; - } - ret = strncpy_s(cardIns->alsaDevIns[i].pcmInfoId, MAX_CARD_NAME_LEN + 1, pcmInfoId, strlen(pcmInfoId)); - if (ret != 0) { - AUDIO_FUNC_LOGE("strncpy_s failed!"); - return HDF_FAILURE; - } - return HDF_SUCCESS; - } - } - AUDIO_FUNC_LOGE("A maximum of %{public}d sound cards are supported!", MAX_CARD_NUM); - - return HDF_FAILURE; -} - -int32_t CloseMixerHandle(snd_mixer_t *alsaMixHandle) -{ - int32_t ret; - - if (alsaMixHandle == NULL) { - return HDF_SUCCESS; - } - - ret = snd_mixer_close(alsaMixHandle); - if (ret < 0) { - AUDIO_FUNC_LOGE("mixer close error: %{public}s.", snd_strerror(ret)); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -void InitSound(snd_mixer_t **mixer, char *hwCtlName) -{ - int32_t ret; - - if (mixer == NULL || hwCtlName == NULL) { - AUDIO_FUNC_LOGE("The parameter is null."); - return; - } - - ret = snd_mixer_open(mixer, 0); - if (ret < 0) { - AUDIO_FUNC_LOGE("Failed to open mixer: %{public}s.", snd_strerror(ret)); - return; - } - - ret = snd_mixer_attach(*mixer, hwCtlName); - if (ret < 0) { - AUDIO_FUNC_LOGE("Failed to attach mixer: %{public}s.", snd_strerror(ret)); - ret = snd_mixer_close(*mixer); - if (ret < 0) { - AUDIO_FUNC_LOGE("mixer close error: %{public}s.", snd_strerror(ret)); - } - return; - } - - ret = snd_mixer_selem_register(*mixer, NULL, NULL); - if (ret < 0) { - AUDIO_FUNC_LOGE("Failed to register mixer element: %{public}s.", snd_strerror(ret)); - ret = snd_mixer_close(*mixer); - if (ret < 0) { - AUDIO_FUNC_LOGE("mixer close error: %{public}s.", snd_strerror(ret)); - } - return; - } - - ret = snd_mixer_load(*mixer); - if (ret < 0) { - AUDIO_FUNC_LOGE("Failed to load mixer element: %{public}s.", snd_strerror(ret)); - ret = snd_mixer_close(*mixer); - if (ret < 0) { - AUDIO_FUNC_LOGE("mixer close error: %{public}s.", snd_strerror(ret)); - } - return; - } -} - -struct HdfIoService *HdfIoServiceBindName(const char *serviceName) -{ - (void)serviceName; - /* Nothing to do */ - static struct HdfIoService hdfIoService; - return &hdfIoService; -} - -static void GetDevCardsInfo(snd_ctl_t *handle, snd_ctl_card_info_t *info, snd_pcm_info_t *pcmInfo, - struct AlsaCardsList *cardIns, struct CardStream cardStream) -{ - int dev = -1; - int32_t ret; - - if (handle == NULL || info == NULL || pcmInfo == NULL || cardIns == NULL) { - AUDIO_FUNC_LOGE("The parameter is empty."); - return; - } - - while (1) { - ret = snd_ctl_pcm_next_device(handle, &dev); - if (ret < 0) { - AUDIO_FUNC_LOGE("snd_ctl_pcm_next_device error: %{public}s.", snd_strerror(ret)); - } - if (dev < 0) { - break; - } - - snd_pcm_info_set_device(pcmInfo, dev); - snd_pcm_info_set_subdevice(pcmInfo, 0); - snd_pcm_info_set_stream(pcmInfo, cardStream.stream); - if ((ret = snd_ctl_pcm_info(handle, pcmInfo)) < 0) { - if (ret != -ENOENT) { - AUDIO_FUNC_LOGE( - "control digital audio info (%{public}d): %{public}s", cardStream.card, snd_strerror(ret)); - } - continue; - } - - const char *cardId = snd_ctl_card_info_get_id(info); - const char *pcmInfoId = snd_pcm_info_get_id(pcmInfo); - ret = GetDevIns(cardIns, cardStream.card, cardId, dev, pcmInfoId); - if (ret < 0) { - AUDIO_FUNC_LOGE("GetDevIns error."); - return; - } - } -} - -static void GetDeviceList(struct AlsaCardsList *cardIns, snd_pcm_stream_t stream) -{ - int32_t ret; - snd_ctl_t *handle; - int card = -1; - snd_ctl_card_info_t *info = NULL; - snd_pcm_info_t *pcminfo = NULL; - char deviceName[MAX_CARD_NAME_LEN] = {0}; - struct CardStream cardStream; - - if (cardIns == NULL) { - AUDIO_FUNC_LOGE("The parameter is empty."); - return; - } - snd_ctl_card_info_alloca(&info); - snd_pcm_info_alloca(&pcminfo); - - ret = snd_card_next(&card); - if (ret < 0 || card < 0) { - AUDIO_FUNC_LOGE("No soundcards found: %{public}s.", snd_strerror(ret)); - return; - } - while (card >= 0) { - (void)memset_s(deviceName, MAX_CARD_NAME_LEN, 0, MAX_CARD_NAME_LEN); - ret = snprintf_s(deviceName, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "hw:%d", card); - if (ret < 0) { - AUDIO_FUNC_LOGE("snprintf_s failed"); - return; - } - - ret = snd_ctl_open(&handle, deviceName, 0); - if (ret == HDF_SUCCESS) { - ret = snd_ctl_card_info(handle, info); - if (ret == HDF_SUCCESS) { - cardStream.card = card; - cardStream.stream = stream; - GetDevCardsInfo(handle, info, pcminfo, cardIns, cardStream); - } - ret = snd_ctl_close(handle); - if (ret < 0) { - AUDIO_FUNC_LOGE("mixer close error: %{public}s.", snd_strerror(ret)); - return; - } - } - - ret = snd_card_next(&card); - if (ret < 0) { - AUDIO_FUNC_LOGE("snd_card_next error: %{public}s", snd_strerror(ret)); - return; - } - } -} - -int32_t GetSelCardInfo(struct AudioCardInfo *cardIns, struct AlsaDevInfo *devInsHandle) -{ - int32_t ret; - - if (cardIns == NULL || devInsHandle == NULL) { - AUDIO_FUNC_LOGE("The parameter is empty."); - return HDF_FAILURE; - } - - ret = snprintf_s(cardIns->devName, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "plughw:%d,%d", devInsHandle->card, - devInsHandle->device); - if (ret >= 0) { - ret = snprintf_s(cardIns->ctrlName, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "hw:%d", devInsHandle->card); - if (ret >= 0) { - ret = snprintf_s(cardIns->alsaCardId, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "%s", devInsHandle->cardId); - if (ret >= 0) { - return HDF_SUCCESS; - } - } - } - AUDIO_FUNC_LOGE("snprintf_s failed"); - - return HDF_FAILURE; -} - -static struct DevProcInfo *MatchPimarySoundCard(struct DevProcInfo *cardInfo[], const char *adapterName) -{ - if (cardInfo == NULL || adapterName == NULL) { - AUDIO_FUNC_LOGE("The parameter is empty."); - return NULL; - } - - if (strncmp(adapterName, PRIMARY, strlen(PRIMARY)) != 0) { - AUDIO_FUNC_LOGE("The user sound card name %{public}s is incorrect!", adapterName); - return NULL; - } - - for (int i = 0; i < AUDIO_MAX_CARD_NUM; i++) { - if (cardInfo[i] != NULL) { - if (strncmp(cardInfo[i]->cardName, adapterName, strlen(adapterName)) == 0) { - return cardInfo[i]; - } - } - } - AUDIO_FUNC_LOGE("No sound card selected by the user is matched from the configuration file."); - - return NULL; -} - -static struct DevProcInfo *MatchHdmiSoundCard(struct DevProcInfo *cardInfo[], const char *adapterName) -{ - if (cardInfo == NULL || adapterName == NULL) { - AUDIO_FUNC_LOGE("The parameter is empty."); - return NULL; - } - - if (strncmp(adapterName, HDMI, strlen(HDMI)) != 0) { - AUDIO_FUNC_LOGE("The user sound card name %{public}s is incorrect!", adapterName); - return NULL; - } - - for (int i = 0; i < AUDIO_MAX_CARD_NUM; i++) { - if (cardInfo[i] != NULL) { - if (strncmp(cardInfo[i]->cardName, HDMI, strlen(HDMI)) == 0) { - return cardInfo[i]; - } - } - } - AUDIO_FUNC_LOGE("No sound card selected by the user is matched from the configuration file."); - - return NULL; -} - -static int32_t GetPrimaryCardInfo(struct AudioCardInfo *cardIns, struct AlsaCardsList *alsaCardsList) -{ - int32_t i; - int32_t ret; - struct DevProcInfo *primaryInfo = NULL; - struct DevProcInfo **cardInfo = NULL; - - if (cardIns == NULL || alsaCardsList == NULL) { - AUDIO_FUNC_LOGE("The parameter is empty."); - return HDF_FAILURE; - } - - cardInfo = AudioGetSoundCardsInfo(SND_CARD_PRIMARY); - if (cardInfo == NULL) { - AUDIO_FUNC_LOGE("The parameter is empty."); - return HDF_FAILURE; - } - - primaryInfo = MatchPimarySoundCard(cardInfo, cardIns->cardName); - if (primaryInfo == NULL) { - AUDIO_FUNC_LOGE("get cardId is null."); - return HDF_FAILURE; - } - - for (i = 0; i < MAX_CARD_NUM; i++) { - /** Built in codec */ - if (strcmp(primaryInfo->cid, alsaCardsList->alsaDevIns[i].cardId) == 0) { - ret = GetSelCardInfo(cardIns, &alsaCardsList->alsaDevIns[i]); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("GetSelCardInfo error."); - } - return ret; - } - } - - return HDF_FAILURE; -} - -static int32_t GetUsbCardInfo(struct AudioCardInfo *cardIns, struct AlsaCardsList *alsaCardsList) -{ - int32_t i; - int32_t ret; - - if (cardIns == NULL || alsaCardsList == NULL) { - AUDIO_FUNC_LOGE("The parameter is empty."); - return HDF_FAILURE; - } - - for (i = 0; i < MAX_CARD_NUM; i++) { - /** External codec */ - if (strcmp(USB_AUDIO, alsaCardsList->alsaDevIns[i].pcmInfoId) == 0) { - ret = GetSelCardInfo(cardIns, &alsaCardsList->alsaDevIns[i]); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("GetSelCardInfo error."); - } - return ret; - } - } - - return HDF_FAILURE; -} - -static int32_t GetHdmiCardInfo(struct AudioCardInfo *cardIns, struct AlsaCardsList *alsaCardsList) -{ - int32_t i; - int32_t ret; - struct DevProcInfo *hdmiInfo = NULL; - struct DevProcInfo **hdmiCardInfo = NULL; - - if (cardIns == NULL || alsaCardsList == NULL) { - AUDIO_FUNC_LOGE("The parameter is empty."); - return HDF_FAILURE; - } - - hdmiCardInfo = AudioGetSoundCardsInfo(SND_CARD_HDMI); - if (hdmiCardInfo == NULL) { - AUDIO_FUNC_LOGE("The parameter is empty."); - return HDF_FAILURE; - } - - hdmiInfo = MatchHdmiSoundCard(hdmiCardInfo, cardIns->cardName); - if (hdmiInfo == NULL) { - AUDIO_FUNC_LOGE("get cardId is null."); - return HDF_FAILURE; - } - for (i = 0; i < MAX_CARD_NUM; i++) { - /** hdmi codec */ - if (strcmp(hdmiInfo->cid, alsaCardsList->alsaDevIns[i].cardId) == 0) { - ret = GetSelCardInfo(cardIns, &alsaCardsList->alsaDevIns[i]); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("GetSelCardInfo error."); - } - return ret; - } - } - - AUDIO_FUNC_LOGE("get hdmi cardId fail."); - return HDF_FAILURE; -} - -int32_t MatchSelAdapter(const char *adapterName, struct AudioCardInfo *cardIns) -{ - if (adapterName == NULL || cardIns == NULL) { - AUDIO_FUNC_LOGE("The parameter is empty."); - return HDF_FAILURE; - } - - if (strncmp(adapterName, PRIMARY, strlen(PRIMARY)) == 0) { - return GetPrimaryCardInfo(cardIns, &g_alsaCardsList); - } else if (strncmp(adapterName, USB, strlen(USB)) == 0) { - return GetUsbCardInfo(cardIns, &g_alsaCardsList); - } else if (strncmp(adapterName, HDMI, strlen(HDMI)) == 0) { - return GetHdmiCardInfo(cardIns, &g_alsaCardsList); - } else if (strncmp(adapterName, A2DP, strlen(A2DP)) == 0) { - AUDIO_FUNC_LOGE("Currently not supported A2DP, please check!"); - return HDF_ERR_NOT_SUPPORT; - } else { - AUDIO_FUNC_LOGE("The selected sound card not find, please check!"); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -static snd_mixer_elem_t *AudioUsbFindElement(snd_mixer_t *mixer, snd_pcm_stream_t stream) -{ - int i; - int count; - int32_t maxLoop = MAX_ELEMENT; - snd_mixer_elem_t *element = NULL; - char *mixerCtlName = NULL; - char **usbCtlVol = NULL; - if (mixer == NULL) { - AUDIO_FUNC_LOGE("The parameter is NULL!"); - return NULL; - } - - if (stream == SND_PCM_STREAM_PLAYBACK) { - usbCtlVol = g_usbSimpleRenderCtlVol; - count = sizeof(g_usbSimpleRenderCtlVol) / sizeof(char *); - } else { - usbCtlVol = g_usbSimpleCapCtlVol; - count = sizeof(g_usbSimpleCapCtlVol) / sizeof(char *); - } - - for (element = snd_mixer_first_elem(mixer); element != NULL && maxLoop >= 0; - element = snd_mixer_elem_next(element)) { - for (i = 0; i < count; i++) { - mixerCtlName = usbCtlVol[i]; - /* Compare whether the element name is the option we want to set */ - if (strcmp(mixerCtlName, snd_mixer_selem_get_name(element)) == 0) { - return element; - } - } - maxLoop--; - } - return NULL; -} - -static snd_mixer_elem_t *AudioFindElement(const char *mixerCtlName, snd_mixer_t *mixer) -{ - int32_t maxLoop = MAX_ELEMENT; - - if (mixerCtlName == NULL || mixer == NULL) { - AUDIO_FUNC_LOGE("The parameter is NULL!"); - return NULL; - } - snd_mixer_elem_t *element = snd_mixer_first_elem(mixer); - if (element == NULL) { - AUDIO_FUNC_LOGE("snd_mixer_first_elem failed."); - return NULL; - } - while (element && maxLoop >= 0) { - /* Compare whether the element name is the option we want to set */ - if (strcmp(mixerCtlName, snd_mixer_selem_get_name(element)) == 0) { - break; - } - /* If not, keep looking for the next one */ - element = snd_mixer_elem_next(element); - maxLoop--; - } - - if (element == NULL || maxLoop < 0) { - AUDIO_FUNC_LOGE("snd_mixer_find_selem Err\n"); - return NULL; - } - - return element; -} - -int32_t GetPriMixerCtlElement(struct AudioCardInfo *cardIns, snd_mixer_t *mixer, snd_pcm_stream_t stream) -{ - int32_t i; - struct DevProcInfo *primaryInfo = NULL; - struct DevProcInfo **cardInfo = NULL; - - if (cardIns == NULL || mixer == NULL) { - AUDIO_FUNC_LOGE("The parameter is empty."); - return HDF_FAILURE; - } - - cardInfo = AudioGetSoundCardsInfo(SND_CARD_PRIMARY); - if (cardInfo == NULL) { - AUDIO_FUNC_LOGE("The parameter is empty."); - return HDF_FAILURE; - } - - primaryInfo = MatchPimarySoundCard(cardInfo, cardIns->cardName); - if (primaryInfo == NULL) { - AUDIO_FUNC_LOGE("get cardId is null."); - return HDF_FAILURE; - } - - if (stream == SND_PCM_STREAM_PLAYBACK) { - cardIns->volElemCount = primaryInfo->ctlRenderVolNameCount; - cardIns->volElemList = - (struct AlsaMixerElem *)OsalMemCalloc(cardIns->volElemCount * sizeof(struct AlsaMixerElem)); - if (cardIns->volElemList == NULL) { - AUDIO_FUNC_LOGE("PLAYBACK cardIns->volElemList Out of memory!"); - return HDF_ERR_MALLOC_FAIL; - } - for (i = 0; i < (int32_t)cardIns->volElemCount; i++) { - cardIns->volElemList[i].elem = AudioFindElement(primaryInfo->ctlRenderNameList[i].name, mixer); - } - } else { - cardIns->volElemCount = primaryInfo->ctlCaptureVolNameCount; - cardIns->volElemList = - (struct AlsaMixerElem *)OsalMemCalloc(cardIns->volElemCount * sizeof(struct AlsaMixerElem)); - if (cardIns->volElemList == NULL) { - AUDIO_FUNC_LOGE("CAPTURE cardIns->volElemList Out of memory!"); - return HDF_ERR_MALLOC_FAIL; - } - for (i = 0; i < (int32_t)cardIns->volElemCount; i++) { - cardIns->volElemList[i].elem = AudioFindElement(primaryInfo->ctlCaptureNameList[i].name, mixer); - } - } - - return HDF_SUCCESS; -} - -static int32_t AudioRenderSetVolumeRange(snd_mixer_elem_t *ctlElem) -{ - int32_t ret; - long volMin = -1; - long volMax = -1; - if (ctlElem == NULL) { - AUDIO_FUNC_LOGE("ctlElem is NULL."); - return HDF_FAILURE; - } - ret = snd_mixer_selem_has_playback_volume(ctlElem); - /* ret is 0 if no control is present, 1 if it's present */ - if (ret == 0) { - AUDIO_FUNC_LOGE("reason: %{public}s", snd_strerror(ret)); - return HDF_SUCCESS; - } - ret = snd_mixer_selem_get_playback_volume_range(ctlElem, &volMin, &volMax); - if (ret < 0) { - AUDIO_FUNC_LOGE("Failed to get playback volume range: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - - if (volMin == MIN_VOLUME && volMax == MAX_VOLUME) { - return HDF_SUCCESS; - } else { - ret = snd_mixer_selem_set_playback_volume_range(ctlElem, MIN_VOLUME, MAX_VOLUME); - if (ret < 0) { - AUDIO_FUNC_LOGE("Failed to set playback volume range: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - } - return HDF_SUCCESS; -} - -static int32_t AudioCaptureSetVolumeRange(snd_mixer_elem_t *ctlElem) -{ - int32_t ret; - long volMin = -1; - long volMax = -1; - if (ctlElem == NULL) { - AUDIO_FUNC_LOGE("ctlElem is NULL."); - return HDF_FAILURE; - } - ret = snd_mixer_selem_has_capture_volume(ctlElem); - /* ret is 0 if no control is present, 1 if it's present */ - if (ret == 0) { - AUDIO_FUNC_LOGE("reason: %{public}s", snd_strerror(ret)); - return HDF_SUCCESS; - } - ret = snd_mixer_selem_get_capture_volume_range(ctlElem, &volMin, &volMax); - if (ret < 0) { - AUDIO_FUNC_LOGE("Failed to get capture volume range: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - - if (volMin != MIN_VOLUME || volMax != MAX_VOLUME) { - ret = snd_mixer_selem_set_capture_volume_range(ctlElem, MIN_VOLUME, MAX_VOLUME); - if (ret < 0) { - AUDIO_FUNC_LOGE("Failed to set capture volume range: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - } - - return HDF_SUCCESS; -} - -static int32_t InitMixerCtrlVolumeRange(snd_mixer_elem_t *ctlElem, snd_pcm_stream_t stream) -{ - if (ctlElem == NULL) { - AUDIO_FUNC_LOGE("ctlElem is NULL."); - return HDF_FAILURE; - } - - switch (stream) { - case SND_PCM_STREAM_PLAYBACK: - return AudioRenderSetVolumeRange(ctlElem); - case SND_PCM_STREAM_CAPTURE: - return AudioCaptureSetVolumeRange(ctlElem); - default: - AUDIO_FUNC_LOGE("stream is error!"); - break; - } - - return HDF_FAILURE; -} - -int32_t AudioSetCtrlVolumeRange(struct AudioCardInfo *cardIns, const char *adapterName, snd_pcm_stream_t stream) -{ - if (cardIns == NULL || adapterName == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } - - if (strncmp(adapterName, PRIMARY, strlen(PRIMARY)) == 0) { - for (int32_t i = 0; i < (int32_t)cardIns->volElemCount; i++) { - if (InitMixerCtrlVolumeRange(cardIns->volElemList[i].elem, stream) != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("set valume failed!"); - return HDF_FAILURE; - } - } - return HDF_SUCCESS; - } - - if (strncmp(adapterName, USB, strlen(USB)) == 0) { - return InitMixerCtrlVolumeRange(cardIns->usbCtlVolume, stream); - } - - if (strncmp(adapterName, HDMI, strlen(HDMI)) == 0) { - AUDIO_FUNC_LOGW("HDMI not ctlElement."); - return HDF_SUCCESS; - } - - AUDIO_FUNC_LOGE("This type of sound card: %{public}s is not supported temporarily!", adapterName); - return HDF_FAILURE; -} - -int32_t InitMixerCtlElement( - const char *adapterName, struct AudioCardInfo *cardIns, snd_mixer_t *mixer, snd_pcm_stream_t stream) -{ - int32_t ret; - - if (adapterName == NULL || cardIns == NULL || mixer == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } - - if (strncmp(adapterName, PRIMARY, strlen(PRIMARY)) == 0) { - ret = GetPriMixerCtlElement(cardIns, mixer, stream); - if (ret < 0) { - AUDIO_FUNC_LOGE("Render GetPriMixerCtlElement failed."); - return HDF_FAILURE; - } - } else if (strncmp(adapterName, USB, strlen(USB)) == 0) { - cardIns->usbCtlVolume = AudioUsbFindElement(mixer, stream); - } else if (strncmp(adapterName, HDMI, strlen(HDMI)) == 0) { - AUDIO_FUNC_LOGI("HDMI not ctlElement."); - return HDF_SUCCESS; - } else { - AUDIO_FUNC_LOGE("The selected sound card not supported, please check!"); - return HDF_FAILURE; - } - - ret = AudioSetCtrlVolumeRange(cardIns, adapterName, stream); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGI("AudioSetCtrlVolumeRange failed."); - return ret; - } - - return HDF_SUCCESS; -} - -struct AudioCardInfo *AudioGetCardInstance(const char *adapterName) -{ - int32_t ret; - - if (adapterName == NULL) { - AUDIO_FUNC_LOGE("The parameter is empty."); - return NULL; - } - - ret = InitCardIns(); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("Failed to initialize sound card information."); - return NULL; - } - - ret = AudioAddCardIns(adapterName); - if (ret < 0) { - AUDIO_FUNC_LOGE("AudioAddCardIns failed."); - return NULL; - } - - return GetCardIns(adapterName); -} - -int32_t AudioGetCardInfo(struct AudioCardInfo *cardIns, const char *adapterName, snd_pcm_stream_t stream) -{ - if (cardIns == NULL || adapterName == NULL) { - AUDIO_FUNC_LOGE("The parameter is empty."); - return HDF_FAILURE; - } - - /* Parse sound card from configuration file */ - if (CardInfoParseFromConfig() != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("parse config file failed!"); - return HDF_FAILURE; - } - /* Read sound card list from alsa hardware */ - (void)memset_s(&g_alsaCardsList, sizeof(struct AlsaCardsList), 0, sizeof(struct AlsaCardsList)); - GetDeviceList(&g_alsaCardsList, stream); - - if (MatchSelAdapter(adapterName, cardIns) < 0) { - AUDIO_FUNC_LOGE("MatchSelAdapter is error."); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -int32_t CheckParaFormat(struct AudioPcmHwParams hwParams, snd_pcm_format_t *alsaPcmFormat) -{ - if (alsaPcmFormat == NULL) { - AUDIO_FUNC_LOGE("paras is NULL!"); - return HDF_FAILURE; - } - enum AudioFormat audioFormat = hwParams.format; - bool isBigEndian = hwParams.isBigEndian; - - /** Little Endian */ - if (!isBigEndian) { - switch (audioFormat) { - case AUDIO_FORMAT_TYPE_PCM_8_BIT: - *alsaPcmFormat = SND_PCM_FORMAT_S8; /** Signed 8 bit */ - break; - case AUDIO_FORMAT_TYPE_PCM_16_BIT: - *alsaPcmFormat = SND_PCM_FORMAT_S16_LE; /** Signed 16 bit Little Endian */ - break; - case AUDIO_FORMAT_TYPE_PCM_24_BIT: - *alsaPcmFormat = SND_PCM_FORMAT_S24_LE; /** Signed 24 bit Little Endian */ - break; - case AUDIO_FORMAT_TYPE_PCM_32_BIT: - *alsaPcmFormat = SND_PCM_FORMAT_S32_LE; /** Signed 32 bit Little Endian */ - break; - default: - return HDF_ERR_NOT_SUPPORT; - } - } else { /** Big Endian */ - switch (audioFormat) { - case AUDIO_FORMAT_TYPE_PCM_8_BIT: - *alsaPcmFormat = SND_PCM_FORMAT_S8; /** Signed 8 bit */ - break; - case AUDIO_FORMAT_TYPE_PCM_16_BIT: - *alsaPcmFormat = SND_PCM_FORMAT_S16_BE; /** Signed 16 bit Big Endian */ - break; - case AUDIO_FORMAT_TYPE_PCM_24_BIT: - *alsaPcmFormat = SND_PCM_FORMAT_S24_BE; /** Signed 24 bit Big Endian */ - break; - case AUDIO_FORMAT_TYPE_PCM_32_BIT: - *alsaPcmFormat = SND_PCM_FORMAT_S32_BE; /** Signed 32 bit Big Endian */ - break; - default: - return HDF_ERR_NOT_SUPPORT; - } - } - - return HDF_SUCCESS; -} - -static char *AudioAdaptersGetConfig(const char *fpath) -{ - int32_t jsonStrSize; - FILE *fp = NULL; - char *pJsonStr = NULL; - char pathBuf[PATH_MAX] = {0}; - - if (fpath == NULL) { - AUDIO_FUNC_LOGE("Parameter is null!!!"); - return NULL; - } - if (realpath(fpath, pathBuf) == NULL) { - AUDIO_FUNC_LOGE("File path invalid!"); - return NULL; - } - - fp = fopen(pathBuf, "r"); - if (fp == NULL) { - AUDIO_FUNC_LOGE("Can not open config file [ %{public}s ].", fpath); - return NULL; - } - if (fseek(fp, 0, SEEK_END) != 0) { - AUDIO_FUNC_LOGE("fseek configuration file error!"); - (void)fclose(fp); - return NULL; - } - jsonStrSize = ftell(fp); - if (jsonStrSize <= 0) { - AUDIO_FUNC_LOGE("The configuration file size <= 0!"); - (void)fclose(fp); - return NULL; - } - rewind(fp); - if (jsonStrSize > ALSA_CONFIG_FILE_MAX) { - AUDIO_FUNC_LOGE("The configuration file is too large to load!"); - (void)fclose(fp); - return NULL; - } - pJsonStr = (char *)OsalMemCalloc((uint32_t)jsonStrSize + 1); - if (pJsonStr == NULL) { - AUDIO_FUNC_LOGE("OsalMemCalloc pJsonStr failed!"); - (void)fclose(fp); - return NULL; - } - if (fread(pJsonStr, jsonStrSize, 1, fp) != 1) { - AUDIO_FUNC_LOGE("Read to config file failed!!!"); - (void)fclose(fp); - AudioMemFree((void **)&pJsonStr); - return NULL; - } - (void)fclose(fp); - - return pJsonStr; -} - -static cJSON *AudioCardGetConfig(const char *fpath) -{ - char *pJsonStr = NULL; - cJSON *cJsonObj = NULL; - - if (fpath == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return NULL; - } - - pJsonStr = AudioAdaptersGetConfig(fpath); - if (pJsonStr == NULL) { - AUDIO_FUNC_LOGE("AudioAdaptersGetConfig failed!"); - return NULL; - } - - cJsonObj = cJSON_Parse(pJsonStr); - if (cJsonObj == NULL) { - AUDIO_FUNC_LOGE("AudioAdaptersGetConfig failed!"); - AudioMemFree((void **)&pJsonStr); - return NULL; - } - AudioMemFree((void **)&pJsonStr); - - return cJsonObj; -} - -static int32_t AudioAdapterCheckName(const char *name) -{ - uint32_t len; - const char *strName = name; - - if (strName == NULL) { - AUDIO_FUNC_LOGE("Invalid parameter!"); - return HDF_FAILURE; - } - - len = strlen(strName); - if (len == 0 || len >= CARD_ID_LEN_MAX) { - AUDIO_FUNC_LOGW("name len is zero or too long!, len = %{public}d", len); - return HDF_FAILURE; - } - - if (!isalpha(*strName++)) { // Names must begin with a letter - AUDIO_FUNC_LOGE("The name of the illegal!"); - return HDF_FAILURE; - } - - while (*strName != '\0') { - if (*strName == '_' || *strName == '-') { - strName++; - continue; - } - - if (!isalnum(*strName++)) { - AUDIO_FUNC_LOGE("The name of the illegal!"); - return HDF_FAILURE; - } - } - - return HDF_SUCCESS; -} - -static enum SndCardType AudioAdapterNameToType(const char *name) -{ - enum SndCardType cardType = SND_CARD_UNKNOWN; - - if (name == NULL) { - AUDIO_FUNC_LOGE("Invalid parameter!"); - return SND_CARD_UNKNOWN; - } - - if (strcmp(name, "primary") == 0) { - cardType = SND_CARD_PRIMARY; - } else if (strcmp(name, "hdmi") == 0) { - cardType = SND_CARD_HDMI; - } else if (strcmp(name, "usb") == 0) { - cardType = SND_CARD_USB; - } else if (strcmp(name, "bt") == 0) { - cardType = SND_CARD_BT; - } - - return cardType; -} - -static int32_t AudioGetVolumeJsonObj(cJSON *object, cJSON **volumeJsonObj, const char *ctlName) -{ - if (object == NULL || volumeJsonObj == NULL || ctlName == NULL) { - AUDIO_FUNC_LOGE("Parameters is NULL!"); - return HDF_FAILURE; - } - - cJSON *ctlObjList = cJSON_GetObjectItem(object, ctlName); - if (ctlObjList == NULL) { - AUDIO_FUNC_LOGE("secondItem[%{public}s] Get Object Fail!", ctlName); - return HDF_FAILURE; - } - *volumeJsonObj = ctlObjList; - return HDF_SUCCESS; -} - -static int32_t AudioGetRenderVolumeInstance(struct DevProcInfo *adapter, cJSON *ctlVolumeList) -{ - int32_t ret; - cJSON *listSub = NULL; - char *ctlName = NULL; - cJSON *nodeCtlName = NULL; - - if (adapter == NULL || ctlVolumeList == NULL) { - AUDIO_FUNC_LOGE("Parameter is null"); - return HDF_FAILURE; - } - - int32_t arraySize = cJSON_GetArraySize(ctlVolumeList); - if (arraySize < 0 || arraySize > MIXER_CTL_MAX_NUM) { - AUDIO_FUNC_LOGE("Maximum support: %{public}d, but actually is %{public}d.", MIXER_CTL_MAX_NUM, arraySize); - return HDF_FAILURE; - } - - adapter->ctlRenderVolNameCount = arraySize; - adapter->ctlRenderNameList = - (struct MixerCtlVolumeName *)OsalMemCalloc(arraySize * sizeof(struct MixerCtlVolumeName)); - if (adapter->ctlRenderNameList == NULL) { - AUDIO_FUNC_LOGE("Out of memory!"); - return HDF_ERR_MALLOC_FAIL; - } - - for (int32_t index = 0; index < arraySize; index++) { - listSub = cJSON_GetArrayItem(ctlVolumeList, index); - if (listSub == NULL) { - AUDIO_FUNC_LOGE("cJSON_GetArrayItem failed, listSub is NULL!"); - AudioMemFree((void **)&adapter->ctlRenderNameList); - return HDF_FAILURE; - } - if ((nodeCtlName = cJSON_GetObjectItem(listSub, "name")) == NULL) { - AudioMemFree((void **)&adapter->ctlRenderNameList); - AUDIO_FUNC_LOGE("cJSON_GetObjectItem Failed!"); - return HDF_FAILURE; - } - ctlName = nodeCtlName->valuestring; - ret = strncpy_s(adapter->ctlRenderNameList[index].name, ALSA_CTL_NAME_LEN - 1, ctlName, strlen(ctlName)); - if (ret != 0) { - AUDIO_FUNC_LOGE("strncpy_s failed!"); - AudioMemFree((void **)&adapter->ctlRenderNameList); - return HDF_FAILURE; - } - } - - return HDF_SUCCESS; -} - -static int32_t AudioGetCaptureVolumeInstance(struct DevProcInfo *adapter, cJSON *ctlCaptureVolList) -{ - int32_t ret; - cJSON *listSub = NULL; - char *ctlName = NULL; - cJSON *nodeCtlName = NULL; - - if (adapter == NULL || ctlCaptureVolList == NULL) { - AUDIO_FUNC_LOGE("Parameter is null"); - return HDF_FAILURE; - } - int32_t arraySize = cJSON_GetArraySize(ctlCaptureVolList); - if (arraySize < 0 || arraySize > MIXER_CTL_MAX_NUM) { - AUDIO_FUNC_LOGE("Maximum support: %{public}d, but actually is %{public}d.", MIXER_CTL_MAX_NUM, arraySize); - return HDF_FAILURE; - } - adapter->ctlCaptureVolNameCount = arraySize; - adapter->ctlCaptureNameList = - (struct MixerCtlVolumeName *)OsalMemCalloc(arraySize * sizeof(struct MixerCtlVolumeName)); - if (adapter->ctlCaptureNameList == NULL) { - AUDIO_FUNC_LOGE("Out of memory!"); - return HDF_ERR_MALLOC_FAIL; - } - for (int32_t index = 0; index < arraySize; index++) { - listSub = cJSON_GetArrayItem(ctlCaptureVolList, index); - if (listSub == NULL) { - AUDIO_FUNC_LOGE("cJSON_GetArrayItem failed, listSub is NULL!"); - AudioMemFree((void **)&adapter->ctlCaptureNameList); - return HDF_FAILURE; - } - if ((nodeCtlName = cJSON_GetObjectItem(listSub, "name")) == NULL) { - AudioMemFree((void **)&adapter->ctlCaptureNameList); - AUDIO_FUNC_LOGE("cJSON_GetObjectItem Failed!"); - return HDF_FAILURE; - } - ctlName = nodeCtlName->valuestring; - ret = strncpy_s(adapter->ctlCaptureNameList[index].name, ALSA_CTL_NAME_LEN - 1, ctlName, strlen(ctlName)); - if (ret != 0) { - AUDIO_FUNC_LOGE("strncpy_s failed!"); - AudioMemFree((void **)&adapter->ctlCaptureNameList); - return HDF_FAILURE; - } - } - return HDF_SUCCESS; -} - -static int32_t AudioGetVolumeControls(cJSON *object, struct DevProcInfo *adapter) -{ - int32_t ret; - cJSON *ctlVolumeObj = NULL; - cJSON *ctlRenderVolumeList = NULL; - cJSON *ctlCaptureVolumeList = NULL; - - if (object == NULL || adapter == NULL) { - AUDIO_FUNC_LOGE("Parameter is null"); - return HDF_FAILURE; - } - ctlVolumeObj = cJSON_GetObjectItem(object, MIXER_CTL_VOLUME); - if (ctlVolumeObj == NULL) { - AUDIO_FUNC_LOGE("cJSON_GetObjectItem failed!"); - return HDF_FAILURE; - } - ret = AudioGetVolumeJsonObj(ctlVolumeObj, &ctlRenderVolumeList, PLAYBACK); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("AudioGetVolumeJsonObj failed."); - return ret; - } - - ret = AudioGetVolumeJsonObj(ctlVolumeObj, &ctlCaptureVolumeList, CAPTURE); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("AudioGetVolumeJsonObj failed."); - return ret; - } - - ret = AudioGetRenderVolumeInstance(adapter, ctlRenderVolumeList); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("AudioGetVolumeInstance failed."); - return ret; - } - ret = AudioGetCaptureVolumeInstance(adapter, ctlCaptureVolumeList); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("AudioGetVolumeInstance failed."); - return ret; - } - return HDF_SUCCESS; -} - -static int32_t AudioAdapterInfoSet(cJSON *adapterObj, struct DevProcInfo *cardDev, enum SndCardType cardType) -{ - int32_t ret; - struct DevProcInfo *adapter = NULL; - - if (cardDev == NULL || adapterObj == NULL) { - AUDIO_FUNC_LOGE("Invalid parameter!"); - return HDF_FAILURE; - } - - adapter = (struct DevProcInfo *)OsalMemCalloc(sizeof(struct DevProcInfo)); - if (adapter == NULL) { - AUDIO_FUNC_LOGE("calloc cardDev failed!"); - return HDF_FAILURE; - } - - ret = memcpy_s(adapter->cardName, CARD_ID_LEN_MAX - 1, cardDev->cardName, CARD_ID_LEN_MAX - 1); - if (ret != EOK) { - AUDIO_FUNC_LOGE("memcpy_s adapter card name fail!"); - AudioMemFree((void **)&adapter); - return HDF_FAILURE; - } - ret = memcpy_s(adapter->cid, CARD_ID_LEN_MAX - 1, cardDev->cid, CARD_ID_LEN_MAX - 1); - if (ret != EOK) { - AUDIO_FUNC_LOGE("memcpy_s adapter card id fail!"); - AudioMemFree((void **)&adapter); - return HDF_FAILURE; - } - ret = memcpy_s(adapter->did, CARD_ID_LEN_MAX - 1, cardDev->did, CARD_ID_LEN_MAX - 1); - if (ret != EOK) { - AUDIO_FUNC_LOGE("memcpy_s adapter dai id fail!"); - /* Only log is printed and cannot be returned */ - } - - if (strncmp(cardDev->cardName, PRIMARY, strlen(PRIMARY)) == 0) { - ret = AudioGetVolumeControls(adapterObj, adapter); - if (ret < 0) { - AUDIO_FUNC_LOGE("AudioGetVolumeControls failed!"); - return HDF_FAILURE; - } - } - - for (int cardNum = 0; cardNum < AUDIO_MAX_CARD_NUM; cardNum++) { - if (g_sndCardList[cardType][cardNum] == NULL) { - g_sndCardList[cardType][cardNum] = adapter; - break; - } - - if (cardNum == AUDIO_MAX_CARD_NUM - 1) { - AUDIO_FUNC_LOGE("The maximum limit for a single type of sound card is %{public}d.", AUDIO_MAX_CARD_NUM); - AudioMemFree((void **)&adapter); - return HDF_FAILURE; - } - } - - return HDF_SUCCESS; -} - -static cJSON *AudioGetItemString(cJSON *adapter, char *name) -{ - int32_t ret; - cJSON *item = NULL; - - if (adapter == NULL || name == NULL) { - AUDIO_FUNC_LOGE("Invalid parameter!"); - return NULL; - } - - item = cJSON_GetObjectItem(adapter, name); - if (item == NULL) { - AUDIO_FUNC_LOGE("item is null!"); - return NULL; - } - if (item->valuestring == NULL) { - AUDIO_FUNC_LOGE("item valuestring is null!"); - return NULL; - } - - ret = AudioAdapterCheckName(item->valuestring); - if (ret < 0) { - if (strncmp(name, "daiId", sizeof("daiId")) != 0) { - AUDIO_FUNC_LOGE("The %{public}s name incorrect!", name); - } - return NULL; - } - - return item; -} - -static int32_t AudioGetAllItem(cJSON *adapter, struct DevProcInfo *cardDev) -{ - int32_t ret; - cJSON *adapterName = NULL; - cJSON *cid = NULL; - cJSON *did = NULL; - - if (adapter == NULL || cardDev == NULL) { - AUDIO_FUNC_LOGE("Invalid parameter!"); - return HDF_FAILURE; - } - - adapterName = AudioGetItemString(adapter, "name"); - if (adapterName == NULL) { - AUDIO_FUNC_LOGE("Get adapterName failed!"); - return HDF_FAILURE; - } - ret = memcpy_s(cardDev->cardName, CARD_ID_LEN_MAX - 1, adapterName->valuestring, CARD_ID_LEN_MAX - 1); - if (ret != EOK) { - AUDIO_FUNC_LOGE("memcpy_s adapter card name fail!"); - return HDF_FAILURE; - } - - cid = AudioGetItemString(adapter, "cardId"); - if (cid == NULL) { - AUDIO_FUNC_LOGE("Get cid failed!"); - return HDF_FAILURE; - } - ret = memcpy_s(cardDev->cid, CARD_ID_LEN_MAX - 1, cid->valuestring, CARD_ID_LEN_MAX - 1); - if (ret != EOK) { - AUDIO_FUNC_LOGE("memcpy_s adapter card id fail!"); - return HDF_FAILURE; - } - - did = AudioGetItemString(adapter, "daiId"); - if (did == NULL) { // Not all sound cards have dai id. - return HDF_SUCCESS; - } - ret = memcpy_s(cardDev->did, CARD_ID_LEN_MAX - 1, did->valuestring, CARD_ID_LEN_MAX - 1); - if (ret != EOK) { - AUDIO_FUNC_LOGE("memcpy_s adapter card id fail!"); - /* Only log is printed and cannot be returned */ - } - - return HDF_SUCCESS; -} - -static int32_t AudioParseAdapter(cJSON *adapterObj) -{ - int ret; - struct DevProcInfo cardDev; - enum SndCardType cardType = SND_CARD_UNKNOWN; - - if (adapterObj == NULL) { - AUDIO_FUNC_LOGE("Parameter error!\n"); - return HDF_FAILURE; - } - - (void)memset_s(&cardDev, sizeof(struct DevProcInfo), 0, sizeof(struct DevProcInfo)); - ret = AudioGetAllItem(adapterObj, &cardDev); - if (ret < 0) { - AUDIO_FUNC_LOGE("AudioGetAllItem failed!\n"); - return ret; - } - cardType = AudioAdapterNameToType(cardDev.cardName); - switch (cardType) { - case SND_CARD_PRIMARY: - case SND_CARD_HDMI: - case SND_CARD_USB: - case SND_CARD_BT: - ret = AudioAdapterInfoSet(adapterObj, &cardDev, cardType); - if (ret < 0) { - AUDIO_FUNC_LOGE("AudioAdapterInfoSet failed!\n"); - return ret; - } - break; - default: - AUDIO_FUNC_LOGE("Sound card unknown!\n"); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -static int32_t AudioAdaptersSetAdapterVar(cJSON *cJsonObj) -{ - int32_t ret, adaptersArraySize; - cJSON *adapterObj = NULL; - - if (cJsonObj == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } - - adaptersArraySize = cJSON_GetArraySize(cJsonObj); - if (adaptersArraySize <= 0) { - AUDIO_FUNC_LOGE("Failed to get JSON array size!"); - return HDF_FAILURE; - } - if (adaptersArraySize > MAX_CARD_NUM) { - AUDIO_FUNC_LOGE("Read adapters number is %{public}d!", adaptersArraySize); - AUDIO_FUNC_LOGE("The number of sound cards exceeds the upper limit %{public}d.", MAX_CARD_NUM); - return HDF_FAILURE; - } - g_sndCardsNum = adaptersArraySize; - for (int32_t i = 0; i < adaptersArraySize; i++) { - adapterObj = cJSON_GetArrayItem(cJsonObj, i); - if (adapterObj != NULL) { - ret = AudioParseAdapter(adapterObj); - if (ret < 0) { - AUDIO_FUNC_LOGE("AudioParseAdapter (%{public}d) error!", i); - return HDF_FAILURE; - } - adapterObj = NULL; - } - } - - return HDF_SUCCESS; -} - -int32_t CardInfoParseFromConfig(void) -{ - int32_t ret; - cJSON *cJsonObj = NULL; - cJSON *adaptersObj = NULL; - - if (g_parseFlag) { - return HDF_SUCCESS; - } - - cJsonObj = AudioCardGetConfig(ALSA_CARD_CONFIG_FILE); - if (cJsonObj == NULL) { - AUDIO_FUNC_LOGE("AudioCardGetConfig failed!\n"); - return HDF_FAILURE; - } - - adaptersObj = cJSON_GetObjectItem(cJsonObj, "adapters"); - if (adaptersObj == NULL) { - AUDIO_FUNC_LOGE("cJSON_GetObjectItem adapters failed!\n"); - cJSON_Delete(cJsonObj); - return HDF_FAILURE; - } - - ret = AudioAdaptersSetAdapterVar(adaptersObj); - if (ret < 0) { - AUDIO_FUNC_LOGE("AudioAdaptersSetAdapterVar is failed!\n"); - cJSON_Delete(cJsonObj); - return HDF_FAILURE; - } - cJSON_Delete(cJsonObj); - g_parseFlag = true; - - return HDF_SUCCESS; -} - -struct DevHandle *AudioBindService(const char *name) -{ - (void)name; - struct DevHandle *handle = (struct DevHandle *)OsalMemCalloc(sizeof(struct DevHandle)); - if (handle == NULL) { - AUDIO_FUNC_LOGE("OsalMemCalloc handle failed!!!"); - return NULL; - } - - static struct HdfIoService hdfIoService; - handle->object = &hdfIoService; - return handle; -} - -void AudioCloseService(const struct DevHandle *handle) -{ - if (handle != NULL) { - if (handle->object == NULL) { - AUDIO_FUNC_LOGE("handle or handle->object is NULL"); - } - AudioMemFree((void **)&handle); - } -} - -static void AudioPortNameFree(struct AudioPort *dataBlock, uint32_t portsLen) -{ - if (dataBlock == NULL) { - return; - } - - for (uint32_t i = 0; i < portsLen; i++) { - OsalMemFree((void *)dataBlock[i].portName); - dataBlock[i].portName = NULL; - } - OsalMemFree(dataBlock); -} - -static void AudioFreeDesc(struct AudioAdapterDescriptor **descList, uint32_t sndCardNum) -{ - if (descList == NULL || *descList == NULL) { - AUDIO_FUNC_LOGE("AudioFreeDesc failed!"); - return; - } - - for (uint32_t index = 0; index < sndCardNum; index++) { - if ((*descList)[index].adapterName != NULL) { - AudioMemFree((void **)&((*descList)[index].adapterName)); - (*descList)[index].adapterName = NULL; - } -#ifndef AUDIO_HDI_SERVICE_MODE - AudioPortNameFree((*descList)[index].ports, (*descList)[index].portNum); -#else - AudioPortNameFree((*descList)[index].ports, (*descList)[index].portsLen); -#endif - } - - AudioMemFree((void **)descList); -} - -static char *AudioMatchCardName(char *cardName, int32_t cardType, int32_t cardNum) -{ - if (strcmp(cardName, PRIMARY) == 0) { - g_sndCardList[cardType][cardNum]->cardName[0] = 0; - return strdup("primary"); - } else if (strcmp(cardName, HDMI) == 0) { - g_sndCardList[cardType][cardNum]->cardName[0] = 0; - return strdup("hdmi"); - } else { - AUDIO_FUNC_LOGI("audio card fail to identify"); - } - return NULL; -} - -static char *AudioCardNameTransform(void) -{ - for (int32_t i = 0; i < SND_CARD_MAX; i++) { - for (int32_t j = 0; j < AUDIO_MAX_CARD_NUM; j++) { - if (g_sndCardList[i][j] != NULL && strlen(g_sndCardList[i][j]->cardName) != 0) { - return AudioMatchCardName(g_sndCardList[i][j]->cardName, i, j); - } - } - } - return NULL; -} - -static void InitAudioPortOut(struct AudioPort *audioPort) -{ - audioPort->dir = PORT_OUT; - audioPort->portId = 0; - audioPort->portName = strdup("AOP"); -} - -static void InitAudioPortIn(struct AudioPort *audioPort) -{ - audioPort->dir = PORT_IN; - audioPort->portId = 0; - audioPort->portName = strdup("AIP"); -} - -static void InitAudioPortOutAndIn(struct AudioPort *audioPort) -{ - audioPort->dir = PORT_OUT_IN; - audioPort->portId = 0; - audioPort->portName = strdup("AIOP"); -} - -static int32_t InitAudioPortsForUser(struct AudioAdapterDescriptor *desc) -{ - if (desc == NULL || desc->adapterName == NULL || desc->ports == NULL) { - AUDIO_FUNC_LOGE("Paras is null!"); - return HDF_ERR_INVALID_PARAM; - } - - if (strcmp(desc->adapterName, PRIMARY) == 0) { - InitAudioPortOut(&desc->ports[0]); - InitAudioPortIn(&desc->ports[SUPPORT_CAPTURE_OR_RENDER]); - InitAudioPortOutAndIn(&desc->ports[SUPPORT_CAPTURE_AND_RENDER]); - } else if (strcmp(desc->adapterName, HDMI) == 0) { - InitAudioPortOut(&desc->ports[0]); - } else if (strcmp(desc->adapterName, USB) == 0) { - InitAudioPortOut(&desc->ports[0]); - InitAudioPortIn(&desc->ports[SUPPORT_CAPTURE_OR_RENDER]); - } else { - AUDIO_FUNC_LOGE("Unknown sound card type does not support this sound card temporarily!"); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -static int32_t AudioReadCardPortToDesc(struct AudioAdapterDescriptor *desc) -{ - uint8_t portNum; - - if (desc == NULL || desc->adapterName == NULL) { - AUDIO_FUNC_LOGE("descs or desc->adapterName is NULL!"); - return HDF_ERR_INVALID_PARAM; - } - - if (strcmp(desc->adapterName, PRIMARY) == 0) { - portNum = PORT_OUT_IN; /* support (capture, render, capture & render) */ - } else if (strcmp(desc->adapterName, HDMI) == 0) { - portNum = PORT_OUT; /* support render */ - } else if (strcmp(desc->adapterName, USB) == 0) { - portNum = PORT_IN; /* support (capture, render) */ - } else { - AUDIO_FUNC_LOGE("Unknown sound card type does not support this sound card temporarily!"); - return HDF_FAILURE; - } - -#ifndef AUDIO_HDI_SERVICE_MODE - desc->portNum = portNum; -#else - desc->portsLen = portNum; -#endif - - desc->ports = (struct AudioPort *)OsalMemCalloc(sizeof(struct AudioPort) * portNum); - if (desc->ports == NULL) { - AUDIO_FUNC_LOGE("OsalMemCalloc failed!"); - return HDF_FAILURE; - } - if (InitAudioPortsForUser(desc) < 0) { - AUDIO_FUNC_LOGE("InitAudioPortsForUser failed!"); - AudioMemFree((void **)&desc->ports); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -static int32_t AudioReadCardInfoToDesc(struct AudioAdapterDescriptor **descs, uint8_t cardNum, bool usbAudioState) -{ - int32_t index = 0; - int32_t cardNumTemp = 0; - if (descs == NULL || cardNum == 0) { - AUDIO_FUNC_LOGE("Parameter error."); - return HDF_FAILURE; - } - cardNumTemp = cardNum; - if (*descs == NULL) { - AUDIO_FUNC_LOGW("*descs is null, need memcalloc."); - *descs = (struct AudioAdapterDescriptor *)OsalMemCalloc(sizeof(struct AudioAdapterDescriptor) * cardNum); - if (*descs == NULL) { - AUDIO_FUNC_LOGE("OsalMemCalloc descs is NULL"); - return HDF_FAILURE; - } - } - if (usbAudioState) { - (*descs)[cardNum - 1].adapterName = strdup(USB); - cardNumTemp = cardNum - 1; - } - - for (index = 0; index < cardNumTemp; index++) { - (*descs)[index].adapterName = AudioCardNameTransform(); - if ((*descs)[index].adapterName == NULL) { - AUDIO_FUNC_LOGE("(*descs)[index].adapterName is NULL!"); - AudioFreeDesc(descs, cardNum); - return HDF_FAILURE; - } - } - - for (index = 0; index < cardNum; index++) { - if (AudioReadCardPortToDesc(&(*descs)[index]) != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("read port failed!"); - AudioFreeDesc(descs, cardNum); - return HDF_FAILURE; - } - } - - return HDF_SUCCESS; -} - -static bool CheckUsbAudioIsInserted(struct AlsaCardsList *cardList) -{ - if (cardList == NULL) { - AUDIO_FUNC_LOGE("The parameter is empty."); - return false; - } - - for (int32_t i = 0; i < MAX_CARD_NUM; i++) { - /** External codec */ - if (strcmp(USB_AUDIO, cardList->alsaDevIns[i].pcmInfoId) == 0) { - return true; - } - } - - return false; -} - -int32_t AudioGetAllCardInfo(struct AudioAdapterDescriptor **descs, int32_t *sndCardNum) -{ - if (descs == NULL || sndCardNum == NULL) { - AUDIO_FUNC_LOGE("descs or sndCardNum is NULL!"); - return HDF_ERR_INVALID_PARAM; - } - AUDIO_FUNC_LOGI("enter!"); - /* Parse sound card from configuration file */ - int32_t ret = CardInfoParseFromConfig(); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("parse config file failed! ret = %{public}d", ret); - return HDF_FAILURE; - } - - /* Read sound card list from alsa hardware */ - (void)memset_s(&g_alsaCardsList, sizeof(struct AlsaCardsList), 0, sizeof(struct AlsaCardsList)); - GetDeviceList(&g_alsaCardsList, SND_PCM_STREAM_PLAYBACK); - - /* Check whether there is a USB sound card through pcmInfoId ("USB Audio") */ - bool usbAduioFlag = CheckUsbAudioIsInserted(&g_alsaCardsList); - if (usbAduioFlag) { - g_sndCardsNum += 1; - } - *sndCardNum = g_sndCardsNum; - - /* Reconstruct sound card information to user */ - if (AudioReadCardInfoToDesc(descs, g_sndCardsNum, usbAduioFlag) != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("AudioReadCardInfoToDesc failed!"); - *sndCardNum = 0; - CardInfoRelease(); - return HDF_FAILURE; - } - CardInfoRelease(); - return HDF_SUCCESS; -} -- Gitee From 0475cacb813a013f0be29fa207faf658fade9793 Mon Sep 17 00:00:00 2001 From: xiesicong Date: Fri, 22 Sep 2023 10:13:13 +0800 Subject: [PATCH 05/14] =?UTF-8?q?=E4=B8=8A=E4=BC=A0=E6=92=AD=E6=94=BE?= =?UTF-8?q?=E5=99=A8=E7=B1=BB=E5=AE=9E=E7=8E=B0=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xiesicong --- .../alsa_adapter/include/alsa_snd_render.h | 84 ++ .../alsa_adapter/src/alsa_snd_render.c | 909 ++++++++++++++++++ 2 files changed, 993 insertions(+) create mode 100755 audio/supportlibs/alsa_adapter/include/alsa_snd_render.h create mode 100755 audio/supportlibs/alsa_adapter/src/alsa_snd_render.c diff --git a/audio/supportlibs/alsa_adapter/include/alsa_snd_render.h b/audio/supportlibs/alsa_adapter/include/alsa_snd_render.h new file mode 100755 index 0000000000..b4327566aa --- /dev/null +++ b/audio/supportlibs/alsa_adapter/include/alsa_snd_render.h @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2022 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 ALSA_SND_RENDER_H +#define ALSA_SND_RENDER_H + +#include "alsa_soundcard.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void* RenderPriData; + +typedef struct AlsaRender AlsaRender; +struct AlsaRender{ + struct AlsaSoundCard soundCard; + enum AudioPortPin descPins; + bool muteState; + bool periodEvent; /* produce poll event after each period */ + snd_pcm_sframes_t bufferSize; + snd_pcm_sframes_t periodSize; + unsigned int bufferTime; /* (0.5s): ring buffer length in us */ + unsigned int periodTime; /* (0.1s): period time in us */ + RenderPriData priData; + + /* render scene */ + int32_t (*Init)(struct AlsaRender*); + int32_t (*SelectScene)(struct AlsaRender *, enum AudioPortPin, const struct PathDeviceInfo *); + int32_t (*Open)(struct AlsaRender *); + int32_t (*Start)(struct AlsaRender *); + int32_t (*Stop)(struct AlsaRender *); + int32_t (*Close)(struct AlsaRender *); + int32_t (*Write)(struct AlsaRender *, const struct AudioHwRenderParam *); + int32_t (*GetMmapPosition)(struct AlsaRender *); + int32_t (*MmapWrite)(struct AlsaRender *, const struct AudioHwRenderParam *); + + /* volume operation */ + int32_t (*GetVolThreshold)(struct AlsaRender *, long *, long *); + int32_t (*GetVolume)(struct AlsaRender *, long *); + int32_t (*SetVolume)(struct AlsaRender *, long ); + + /* gain operation */ + int32_t (*GetGainThreshold)(struct AlsaRender *, float *, float *); + int32_t (*GetGain)(struct AlsaRender *, float *); + int32_t (*SetGain)(struct AlsaRender *, float ); + + /* mute operation */ + bool (*GetMute)(struct AlsaRender *); + int32_t (*SetMute)(struct AlsaRender *, bool); + + /* channel mode operation */ + int32_t (*GetChannelMode)(struct AlsaRender *, enum AudioChannelMode *); + int32_t (*SetChannelMode)(struct AlsaRender *, enum AudioChannelMode ); +}; + +struct AlsaRender *RenderCreateInstance(const char* adapterName); +struct AlsaRender *RenderGetInstance(const char *adapterName); +int32_t RenderSetParams(struct AlsaRender *renderIns, const struct AudioHwRenderParam *handleData); +void RenderSetPriData(struct AlsaRender *renderIns, RenderPriData data); +RenderPriData RenderGetPriData(struct AlsaRender *renderIns); + +/* + Different platforms implement this function rewriting render implementation + */ +int32_t RenderOverrideFunc(struct AlsaRender *renderIns); + +#ifdef __cplusplus +} +#endif + +#endif /* ALSA_SND_RENDER_H */ \ No newline at end of file diff --git a/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c b/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c new file mode 100755 index 0000000000..f01a091523 --- /dev/null +++ b/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c @@ -0,0 +1,909 @@ +/* + * Copyright (c) 2022 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 "alsa_soundcard.h" +#include "alsa_snd_render.h" +#include "osal_time.h" + +#define HDF_LOG_TAG HDF_AUDIO_HAL_RENDER + +#define MAX_PERIOD_SIZE (8 * 1024) +#define MIN_PERIOD_SIZE (4 * 1024) +#define AUDIO_RENDER_RECOVER_DELAY (10 * 1000) +#define POLL_EVENT_DEF false +#define AUDIO_BUFFER_TIME_DEF 500000 +#define AUDIO_PERIOD_TIME_DEF 100000 +#ifdef SUPPORT_ALSA_CHMAP +#define CHMAP_NAME_LENGHT_MAX 256 + +/* channel map list type */ +#define CHANNEL_MAP_TYPE_FIXED "FIXED" /* fixed channel position */ +#define CHANNEL_MAP_TYPE_VAR "VAR" /* freely swappable channel position */ +#define CHANNEL_MAP_TYPE_PAIRED "PAIRED" /* pair-wise swappable channel position */ +#endif + +static struct AlsaRender *g_alsaRenderList = NULL; +static void RegisterRenderImpl(struct AlsaRender *renderIns); + +void RenderSetPriData(struct AlsaRender *renderIns, RenderPriData data) +{ + renderIns->priData = data; +} + +RenderPriData RenderGetPriData(struct AlsaRender *renderIns) +{ + return renderIns->priData; +} + +static int32_t CreateRenderIns(void) +{ + if (g_alsaRenderList == NULL) { + g_alsaRenderList = (struct AlsaRender *)OsalMemCalloc(MAX_CARD_NUM * sizeof(struct AlsaRender)); + if (g_alsaRenderList == NULL) { + AUDIO_FUNC_LOGE("Failed to allocate memory!"); + return HDF_FAILURE; + } + } + return HDF_SUCCESS; +} + +static int32_t RenderFreeMemory(void) +{ + int32_t i; + + if (g_alsaRenderList != NULL) { + for (i = 0; i < MAX_CARD_NUM; i++) { + if (g_alsaRenderList[i].soundCard.cardStatus != 0) { + AUDIO_FUNC_LOGE("refCount is not zero, Sound card in use!"); + return HDF_ERR_DEVICE_BUSY; + } + + if (g_alsaRenderList[i].priData != NULL) { + OsalMemFree(g_alsaRenderList[i].priData); + g_alsaRenderList[i].priData = NULL; + } + } + AudioMemFree((void **)&g_alsaRenderList); + g_alsaRenderList = NULL; + } + + return HDF_SUCCESS; +} + +static int32_t SetHWParamsSub( + snd_pcm_t *handle, snd_pcm_hw_params_t *params, const struct AudioPcmHwParams *hwParams, snd_pcm_access_t access) +{ + int32_t ret; + snd_pcm_format_t pcmFormat = SND_PCM_FORMAT_S16_LE; + CHECK_NULL_PTR_RETURN_DEFAULT(handle); + CHECK_NULL_PTR_RETURN_DEFAULT(params); + + /* set hardware resampling,enable alsa-lib resampling */ + ret = snd_pcm_hw_params_set_rate_resample(handle, params, 1); + if (ret < 0) { + AUDIO_FUNC_LOGE("Resampling setup failed for playback: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + /* set the interleaved read/write format */ + ret = snd_pcm_hw_params_set_access(handle, params, access); + if (ret < 0) { + AUDIO_FUNC_LOGE("Access type not available for playback: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + ret = SndConverAlsaPcmFormat(hwParams, &pcmFormat); + if (ret < 0) { + AUDIO_FUNC_LOGE("SndConverAlsaPcmFormat error."); + return HDF_FAILURE; + } + /* set the sample format */ + ret = snd_pcm_hw_params_set_format(handle, params, pcmFormat); + if (ret < 0) { + AUDIO_FUNC_LOGE("Sample format not available for playback: %{public}s, format: %{public}d", snd_strerror(ret), pcmFormat); + return HDF_FAILURE; + } + /* set the count of channels */ + ret = snd_pcm_hw_params_set_channels(handle, params, hwParams->channels); + if (ret < 0) { + AUDIO_FUNC_LOGE("Channels count (%{public}u) not available for playbacks: %{public}s", hwParams->channels, + snd_strerror(ret)); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t SetHWRate(snd_pcm_t *handle, snd_pcm_hw_params_t *params, uint32_t *rate) +{ + int32_t ret; + uint32_t rRate; + int dir = 0; /* dir Value range (-1,0,1) */ + CHECK_NULL_PTR_RETURN_DEFAULT(handle); + CHECK_NULL_PTR_RETURN_DEFAULT(params); + CHECK_NULL_PTR_RETURN_DEFAULT(rate); + + /* set the stream rate */ + rRate = *rate; + ret = snd_pcm_hw_params_set_rate_near(handle, params, &rRate, &dir); + if (ret < 0) { + AUDIO_FUNC_LOGE("Rate %{public}uHz not available for playback: %{public}s.", *rate, snd_strerror(ret)); + return HDF_FAILURE; + } + + if (rRate != *rate) { + ret = snd_pcm_hw_params_set_rate_near(handle, params, &rRate, &dir); + if (ret < 0) { + AUDIO_FUNC_LOGE("Rate %{public}uHz not available for playback: %{public}s.", *rate, snd_strerror(ret)); + return HDF_FAILURE; + } + } + /* Update to hardware supported rate */ + *rate = rRate; + + return HDF_SUCCESS; +} + +static int32_t SetHWParams(struct AlsaSoundCard *cardIns, snd_pcm_access_t access) +{ + int ret; + int dir = 0; /* dir Value range (-1,0,1) */ + snd_pcm_uframes_t size; + snd_pcm_hw_params_t *hwParams = NULL; + snd_pcm_t *handle = cardIns->pcmHandle; + struct AlsaRender *renderIns = (struct AlsaRender*)cardIns; + CHECK_NULL_PTR_RETURN_DEFAULT(handle); + + snd_pcm_hw_params_alloca(&hwParams); + ret = snd_pcm_hw_params_any(handle, hwParams); // choose all parameters + if (ret < 0) { + AUDIO_FUNC_LOGE("No configurations available: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + + ret = SetHWParamsSub(handle, hwParams, &cardIns->hwParams, access); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("SetHWParamsSub failed!"); + return ret; + } + + ret = SetHWRate(handle, hwParams, &(cardIns->hwParams.rate)); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("SetHWRate failed!"); + return ret; + } + + snd_pcm_hw_params_get_buffer_time_max(hwParams, &renderIns->bufferTime, &dir); + if (renderIns->bufferTime > 500000) + renderIns->bufferTime = 500000; + renderIns->periodTime = renderIns->bufferTime / 4; + + ret = snd_pcm_hw_params_set_buffer_time_near(handle, hwParams, &renderIns->bufferTime, &dir); + if (ret < 0) { + AUDIO_FUNC_LOGE("Set buffer time %{public}u failed: %{public}s", renderIns->bufferTime, snd_strerror(ret)); + return HDF_FAILURE; + } + + ret = snd_pcm_hw_params_get_buffer_size(hwParams, &size); + if (ret < 0) { + AUDIO_FUNC_LOGE("Unable to get buffer size for playback: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + renderIns->bufferSize = size; + + ret = snd_pcm_hw_params_set_period_time_near(handle, hwParams, &renderIns->periodTime, &dir); + if (ret < 0) { + AUDIO_FUNC_LOGE("Set period time %{public}u failed: %{public}s", renderIns->bufferTime, snd_strerror(ret)); + return HDF_FAILURE; + } + + ret = snd_pcm_hw_params_get_period_size(hwParams, &size, &dir); + if (ret < 0) { + AUDIO_FUNC_LOGE("Unable to get period size for playback: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + renderIns->periodSize = size; + + ret = snd_pcm_hw_params(handle, hwParams); // write the parameters to device + if (ret < 0) { + AUDIO_FUNC_LOGE("Unable to set hw params for playback: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + + cardIns->canPause = snd_pcm_hw_params_can_pause(hwParams); + return HDF_SUCCESS; +} + +static int32_t SetSWParams(struct AlsaSoundCard *cardIns) +{ + int32_t ret; + int32_t val = 1; /* val 0 = disable period event, 1 = enable period event */ + snd_pcm_sw_params_t *swParams = NULL; + snd_pcm_t *handle = cardIns->pcmHandle; + struct AlsaRender *renderIns = (struct AlsaRender *)cardIns; + CHECK_NULL_PTR_RETURN_DEFAULT(handle); + + snd_pcm_sw_params_alloca(&swParams); + + /* get the current swparams */ + ret = snd_pcm_sw_params_current(handle, swParams); + if (ret < 0) { + AUDIO_FUNC_LOGE("Unable to determine current swparams for playback: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + /* start the transfer when the buffer is almost full: */ + /* (buffer_size / avail_min) * avail_min */ + if (renderIns->periodSize == 0) { + AUDIO_FUNC_LOGE("g_periodSize=0"); + return HDF_FAILURE; + } + ret = snd_pcm_sw_params_set_start_threshold(handle, swParams, + (renderIns->bufferSize / renderIns->periodSize) * renderIns->periodSize); + if (ret < 0) { + AUDIO_FUNC_LOGE("Unable to set start threshold mode for playback: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + /* allow the transfer when at least period_size samples can be processed */ + /* or disable this mechanism when period event is enabled (aka interrupt like style processing) */ + ret = snd_pcm_sw_params_set_avail_min(handle, swParams, + renderIns->periodEvent ? renderIns->bufferSize : renderIns->periodSize); + if (ret < 0) { + AUDIO_FUNC_LOGE("Unable to set avail min for playback: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + + /* enable period events when requested */ + if (renderIns->periodEvent) { + ret = snd_pcm_sw_params_set_period_event(handle, swParams, val); + if (ret < 0) { + AUDIO_FUNC_LOGE("Unable to set period event: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + } + + /* write the parameters to the playback device */ + ret = snd_pcm_sw_params(handle, swParams); + if (ret < 0) { + AUDIO_FUNC_LOGE("Unable to set sw params for playback: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t ResetRenderParams(struct AlsaSoundCard *cardIns, snd_pcm_access_t access) +{ + int32_t ret; + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + + ret = SetHWParams(cardIns, access); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Setting of hwparams failed."); + return ret; + } + + ret = SetSWParams(cardIns); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Setting of swparams failed."); + return ret; + } + + return HDF_SUCCESS; +} + +static struct AlsaRender *GetRenderInsByName(const char *adapterName) +{ + int32_t ret; + int32_t i; + struct AlsaRender *renderIns = NULL; + struct AlsaSoundCard *alsaSnd = NULL; + + /* + fine the instance with the corresponding adapter name, or create one if none. + */ + for (i = 0; i < MAX_CARD_NUM; i++) { + alsaSnd = (struct AlsaSoundCard *)&g_alsaRenderList[i]; + if (alsaSnd->cardStatus) { + if (0 == strcmp(alsaSnd->adapterName, adapterName)) { + return &g_alsaRenderList[i]; + } + } + } + + for (i = 0; i < MAX_CARD_NUM; i++) { + renderIns = &g_alsaRenderList[i]; + alsaSnd = (struct AlsaSoundCard *)&g_alsaRenderList[i]; + if (alsaSnd->cardStatus == 0) { + (void)memset_s(renderIns, sizeof(struct AlsaRender), 0, sizeof(struct AlsaRender)); + ret = strncpy_s(alsaSnd->adapterName, MAX_CARD_NAME_LEN + 1, adapterName, strlen(adapterName)); + if (ret != 0) { + AUDIO_FUNC_LOGE("strncpy_s failed!"); + return NULL; + } + alsaSnd->cardStatus++; + renderIns->periodEvent = POLL_EVENT_DEF; + renderIns->periodTime = AUDIO_PERIOD_TIME_DEF; + renderIns->bufferTime = AUDIO_BUFFER_TIME_DEF; + renderIns->descPins = PIN_NONE; + return renderIns; + } + } + AUDIO_FUNC_LOGE("Failed to AddCardIns!"); + return NULL; +} + +struct AlsaRender *RenderCreateInstance(const char* adapterName) +{ + int32_t ret; + struct AlsaRender *renderIns = NULL; + if (adapterName == NULL || strlen(adapterName) == 0) { + AUDIO_FUNC_LOGE("Invalid adapterName!"); + return NULL; + } + + ret = CreateRenderIns(); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Failed to create render instance."); + return NULL; + } + + renderIns = GetRenderInsByName(adapterName); + if (renderIns == NULL) { + AUDIO_FUNC_LOGE("get render instance failed."); + return NULL; + } + RegisterRenderImpl(renderIns); + + ret = SndSaveCardListInfo(SND_PCM_STREAM_PLAYBACK); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Failed to save card device info."); + return NULL; + } + + ret = SndMatchSelAdapter(&renderIns->soundCard, adapterName); + if (ret != HDF_SUCCESS) { + SndCloseHandle(&renderIns->soundCard); + RenderFreeMemory(); + return NULL; + } + + RenderOverrideFunc(renderIns); + return renderIns; +} + +struct AlsaRender *RenderGetInstance(const char *adapterName) +{ + int32_t i; + + if (adapterName == NULL || strlen(adapterName) == 0) { + AUDIO_FUNC_LOGE("Invalid adapterName!"); + return NULL; + } + + if (g_alsaRenderList == NULL) { + AUDIO_FUNC_LOGE("g_alsaRenderList is NULL!"); + return NULL; + } + + for (i = 0; i < MAX_CARD_NUM; i++) { + if (strcmp(g_alsaRenderList[i].soundCard.adapterName, adapterName) == 0) { + return &(g_alsaRenderList[i]); + } + } + + return NULL; +} + +#ifdef SUPPORT_ALSA_CHMAP +static int32_t GetChannelsNameFromUser(struct AlsaSoundCard *cardIns, const char *channelsName) +{ + if (channelsName == NULL) { + AUDIO_FUNC_LOGE("channelsName is NULL!"); + return HDF_ERR_INVALID_PARAM; + } + + if (cardIns->hwParams.channelsName == NULL) { + cardIns->hwParams.channelsName = (char *)OsalMemCalloc(CHMAP_NAME_LENGHT_MAX); + if (cardIns->hwParams.channelsName == NULL) { + AUDIO_FUNC_LOGE("Failed to allocate memory!"); + return HDF_ERR_MALLOC_FAIL; + } + } + + (void)memset_s(cardIns->hwParams.channelsName, CHMAP_NAME_LENGHT_MAX, 0, CHMAP_NAME_LENGHT_MAX); + int32_t ret = strncpy_s(cardIns->hwParams.channelsName, CHMAP_NAME_LENGHT_MAX - 1, + channelsName, strlen(channelsName)); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("strncpy_s failed!"); + AudioMemFree((void **)&(cardIns->hwParams.channelsName)); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} +#endif + + static int32_t SaveHwParams(struct AlsaSoundCard *cardIns, const struct AudioHwRenderParam *handleData) +{ + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); + + cardIns->hwParams.streamType = AUDIO_RENDER_STREAM; + cardIns->hwParams.channels = handleData->frameRenderMode.attrs.channelCount; + cardIns->hwParams.rate = handleData->frameRenderMode.attrs.sampleRate; + cardIns->hwParams.periodSize = handleData->frameRenderMode.periodSize; + cardIns->hwParams.periodCount = handleData->frameRenderMode.periodCount; + cardIns->hwParams.format = handleData->frameRenderMode.attrs.format; + cardIns->hwParams.period = handleData->frameRenderMode.attrs.period; + cardIns->hwParams.frameSize = handleData->frameRenderMode.attrs.frameSize; + cardIns->hwParams.isBigEndian = handleData->frameRenderMode.attrs.isBigEndian; + cardIns->hwParams.isSignedData = handleData->frameRenderMode.attrs.isSignedData; + cardIns->hwParams.startThreshold = handleData->frameRenderMode.attrs.startThreshold; + cardIns->hwParams.stopThreshold = handleData->frameRenderMode.attrs.stopThreshold; + cardIns->hwParams.silenceThreshold = handleData->frameRenderMode.attrs.silenceThreshold; +#ifdef SUPPORT_ALSA_CHMAP + /* param 2 by handleData->frameRenderMode.attrs.channelsName, sample channelsName is "FL, FR" */ + if (GetChannelsNameFromUser(cardIns, "FL, FR") != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("GetChannelsNameFromUser failed"); + return HDF_FAILURE; + } +#endif + + return HDF_SUCCESS; +} + +#ifdef SUPPORT_ALSA_CHMAP +static void PrintChannels(const snd_pcm_chmap_t *map) +{ + char tmp[CHMAP_NAME_LENGHT_MAX] = {0}; + if (snd_pcm_chmap_print(map, sizeof(tmp), tmp) > 0) { + HDF_LOGI("print_channels: %{public}s.", tmp); + } +} + +static int32_t QueryChmaps(snd_pcm_t *pcm) +{ + snd_pcm_chmap_query_t **pChmap = NULL; + snd_pcm_chmap_query_t *chmap = NULL; + const char *champType = NULL; + snd_pcm_chmap_query_t **hwChmap = snd_pcm_query_chmaps(pcm); + if (hwChmap == NULL) { + AUDIO_FUNC_LOGE("This sound card has no chmap component, cannot query maps."); + return HDF_FAILURE; + } + + for (pChmap = hwChmap; (chmap = *pChmap) != NULL; pChmap++) { + champType = snd_pcm_chmap_type_name(chmap->type); + HDF_LOGI("Channel Type = %{public}s, Channels = %{public}d.", champType, chmap->map.channels); + if (strncmp(champType, CHANNEL_MAP_TYPE_FIXED, strlen(CHANNEL_MAP_TYPE_FIXED)) == 0) { + HDF_LOGW("Fixed channel type does not support modification temporarily!"); + } + PrintChannels(&chmap->map); + } + + snd_pcm_free_chmaps(hwChmap); + return HDF_SUCCESS; +} + +static int32_t SetChmap(snd_pcm_t *pcm, struct AudioPcmHwParams *hwRenderParams) +{ + if (hwRenderParams == NULL || hwRenderParams->channelsName == NULL) { + AUDIO_FUNC_LOGE("Parameter is NULL!"); + return HDF_FAILURE; + } + + snd_pcm_chmap_t *chmap = snd_pcm_chmap_parse_string(hwRenderParams->channelsName); + if (chmap == NULL) { + AUDIO_FUNC_LOGE("parse chmap error!"); + return HDF_FAILURE; + } + + if (snd_pcm_set_chmap(pcm, chmap) < 0) { + AUDIO_FUNC_LOGE("Cannot set chmap!"); + free((void *)chmap); + return HDF_ERR_NOT_SUPPORT; + } + free((void *)chmap); + + chmap = snd_pcm_get_chmap(pcm); + if (chmap == NULL) { + AUDIO_FUNC_LOGE("Cannot get chmap!"); + return HDF_ERR_NOT_SUPPORT; + } + + PrintChannels(chmap); + free((void *)chmap); + return HDF_SUCCESS; +} + +static int32_t RenderHwParamsChmaps(struct AlsaSoundCard *cardIns) +{ + if (QueryChmaps(cardIns->pcmHandle) != HDF_SUCCESS) { + AUDIO_FUNC_LOGW("QueryChmaps failed."); + return HDF_SUCCESS; + } + if (SetChmap(cardIns->pcmHandle, &cardIns->hwParams) != HDF_SUCCESS) { + AUDIO_FUNC_LOGW("SetChmap failed."); + } + + return HDF_SUCCESS; +} +#endif + +int32_t RenderSetParams(struct AlsaRender *renderIns, const struct AudioHwRenderParam *handleData) +{ + int32_t ret; + int bits_per_sample; + snd_pcm_format_t fmt; + struct AlsaSoundCard *cardIns = (struct AlsaSoundCard *)renderIns; + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); + + SaveHwParams(&renderIns->soundCard, handleData); + ret = SetHWParams(cardIns, SND_PCM_ACCESS_RW_INTERLEAVED); + if (ret < 0) { + AUDIO_FUNC_LOGE("Setting of hwparams failed."); + return HDF_FAILURE; + } + + ret = SetSWParams(cardIns); + if (ret < 0) { + AUDIO_FUNC_LOGE("Setting of swparams failed."); + return HDF_FAILURE; + } + +#ifdef SUPPORT_ALSA_CHMAP + ret = RenderHwParamsChmaps(&renderIns->soundCard); + if (ret < 0) { + AUDIO_FUNC_LOGE("Setting of chmaps failed."); + } +#endif + + SndConverAlsaPcmFormat(&cardIns->hwParams, &fmt); + bits_per_sample = snd_pcm_format_physical_width(fmt); + cardIns->hwParams.bitsPerFrame = bits_per_sample * cardIns->hwParams.channels; + + return HDF_SUCCESS; +} + +static int32_t RenderWritei(snd_pcm_t *pcm, const struct AudioHwRenderParam *handleData, + const struct AudioPcmHwParams *hwParams) +{ + int32_t ret, offset; + long frames; + char * dataBuf; + size_t sbufFrameSize; + snd_pcm_state_t state; + int32_t tryNum = AUDIO_ALSALIB_RETYR; + CHECK_NULL_PTR_RETURN_DEFAULT(pcm); + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); + + /* Check whether the PCM status is normal */ + state = snd_pcm_state(pcm); + if (state == SND_PCM_STATE_SETUP) { + ret = snd_pcm_prepare(pcm); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_pcm_prepare fail: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + } + + sbufFrameSize = (size_t)handleData->frameRenderMode.bufferFrameSize; + dataBuf = handleData->frameRenderMode.buffer; + offset = hwParams->bitsPerFrame /8; + while (sbufFrameSize > 0) { + frames = snd_pcm_writei(pcm, dataBuf, sbufFrameSize); + if (frames > 0) { + sbufFrameSize -= frames; + dataBuf += frames * offset; + } else if (frames == -EAGAIN){ + snd_pcm_wait(pcm, 100); + tryNum--; + if (tryNum == 0) { + return HDF_SUCCESS; + } + } else if (frames == -EBADFD) { + /* not #SND_PCM_STATE_PREPARED or #SND_PCM_STATE_RUNNING */ + AUDIO_FUNC_LOGE("render PCM is not in the right state: %{public}s", snd_strerror(frames)); + snd_pcm_prepare(pcm); + return HDF_FAILURE; + } else { + /* -ESTRPIPE: a suspend event occurred, + * stream is suspended and waiting for an application recovery. + * -EPIPE: an underrun occurred. + */ + AUDIO_FUNC_LOGI("err: %{public}s",snd_strerror(ret)); + ret = snd_pcm_recover(pcm, frames, 0); // 0 for open render recover log. + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_pcm_writei failed: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + } + } + + return HDF_SUCCESS; +} + +static int32_t RenderWriteiMmap(struct AlsaSoundCard *cardIns, const struct AudioHwRenderParam *handleData) +{ + int32_t ret; + uint32_t frameSize; + uint32_t totalSize; + uint32_t lastBuffSize; + uint32_t loopTimes; + uint32_t looper = 0; + uint32_t copyLen; + int32_t count = 0; + struct AudioMmapBufferDescriptor *mmapBufDesc = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); + + cardIns->mmapFlag = false; + ret = ResetRenderParams(cardIns, SND_PCM_ACCESS_MMAP_INTERLEAVED); + if (ret < 0) { + AUDIO_FUNC_LOGE("AudioSetParamsMmap failed!"); + return HDF_FAILURE; + } + + frameSize = cardIns->hwParams.channels * cardIns->hwParams.format; + if (frameSize == 0) { + AUDIO_FUNC_LOGE("frame size = 0!"); + return HDF_FAILURE; + } + mmapBufDesc = (struct AudioMmapBufferDescriptor *)&(handleData->frameRenderMode.mmapBufDesc); + totalSize = (uint32_t)mmapBufDesc->totalBufferFrames * frameSize; + lastBuffSize = ((totalSize % MIN_PERIOD_SIZE) == 0) ? MIN_PERIOD_SIZE : (totalSize % MIN_PERIOD_SIZE); + loopTimes = (lastBuffSize == MIN_PERIOD_SIZE) ? (totalSize / MIN_PERIOD_SIZE) : (totalSize / MIN_PERIOD_SIZE + 1); + while (looper < loopTimes) { + copyLen = (looper < (loopTimes - 1)) ? MIN_PERIOD_SIZE : lastBuffSize; + snd_pcm_uframes_t frames = (snd_pcm_uframes_t)(copyLen / frameSize); + ret = snd_pcm_mmap_writei( + cardIns->pcmHandle, (char *)mmapBufDesc->memoryAddress + mmapBufDesc->offset, frames); + if (ret == -EAGAIN) { + count++; + if (count > AUDIO_ALSALIB_MMAP_MAX) { + AUDIO_FUNC_LOGE("loop > max !"); + return HDF_FAILURE; + } + continue; + } + count = 0; + if (ret < 0) { + AUDIO_FUNC_LOGE("Write error: %{public}s\n", snd_strerror(ret)); + return HDF_FAILURE; + } + looper++; + mmapBufDesc->offset += copyLen; + cardIns->mmapFrames += (uint64_t)frames; + } + + return HDF_SUCCESS; +} + +static int32_t RenderOpenImpl(struct AlsaRender *renderIns) +{ + int32_t ret; + struct AlsaSoundCard *cardIns = (struct AlsaSoundCard *)renderIns; + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); + + if (SndisBusy(&renderIns->soundCard)) { + AUDIO_FUNC_LOGE("Resource busy!!"); + return HDF_ERR_DEVICE_BUSY; + } + + ret = snd_pcm_open(&cardIns->pcmHandle, cardIns->devName, + SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_pcm_open fail: %{public}s!", snd_strerror(ret)); + RenderFreeMemory(); + return HDF_FAILURE; + } + + ret = snd_pcm_nonblock(cardIns->pcmHandle, 1); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_pcm_nonblock fail: %{public}s!", snd_strerror(ret)); + SndCloseHandle(&renderIns->soundCard); + RenderFreeMemory(); + return HDF_FAILURE; + } + + ret = SndOpenMixer(&renderIns->soundCard); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("SndOpenMixer failed"); + SndCloseHandle(&renderIns->soundCard); + RenderFreeMemory(); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t RenderCloseImpl(struct AlsaRender *renderIns) +{ + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); +#ifdef SUPPORT_ALSA_CHMAP + AudioMemFree((void **)&renderIns->soundCard.hwParams.channelsName); +#endif + SndCloseHandle(&renderIns->soundCard); + RenderFreeMemory(); + return HDF_SUCCESS; +} + +int32_t RenderWriteImpl(struct AlsaRender *renderIns, const struct AudioHwRenderParam *handleData) +{ + int32_t ret; + struct AlsaSoundCard *cardIns = (struct AlsaSoundCard*)renderIns; + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); + + if(cardIns->pauseState) { + AUDIO_FUNC_LOGE("Currently in pause, please check!"); + return HDF_FAILURE; + } + + if (!cardIns->mmapFlag) { + ret = ResetRenderParams(cardIns, SND_PCM_ACCESS_RW_INTERLEAVED); + if (ret < 0) { + AUDIO_FUNC_LOGE("ResetRenderParams failed!"); + return HDF_FAILURE; + } + cardIns->mmapFlag = true; + } + + ret = RenderWritei(cardIns->pcmHandle, handleData, &cardIns->hwParams); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("RenderWritei failed!"); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t RenderGetMmapPositionImpl(struct AlsaRender *renderIns) +{ + return renderIns->soundCard.mmapFrames; +} + +int32_t RenderMmapWriteImpl(struct AlsaRender *renderIns, const struct AudioHwRenderParam *handleData) +{ + int32_t ret; + struct AlsaSoundCard *cardIns = (struct AlsaSoundCard *)renderIns; + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); + + cardIns->mmapFlag = false; + ret = ResetRenderParams(cardIns, SND_PCM_ACCESS_MMAP_INTERLEAVED); + if (ret < 0) { + AUDIO_FUNC_LOGE("ResetRenderParams failed!"); + return HDF_FAILURE; + } + + ret = RenderWriteiMmap(cardIns, handleData); + if (ret < 0) { + AUDIO_FUNC_LOGE("RenderWriteiMmap error!"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +static int32_t RenderInitImpl(struct AlsaRender* renderIns) +{ + AUDIO_FUNC_LOGE("Not yet realized"); + return HDF_SUCCESS; +} + +static int32_t RenderSelectSceneImpl(struct AlsaRender *renderIns, enum AudioPortPin descPins, + const struct PathDeviceInfo *deviceInfo) +{ + AUDIO_FUNC_LOGE("Not yet realized"); + return HDF_SUCCESS; +} + +static int32_t RenderStartImpl(struct AlsaRender *renderIns) +{ + AUDIO_FUNC_LOGE("Not yet realized"); + return HDF_SUCCESS; +} + +static int32_t RenderStopImpl(struct AlsaRender *renderIns) +{ + AUDIO_FUNC_LOGE("Not yet realized"); + return HDF_SUCCESS; +} + +static int32_t RenderGetVolThresholdImpl(struct AlsaRender *renderIns, long *volMin, long *volMax) +{ + AUDIO_FUNC_LOGE("Not yet realized"); + return HDF_SUCCESS; +} + +static int32_t RenderGetVolumeImpl(struct AlsaRender *renderIns, long *volume) +{ + AUDIO_FUNC_LOGE("Not yet realized"); + return HDF_SUCCESS; +} + +static int32_t RenderSetVolumeImpl(struct AlsaRender *renderIns, long volume) +{ + AUDIO_FUNC_LOGE("Not yet realized"); + return HDF_SUCCESS; +} + +static int32_t RenderGetGainThresholdImpl(struct AlsaRender *renderIns, float *gainMin, float *gainMax) +{ + AUDIO_FUNC_LOGE("Not yet realized"); + return HDF_SUCCESS; +} + +static int32_t RenderGetGainImpl(struct AlsaRender *renderIns, float *volume) +{ + AUDIO_FUNC_LOGE("Not yet realized"); + return HDF_SUCCESS; +} + +static int32_t RenderSetGainImpl(struct AlsaRender *renderIns, float volume) +{ + AUDIO_FUNC_LOGE("Not yet realized"); + return HDF_SUCCESS; +} + +static bool RenderGetMuteImpl(struct AlsaRender *renderIns) +{ + AUDIO_FUNC_LOGE("Not yet realized"); + return false; +} + +static int32_t RenderSetMuteImpl(struct AlsaRender *renderIns, bool muteFlag) +{ + AUDIO_FUNC_LOGE("Not yet realized"); + return HDF_SUCCESS; +} + +static int32_t RenderGetChannelModeImpl(struct AlsaRender *renderIns, enum AudioChannelMode *mode) +{ + AUDIO_FUNC_LOGE("Not yet realized"); + return HDF_SUCCESS; +} + +static int32_t RenderSetChannelModeImpl(struct AlsaRender *renderIns, enum AudioChannelMode mode) +{ + AUDIO_FUNC_LOGE("Not yet realized"); + return HDF_SUCCESS; +} + +static void RegisterRenderImpl(struct AlsaRender *renderIns) +{ + if (renderIns == NULL) { + AUDIO_FUNC_LOGE("renderIns is NULL!"); + } + + renderIns->Init = RenderInitImpl; + renderIns->Open = RenderOpenImpl; + renderIns->SelectScene = RenderSelectSceneImpl; + renderIns->Start = RenderStartImpl; + renderIns->Stop = RenderStopImpl; + renderIns->Close = RenderCloseImpl; + renderIns->Write = RenderWriteImpl; + renderIns->MmapWrite = RenderMmapWriteImpl; + renderIns->GetMmapPosition = RenderGetMmapPositionImpl; + renderIns->GetVolThreshold = RenderGetVolThresholdImpl; + renderIns->GetVolume = RenderGetVolumeImpl; + renderIns->SetVolume = RenderSetVolumeImpl; + renderIns->GetGainThreshold = RenderGetGainThresholdImpl; + renderIns->GetGain = RenderGetGainImpl; + renderIns->SetGain = RenderSetGainImpl; + renderIns->GetMute = RenderGetMuteImpl; + renderIns->SetMute = RenderSetMuteImpl; + renderIns->GetChannelMode = RenderGetChannelModeImpl; + renderIns->SetChannelMode = RenderSetChannelModeImpl; +} + -- Gitee From 3176a2ac81ba7efd74a9aa3794a28f562d84a522 Mon Sep 17 00:00:00 2001 From: xiesicong Date: Fri, 22 Sep 2023 10:13:39 +0800 Subject: [PATCH 06/14] =?UTF-8?q?=E4=B8=8A=E4=BC=A0=E5=BD=95=E9=9F=B3?= =?UTF-8?q?=E5=99=A8=E7=B1=BB=E5=AE=9E=E7=8E=B0=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xiesicong --- .../alsa_adapter/include/alsa_snd_capture.h | 81 ++ .../alsa_adapter/src/alsa_snd_capture.c | 883 ++++++++++++++++++ 2 files changed, 964 insertions(+) create mode 100755 audio/supportlibs/alsa_adapter/include/alsa_snd_capture.h create mode 100755 audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c diff --git a/audio/supportlibs/alsa_adapter/include/alsa_snd_capture.h b/audio/supportlibs/alsa_adapter/include/alsa_snd_capture.h new file mode 100755 index 0000000000..9e44236cd2 --- /dev/null +++ b/audio/supportlibs/alsa_adapter/include/alsa_snd_capture.h @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2022 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 ALSA_SND_CAPTURE_H +#define ALSA_SND_CAPTURE_H + +#include "alsa_soundcard.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void* CapturePriData; + +typedef struct AlsaCapture AlsaCapture; +struct AlsaCapture{ + struct AlsaSoundCard soundCard; + enum AudioPortPin descPins; + bool muteState; + bool periodEvent; /* produce poll event after each period */ + snd_pcm_sframes_t bufferSize; + snd_pcm_sframes_t periodSize; + unsigned int bufferTime; /* (0.5s): ring buffer length in us */ + unsigned int periodTime; /* (0.1s): period time in us */ + int resample; /* enable alsa-lib resampling */ + CapturePriData priData; + + /* Capture scene */ + int32_t (*Init)(struct AlsaCapture*); + int32_t (*Open)(struct AlsaCapture *); + int32_t (*SelectScene)(struct AlsaCapture *, enum AudioPortPin, const struct PathDeviceInfo *); + int32_t (*Start)(struct AlsaCapture *); + int32_t (*Stop)(struct AlsaCapture *); + int32_t (*Close)(struct AlsaCapture *); + int32_t (*Read)(struct AlsaCapture *, struct AudioHwCaptureParam *); + int32_t (*GetMmapPosition)(struct AlsaCapture *); + int32_t (*MmapRead)(struct AlsaCapture *, const struct AudioHwCaptureParam *); + + /* volume operation */ + int32_t (*GetVolThreshold)(struct AlsaCapture *, long *, long *); + int32_t (*GetVolume)(struct AlsaCapture *, long *); + int32_t (*SetVolume)(struct AlsaCapture *, long); + + /* gain operation */ + int32_t (*GetGainThreshold)(struct AlsaCapture *, float *, float *); + int32_t (*GetGain)(struct AlsaCapture *, float *); + int32_t (*SetGain)(struct AlsaCapture *, float); + + /* mute operation */ + bool (*GetMute)(struct AlsaCapture *); + int32_t (*SetMute)(struct AlsaCapture *,bool); +}; + +struct AlsaCapture *CaptureCreateInstance(const char* adapterName); +struct AlsaCapture *CaptureGetInstance(const char *adapterName); +int32_t CaptureSetParams(struct AlsaCapture *captureIns, const struct AudioHwCaptureParam *handleData); +void CaptureSetPriData(struct AlsaCapture *captureIns, CapturePriData data); +CapturePriData CaptureGetPriData(struct AlsaCapture *captureIns); + +/* + Different platforms implement this function rewriting capture implementation + */ +int32_t CaptureOverrideFunc(struct AlsaCapture *captureIns); + +#ifdef __cplusplus +} +#endif + +#endif /* ALSA_SND_CAPTURE_H */ \ No newline at end of file diff --git a/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c b/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c new file mode 100755 index 0000000000..abd15208c7 --- /dev/null +++ b/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c @@ -0,0 +1,883 @@ +/* + * Copyright (c) 2022 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 "alsa_soundcard.h" +#include "alsa_snd_capture.h" + +#define HDF_LOG_TAG HDF_AUDIO_HAL_CAPTURE + +#define AUDIO_TIMESTAMP_FREQ 8 /* Hz */ +#define AUDIO_SAMPLE_FREQ 48000 +#define AUDIO_PERIOD ((AUDIO_SAMPLE_FREQ) / (AUDIO_TIMESTAMP_FREQ)) +#define AUDIO_PCM_WAIT 100 +#define AUDIO_RESUME_POLL (10 * (AUDIO_PCM_WAIT)) // 1s +#define ALSA_CAP_BUFFER_SIZE (2 * 2 * 6000) // format(S16LE) * channels(2) * period. + +#define POLL_EVENT_DEF false +#define AUDIO_BUFFER_TIME_DEF 500000 +#define AUDIO_PERIOD_TIME_DEF 100000 + +static struct AlsaCapture *g_alsaCaptureList = NULL; +static void RegisterCaptureImpl(struct AlsaCapture *captureIns); + +void CaptureSetPriData(struct AlsaCapture *captureIns, CapturePriData data) +{ + captureIns->priData = data; +} + +CapturePriData CaptureGetPriData(struct AlsaCapture *captureIns) +{ + return captureIns->priData; +} + +static int32_t CaptureFreeMemory(void) +{ + int32_t i; + + if (g_alsaCaptureList != NULL) { + for (i = 0; i < MAX_CARD_NUM; i++) { + if (g_alsaCaptureList[i].soundCard.cardStatus != 0) { + AUDIO_FUNC_LOGE("refCount is not zero, Sound card in use!"); + return HDF_ERR_DEVICE_BUSY; + } + if (g_alsaCaptureList[i].priData != NULL) { + OsalMemFree(g_alsaCaptureList[i].priData); + g_alsaCaptureList[i].priData = NULL; + } + } + AudioMemFree((void **)&g_alsaCaptureList); + g_alsaCaptureList = NULL; + } + + return HDF_SUCCESS; +} + +static int32_t SetHWParamsSub( + struct AlsaSoundCard *cardIns, snd_pcm_hw_params_t *params, snd_pcm_access_t access) +{ + int32_t ret; + snd_pcm_format_t pcmFormat; + snd_pcm_t *handle = cardIns->pcmHandle; + struct AlsaCapture *captureIns = (struct AlsaCapture *)cardIns; + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(params); + + ret = snd_pcm_hw_params_set_rate_resample(handle, params, captureIns->resample); + if (ret < 0) { + AUDIO_FUNC_LOGE("Resampling setup failed for capture: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + + /* set the interleaved read/write format */ + ret = snd_pcm_hw_params_set_access(handle, params, access); + if (ret < 0) { + AUDIO_FUNC_LOGE("Access type not available for capture: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + ret = SndConverAlsaPcmFormat(&cardIns->hwParams, &pcmFormat); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("SndConverAlsaPcmFormat error."); + return ret; + } + + /* set the sample format */ + ret = snd_pcm_hw_params_set_format(handle, params, pcmFormat); + if (ret < 0) { + AUDIO_FUNC_LOGE("Sample format not available for capture: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + + /* set the count of channels */ + ret = snd_pcm_hw_params_set_channels(handle, params, cardIns->hwParams.channels); + if (ret < 0) { + AUDIO_FUNC_LOGE("Channels count (%{public}u) not available for capture: %{public}s", cardIns->hwParams.channels, + snd_strerror(ret)); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t SetHWRate(struct AlsaSoundCard *cardIns, snd_pcm_hw_params_t *params) +{ + int32_t ret; + uint32_t rRate; + int32_t dir = 0; /* dir Value range (-1,0,1) */ + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(params); + + /* set the stream rate */ + rRate = cardIns->hwParams.rate; + ret = snd_pcm_hw_params_set_rate_near(cardIns->pcmHandle, params, &rRate, &dir); + if (ret < 0) { + AUDIO_FUNC_LOGE("Rate %{public}uHz not available for capture: %{public}s", cardIns->hwParams.rate, snd_strerror(ret)); + return HDF_FAILURE; + } + + if (rRate != cardIns->hwParams.rate) { + ret = snd_pcm_hw_params_set_rate_near(cardIns->pcmHandle, params, &rRate, &dir); + if (ret < 0) { + AUDIO_FUNC_LOGE("Rate %{public}uHz not available for capture: %{public}s", cardIns->hwParams.rate, snd_strerror(ret)); + return HDF_FAILURE; + } + } + /* Update to hardware supported rate */ + cardIns->hwParams.rate = rRate; + + return HDF_SUCCESS; +} + +static int32_t SetHWBuffer(struct AlsaSoundCard *cardIns, snd_pcm_hw_params_t *params) +{ + int32_t ret; + int32_t dir = 0; /* dir Value range (-1,0,1) */ + snd_pcm_uframes_t size = 0; + struct AlsaCapture *captureIns = (struct AlsaCapture *)cardIns; + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(params); + + ret = snd_pcm_hw_params_set_buffer_time_near(cardIns->pcmHandle, params, &captureIns->bufferTime, &dir); + if (ret < 0) { + AUDIO_FUNC_LOGE("Unable to set buffer time %{public}u for capture: %{public}s", + captureIns->bufferTime, snd_strerror(ret)); + return HDF_FAILURE; + } + + ret = snd_pcm_hw_params_get_buffer_size(params, &size); + if (ret < 0) { + AUDIO_FUNC_LOGE("Unable to get buffer size for capture: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + captureIns->bufferSize = size; + + return HDF_SUCCESS; +} + +static int32_t SetHWPeriod(struct AlsaSoundCard *cardIns, snd_pcm_hw_params_t *params) +{ + int32_t ret; + int32_t dir = 0; /* dir Value range (-1,0,1) */ + snd_pcm_uframes_t size = 0; + struct AlsaCapture *captureIns = (struct AlsaCapture*)cardIns; + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(params); + + ret = snd_pcm_hw_params_set_period_time_near(cardIns->pcmHandle, params, &captureIns->periodTime, &dir); + if (ret < 0) { + AUDIO_FUNC_LOGE("Unable to set period time %{public}u for capture: %{public}s", + captureIns->periodTime, snd_strerror(ret)); + return HDF_FAILURE; + } + + ret = snd_pcm_hw_params_get_period_size(params, &size, &dir); + if (ret < 0) { + AUDIO_FUNC_LOGE("Unable to get period size for capture: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + captureIns->periodSize = size; + + return HDF_SUCCESS; +} + +static int32_t SetHWParams(struct AlsaSoundCard *cardIns, snd_pcm_access_t access) +{ + int32_t ret; + snd_pcm_hw_params_t *hwParams = NULL; + snd_pcm_t *handle = cardIns->pcmHandle; + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(handle); + + snd_pcm_hw_params_alloca(&hwParams); + ret = snd_pcm_hw_params_any(handle, hwParams); // choose all parameters + if (ret < 0) { + AUDIO_FUNC_LOGE("Broken configuration for capture: no configurations available: %{public}s.", + snd_strerror(ret)); + return HDF_FAILURE; + } + + ret = SetHWParamsSub(cardIns, hwParams, access); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("SetHWParamsSub failed!"); + return ret; + } + + ret = SetHWRate(cardIns, hwParams); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("SetHWRate failed!"); + return ret; + } + + ret = SetHWBuffer(cardIns, hwParams); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("SetHWBuffer failed!"); + return ret; + } + + ret = SetHWPeriod(cardIns, hwParams); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("SetHWPeriod failed!"); + return ret; + } + + /* write the parameters to device. */ + ret = snd_pcm_hw_params(handle, hwParams); + if (ret < 0) { + AUDIO_FUNC_LOGE("Unable to set hw params for capture: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + + cardIns->canPause = snd_pcm_hw_params_can_pause(hwParams); + + return HDF_SUCCESS; +} + +static int32_t SetSWParams(struct AlsaSoundCard *cardIns) +{ + int32_t ret; + snd_pcm_sw_params_t *swParams = NULL; + snd_pcm_t *handle = cardIns->pcmHandle; + struct AlsaCapture *captureIns = (struct AlsaCapture *)cardIns; + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(handle); + + snd_pcm_sw_params_alloca(&swParams); + + /* get the current swparams */ + ret = snd_pcm_sw_params_current(handle, swParams); + if (ret < 0) { + AUDIO_FUNC_LOGE("Unable to determine current swparams for capture: %{public}s.", snd_strerror(ret)); + return HDF_FAILURE; + } + + if (captureIns->periodSize == 0) { + AUDIO_FUNC_LOGE("error: g_periodSize cannot be zero!"); + return HDF_FAILURE; + } + /* start the transfer when the buffer is almost full: */ + /* (buffer_size / avail_min) * avail_min */ + ret = snd_pcm_sw_params_set_start_threshold(handle, swParams, + (captureIns->bufferSize / captureIns->periodSize) * captureIns->periodSize); + if (ret < 0) { + AUDIO_FUNC_LOGE("Unable to set start threshold mode for capture: %{public}s.", snd_strerror(ret)); + return HDF_FAILURE; + } + + /* allow the transfer when at least period_size samples can be processed */ + /* or disable this mechanism when period event is enabled (aka interrupt like style processing) */ + ret = snd_pcm_sw_params_set_avail_min(handle, swParams, + captureIns->periodEvent ? captureIns->bufferSize : captureIns->periodSize); + if (ret < 0) { + AUDIO_FUNC_LOGE("Unable to set avail min for capture: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + + /* enable period events when requested */ + if (captureIns->periodEvent) { + ret = snd_pcm_sw_params_set_period_event(handle, swParams, 1); + if (ret < 0) { + AUDIO_FUNC_LOGE("Unable to set period event: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + } + + /* write the parameters to the capture device */ + ret = snd_pcm_sw_params(handle, swParams); + if (ret < 0) { + AUDIO_FUNC_LOGE("Unable to set sw params for capture: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t ResetCaptureParams(struct AlsaSoundCard *cardIns, snd_pcm_access_t access) +{ + int32_t ret; + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns->pcmHandle); + + ret = SetHWParams(cardIns, access); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Setting of hwparams failed: %{public}d.", ret); + return ret; + } + + ret = SetSWParams(cardIns); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Setting of swparams failed: %{public}d.", ret); + return ret; + } + + return HDF_SUCCESS; +} + +static int32_t UpdateSetParams(struct AlsaSoundCard *cardIns) +{ + int32_t ret; + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns->pcmHandle); + + cardIns->mmapFlag = false; + ret = ResetCaptureParams(cardIns, SND_PCM_ACCESS_MMAP_INTERLEAVED); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("AudioSetParamsMmap failed!"); + return ret; + } + + ret = snd_pcm_start(cardIns->pcmHandle); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_pcm_start fail. %{public}s.", snd_strerror(ret)); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t SaveHwParams(struct AlsaSoundCard *cardIns, const struct AudioHwCaptureParam *handleData) +{ + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); + + cardIns->hwParams.streamType = AUDIO_CAPTURE_STREAM; + cardIns->hwParams.channels = handleData->frameCaptureMode.attrs.channelCount; + cardIns->hwParams.rate = handleData->frameCaptureMode.attrs.sampleRate; + cardIns->hwParams.periodSize = handleData->frameCaptureMode.periodSize; + cardIns->hwParams.periodCount = handleData->frameCaptureMode.periodCount; + cardIns->hwParams.format = handleData->frameCaptureMode.attrs.format; + cardIns->hwParams.period = handleData->frameCaptureMode.attrs.period; + cardIns->hwParams.frameSize = handleData->frameCaptureMode.attrs.frameSize; + cardIns->hwParams.isBigEndian = handleData->frameCaptureMode.attrs.isBigEndian; + cardIns->hwParams.isSignedData = handleData->frameCaptureMode.attrs.isSignedData; + cardIns->hwParams.startThreshold = handleData->frameCaptureMode.attrs.startThreshold; + cardIns->hwParams.stopThreshold = handleData->frameCaptureMode.attrs.stopThreshold; + cardIns->hwParams.silenceThreshold = handleData->frameCaptureMode.attrs.silenceThreshold; + + return HDF_SUCCESS; +} + +int32_t CaptureSetParams(struct AlsaCapture *captureIns, const struct AudioHwCaptureParam *handleData) +{ + int32_t ret; + struct AlsaSoundCard *cardIns = (struct AlsaSoundCard *)captureIns; + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); + + SaveHwParams(cardIns, handleData); + ret = SetHWParams(cardIns, SND_PCM_ACCESS_RW_INTERLEAVED); + if (ret < 0) { + AUDIO_FUNC_LOGE("Setting of hwparams failed."); + return HDF_FAILURE; + } + + ret = SetSWParams(cardIns); + if (ret < 0) { + AUDIO_FUNC_LOGE("Setting of swparams failed."); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static struct AlsaCapture *GetCaptureInsByName(const char *adapterName) +{ + int32_t ret; + int32_t i; + struct AlsaCapture *captureIns = NULL; + struct AlsaSoundCard *alsaSnd = NULL; + + /* + fine the instance with the corresponding adapter name, or create one if none. + */ + for (i = 0; i < MAX_CARD_NUM; i++) { + alsaSnd = (struct AlsaSoundCard *)&g_alsaCaptureList[i]; + if (alsaSnd->cardStatus) { + if (0 == strcmp(alsaSnd->adapterName, adapterName)) { + return &g_alsaCaptureList[i]; + } + } + } + + for (i = 0; i < MAX_CARD_NUM; i++) { + captureIns = &g_alsaCaptureList[i]; + alsaSnd = (struct AlsaSoundCard *)&g_alsaCaptureList[i]; + if (alsaSnd->cardStatus == 0) { + (void)memset_s(captureIns, sizeof(struct AlsaCapture), 0, sizeof(struct AlsaCapture)); + ret = strncpy_s(alsaSnd->adapterName, MAX_CARD_NAME_LEN + 1, adapterName, strlen(adapterName)); + if (ret != 0) { + AUDIO_FUNC_LOGE("strncpy_s failed!"); + return NULL; + } + alsaSnd->cardStatus++; + captureIns->periodEvent = POLL_EVENT_DEF; + captureIns->periodTime = AUDIO_PERIOD_TIME_DEF; + captureIns->bufferTime = AUDIO_BUFFER_TIME_DEF; + captureIns->descPins = PIN_NONE; + captureIns->resample = 1; + return captureIns; + } + } + AUDIO_FUNC_LOGE("Failed to AddCardIns!"); + return NULL; +} + +struct AlsaCapture *CaptureCreateInstance(const char* adapterName) +{ + int32_t ret; + struct AlsaCapture *captureIns = NULL; + if (adapterName == NULL || strlen(adapterName) == 0) { + AUDIO_FUNC_LOGE("Invalid adapterName!"); + return NULL; + } + + if (g_alsaCaptureList == NULL) { + g_alsaCaptureList = (struct AlsaCapture *)OsalMemCalloc(MAX_CARD_NUM * sizeof(struct AlsaCapture)); + if (g_alsaCaptureList == NULL) { + AUDIO_FUNC_LOGE("Failed to allocate memory!"); + return NULL; + } + } + + captureIns = GetCaptureInsByName(adapterName); + if (captureIns == NULL) { + AUDIO_FUNC_LOGE("Get capture instance failed."); + return NULL; + } + RegisterCaptureImpl(captureIns); + + ret = SndSaveCardListInfo(SND_PCM_STREAM_PLAYBACK); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Failed to save card device info."); + return NULL; + } + + ret = SndMatchSelAdapter(&captureIns->soundCard, adapterName); + if (ret != HDF_SUCCESS) { + SndCloseHandle(&captureIns->soundCard); + CaptureFreeMemory(); + return NULL; + } + CaptureOverrideFunc(captureIns); + + return captureIns; +} + +struct AlsaCapture *CaptureGetInstance(const char *adapterName) +{ + int32_t i; + + if (adapterName == NULL || strlen(adapterName) == 0) { + AUDIO_FUNC_LOGE("Invalid cardName!"); + return NULL; + } + + if (g_alsaCaptureList == NULL) { + AUDIO_FUNC_LOGE("g_alsaCaptureList is NULL!"); + return NULL; + } + + for (i = 0; i < MAX_CARD_NUM; i++) { + if (strcmp(g_alsaCaptureList[i].soundCard.adapterName, adapterName) == 0) { + return &(g_alsaCaptureList[i]); + } + } + + return NULL; +} + +static int32_t CheckCapFrameBufferSize(struct AudioHwCaptureParam *handleData, snd_pcm_uframes_t *periodSize) +{ + uint32_t capFrameSize; + uint64_t capReqBufferSize; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); + CHECK_NULL_PTR_RETURN_DEFAULT(periodSize); + + capFrameSize = handleData->frameCaptureMode.attrs.channelCount * handleData->frameCaptureMode.attrs.format; + if (capFrameSize == 0) { + AUDIO_FUNC_LOGE("Capture frame size is zero!"); + return HDF_FAILURE; + } + capReqBufferSize = capFrameSize * (*periodSize); + if (capReqBufferSize > FRAME_DATA) { + *periodSize = FRAME_DATA / capFrameSize; + } + + return HDF_SUCCESS; +} + +static int32_t CheckPcmStatus(snd_pcm_t *capturePcmHandle) +{ + int32_t ret; + CHECK_NULL_PTR_RETURN_DEFAULT(capturePcmHandle); + + ret = snd_pcm_wait(capturePcmHandle, -1); /* -1 for timeout, Waiting forever */ + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_pcm_wait failed: %{public}s.", snd_strerror(ret)); + return HDF_FAILURE; + } + + if (snd_pcm_state(capturePcmHandle) == SND_PCM_STATE_SETUP) { + ret = snd_pcm_prepare(capturePcmHandle); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_pcm_prepare fail: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + } + + return HDF_SUCCESS; +} + +static int32_t CapturePcmReadi(snd_pcm_t *pcm, uint64_t *frameCnt, char *dataBuf, snd_pcm_uframes_t bufSize) +{ + int32_t ret; + long frames; + int32_t tryNum = AUDIO_ALSALIB_RETYR; + CHECK_NULL_PTR_RETURN_DEFAULT(pcm); + CHECK_NULL_PTR_RETURN_DEFAULT(frameCnt); + CHECK_NULL_PTR_RETURN_DEFAULT(dataBuf); + if (bufSize == 0) { + AUDIO_FUNC_LOGE("Capture data buf is empty."); + return HDF_FAILURE; + } + + do { + /* Read interleaved frames to a PCM. */ + frames = snd_pcm_readi(pcm, dataBuf, bufSize); + if (frames > 0) { + *frameCnt = (uint64_t)frames; + return HDF_SUCCESS; + } + + if (frames == -EBADFD) { + AUDIO_FUNC_LOGE("Capture PCM is not in the right state: %{public}s", snd_strerror(frames)); + ret = snd_pcm_prepare(pcm); + if (ret < 0) { + AUDIO_FUNC_LOGE("Capture snd_pcm_prepare fail: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + } else { + /* -ESTRPIPE: a suspend event occurred, + * stream is suspended and waiting for an application recovery. + * -EPIPE: an underrun occurred. + */ + ret = snd_pcm_recover(pcm, frames, 0); // 0 for open capture recover log. + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_pcm_readi failed: %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + } + ret = snd_pcm_start(pcm); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_pcm_start fail. %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + tryNum--; + } while (tryNum > 0); + + return HDF_SUCCESS; +} + +static int32_t CaptureDataCopy(struct AudioHwCaptureParam *handleData, char *buffer, uint64_t frames) +{ + int32_t ret; + uint32_t channels; + uint32_t format; + uint64_t recvDataSize; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); + CHECK_NULL_PTR_RETURN_DEFAULT(buffer); + if (frames == 0) { + AUDIO_FUNC_LOGE("Capture buffer size is empty!"); + return HDF_FAILURE; + } + + if (handleData->frameCaptureMode.buffer == NULL) { + AUDIO_FUNC_LOGE("frameCaptureMode.buffer is NULL!"); + return HDF_FAILURE; + } + channels = handleData->frameCaptureMode.attrs.channelCount; + format = (uint32_t)handleData->frameCaptureMode.attrs.format; + recvDataSize = (uint64_t)(frames * channels * format); + ret = memcpy_s(handleData->frameCaptureMode.buffer, FRAME_DATA, buffer, recvDataSize); + if (ret != EOK) { + AUDIO_FUNC_LOGE("memcpy frame data failed!"); + return HDF_FAILURE; + } + handleData->frameCaptureMode.bufferSize = recvDataSize; + handleData->frameCaptureMode.bufferFrameSize = frames; + + return HDF_SUCCESS; +} + +static int32_t CaptureOpenImpl(struct AlsaCapture *captureIns) +{ + int32_t ret; + CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); + + if (SndisBusy(&captureIns->soundCard)) { + AUDIO_FUNC_LOGE("Resource busy!!"); + SndCloseHandle(&captureIns->soundCard); + return HDF_ERR_DEVICE_BUSY; + } + + ret = snd_pcm_open(&captureIns->soundCard.pcmHandle, captureIns->soundCard.devName, + SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_pcm_open fail: %{public}s!", snd_strerror(ret)); + CaptureFreeMemory(); + return HDF_FAILURE; + } + + ret = snd_pcm_nonblock(captureIns->soundCard.pcmHandle, 1); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_pcm_nonblock fail: %{public}s!", snd_strerror(ret)); + SndCloseHandle(&captureIns->soundCard); + CaptureFreeMemory(); + return HDF_FAILURE; + } + + ret = SndOpenMixer(&captureIns->soundCard); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("SndOpenMixer failed"); + SndCloseHandle(&captureIns->soundCard); + CaptureFreeMemory(); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t CaptureCloseImpl(struct AlsaCapture *captureIns) +{ + CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); + SndCloseHandle(&captureIns->soundCard); + CaptureFreeMemory(); + return HDF_SUCCESS; +} + +static int32_t CaptureReadImpl(struct AlsaCapture *captureIns, struct AudioHwCaptureParam *handleData) +{ + int32_t ret; + uint64_t frames = 0; + char *buffer = NULL; + snd_pcm_uframes_t bufferSize = 0; + snd_pcm_uframes_t periodSize = 0; + struct AlsaSoundCard *cardIns = (struct AlsaSoundCard *)captureIns; + CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); + + ret = snd_pcm_get_params(cardIns->pcmHandle, &bufferSize, &periodSize); + if (ret < 0) { + AUDIO_FUNC_LOGE("Get capture params error: %{public}s.", snd_strerror(ret)); + return HDF_FAILURE; + } + + if (!cardIns->mmapFlag) { + ret = ResetCaptureParams(cardIns, SND_PCM_ACCESS_RW_INTERLEAVED); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("AudioSetParamsMmap failed!"); + return ret; + } + ret = snd_pcm_start(cardIns->pcmHandle); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_pcm_start fail. %{public}s", snd_strerror(ret)); + return HDF_FAILURE; + } + cardIns->mmapFlag = true; + } + + buffer = OsalMemCalloc(ALSA_CAP_BUFFER_SIZE); + if (buffer == NULL) { + AUDIO_FUNC_LOGE("Failed to Calloc buffer"); + return HDF_FAILURE; + } + + ret = CheckCapFrameBufferSize(handleData, &periodSize); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("CheckCapFrameBufferSize failed."); + AudioMemFree((void **)&buffer); + return ret; + } + + ret = CheckPcmStatus(cardIns->pcmHandle); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("CheckPcmStatus failed."); + AudioMemFree((void **)&buffer); + return ret; + } + + ret = CapturePcmReadi(cardIns->pcmHandle, &frames, buffer, periodSize); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("CapturePcmReadi is error!"); + AudioMemFree((void **)&buffer); + return ret; + } + + ret = CaptureDataCopy(handleData, buffer, frames); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Failed to copy data. It may be paused. Check the status!"); + AudioMemFree((void **)&buffer); + return ret; + } + AudioMemFree((void **)&buffer); + + return HDF_SUCCESS; +} + +static int32_t CaptureGetMmapPositionImpl(struct AlsaCapture *captureIns) +{ + return captureIns->soundCard.mmapFrames; +} + +static int32_t CaptureMmapReadImpl(struct AlsaCapture *captureIns, const struct AudioHwCaptureParam *handleData) +{ + int32_t ret; + char *mmapAddr; + uint32_t frameSize; + snd_pcm_sframes_t xfer; + snd_pcm_uframes_t size; + struct AlsaSoundCard *cardIns = (struct AlsaSoundCard *)captureIns; + CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); + + ret = UpdateSetParams(cardIns); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Update set params failed!"); + return ret; + } + + mmapAddr = (char *)handleData->frameCaptureMode.mmapBufDesc.memoryAddress; + if (mmapAddr == NULL) { + AUDIO_FUNC_LOGE("mmapAddr is NULL!"); + return HDF_FAILURE; + } + size = (snd_pcm_sframes_t)handleData->frameCaptureMode.mmapBufDesc.totalBufferFrames; + frameSize = handleData->frameCaptureMode.attrs.channelCount * handleData->frameCaptureMode.attrs.format; + while (size > 0) { + xfer = snd_pcm_mmap_readi(cardIns->pcmHandle, mmapAddr, size); + if (xfer < 0) { + if (xfer == -EAGAIN) { + snd_pcm_wait(cardIns->pcmHandle, AUDIO_PCM_WAIT); + continue; + } + AUDIO_FUNC_LOGE("snd_pcm_mmap_readi: %{public}s", snd_strerror(xfer)); + return HDF_FAILURE; + } + + if (xfer > 0) { + mmapAddr += xfer * frameSize; + size -= xfer; + cardIns->mmapFrames += xfer; + } + } + + return HDF_SUCCESS; +} + +static int32_t CaptureInitImpl(struct AlsaCapture* captureIns) +{ + AUDIO_FUNC_LOGE("Not yet realized"); + return HDF_SUCCESS; +} + +static int32_t CaptureSelectSceneImpl(struct AlsaCapture *captureIns, enum AudioPortPin descPins, + const struct PathDeviceInfo *deviceInfo) +{ + AUDIO_FUNC_LOGE("Not yet realized"); + return HDF_SUCCESS; +} + +static int32_t CaptureStartImpl(struct AlsaCapture *captureIns) +{ + AUDIO_FUNC_LOGE("Not yet realized"); + return HDF_SUCCESS; +} + +static int32_t CaptureStopImpl(struct AlsaCapture *captureIns) +{ + AUDIO_FUNC_LOGE("Not yet realized"); + return HDF_SUCCESS; +} + +static int32_t CaptureGetVolThresholdImpl(struct AlsaCapture *captureIns, long *volMin, long *volMax) +{ + AUDIO_FUNC_LOGE("Not yet realized"); + return HDF_SUCCESS; +} + +static int32_t CaptureGetVolumeImpl(struct AlsaCapture *captureIns, long *volume) +{ + AUDIO_FUNC_LOGE("Not yet realized"); + return HDF_SUCCESS; +} + +static int32_t CaptureSetVolumeImpl(struct AlsaCapture *captureIns, long volume) +{ + AUDIO_FUNC_LOGE("Not yet realized"); + return HDF_SUCCESS; +} + +static int32_t CaptureGetGainThresholdImpl(struct AlsaCapture *captureIns, float *gainMin, float *gainMax) +{ + AUDIO_FUNC_LOGE("Not yet realized"); + return HDF_SUCCESS; +} + +static int32_t CaptureGetGainImpl(struct AlsaCapture *captureIns, float *gain) +{ + AUDIO_FUNC_LOGE("Not yet realized"); + return HDF_SUCCESS; +} + +static int32_t CaptureSetGainImpl(struct AlsaCapture *captureIns, float gain) +{ + AUDIO_FUNC_LOGE("Not yet realized"); + return HDF_SUCCESS; +} + +static bool CaptureGetMuteImpl(struct AlsaCapture *captureIns) +{ + AUDIO_FUNC_LOGE("Not yet realized"); + return false; +} + +static int32_t CaptureSetMuteImpl(struct AlsaCapture *captureIns, bool muteFlag) +{ + AUDIO_FUNC_LOGE("Not yet realized"); + return HDF_SUCCESS; +} + +static void RegisterCaptureImpl(struct AlsaCapture *captureIns) +{ + if (captureIns == NULL) { + AUDIO_FUNC_LOGE("captureIns is NULL!"); + } + + captureIns->Init = CaptureInitImpl; + captureIns->Open = CaptureOpenImpl; + captureIns->Close = CaptureCloseImpl; + captureIns->SelectScene = CaptureSelectSceneImpl; + captureIns->Start = CaptureStartImpl; + captureIns->Stop = CaptureStopImpl; + captureIns->Read = CaptureReadImpl; + captureIns->GetMmapPosition = CaptureGetMmapPositionImpl; + captureIns->MmapRead = CaptureMmapReadImpl; + captureIns->GetVolThreshold = CaptureGetVolThresholdImpl; + captureIns->GetVolume = CaptureGetVolumeImpl; + captureIns->SetVolume = CaptureSetVolumeImpl; + captureIns->GetGainThreshold = CaptureGetGainThresholdImpl; + captureIns->GetGain = CaptureGetGainImpl; + captureIns->SetGain = CaptureSetGainImpl; + captureIns->GetMute = CaptureGetMuteImpl; + captureIns->SetMute = CaptureSetMuteImpl; +} -- Gitee From b391a58e0c501470c05987ace6da4238311e3246 Mon Sep 17 00:00:00 2001 From: xiesicong Date: Fri, 22 Sep 2023 10:14:21 +0800 Subject: [PATCH 07/14] =?UTF-8?q?=E4=BF=AE=E6=94=B9render=E5=8D=97?= =?UTF-8?q?=E5=90=91=E6=8E=A5=E5=8F=A3=E5=AE=9E=E7=8E=B0=E4=B8=BA=E6=8A=BD?= =?UTF-8?q?=E8=B1=A1=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xiesicong --- .../alsa_adapter/include/alsa_lib_render.h | 3 +- .../alsa_adapter/src/alsa_lib_render.c | 1343 +++-------------- 2 files changed, 229 insertions(+), 1117 deletions(-) diff --git a/audio/supportlibs/alsa_adapter/include/alsa_lib_render.h b/audio/supportlibs/alsa_adapter/include/alsa_lib_render.h index ffd95d7d7e..e3c84cd418 100644 --- a/audio/supportlibs/alsa_adapter/include/alsa_lib_render.h +++ b/audio/supportlibs/alsa_adapter/include/alsa_lib_render.h @@ -16,7 +16,8 @@ #ifndef ALSA_LIB_RENDER_H #define ALSA_LIB_RENDER_H -#include "alsa_lib_common.h" #include "audio_if_lib_render.h" +#include "alsa_soundcard.h" +#include "alsa_snd_render.h" #endif /* ALSA_LIB_RENDER_H */ diff --git a/audio/supportlibs/alsa_adapter/src/alsa_lib_render.c b/audio/supportlibs/alsa_adapter/src/alsa_lib_render.c index be63ca89e5..135d94c521 100644 --- a/audio/supportlibs/alsa_adapter/src/alsa_lib_render.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_lib_render.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Copyright (c) 2022 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 @@ -14,265 +14,46 @@ */ #include "alsa_lib_render.h" -#include "audio_common.h" -#include "osal_mem.h" -#include "securec.h" - -#define HDF_LOG_TAG HDF_AUDIO_HAL_LIB - -#define MAX_PERIOD_SIZE (8 * 1024) -#define MIN_PERIOD_SIZE (4 * 1024) -#define AUDIO_RENDER_RECOVER_DELAY (10 * 1000) -#define CHMAP_NAME_LENGHT_MAX 256 - -/* channel map list type */ -#define CHANNEL_MAP_TYPE_FIXED "FIXED" /* fixed channel position */ -#define CHANNEL_MAP_TYPE_VAR "VAR" /* freely swappable channel position */ -#define CHANNEL_MAP_TYPE_PAIRED "PAIRED" /* pair-wise swappable channel position */ - -static snd_pcm_uframes_t g_bufferSize = 0; -static snd_pcm_uframes_t g_periodSize = 0; -static unsigned int g_bufferTime = 500000; /* (0.5s): ring buffer length in us */ -static unsigned int g_periodTime = 100000; /* (0.1s): period time in us */ -static int g_resample = 1; /* enable alsa-lib resampling */ -static bool g_periodEvent = false; /* produce poll event after each period */ -static int g_canPause = 0; /* 0 Hardware doesn't support pause, 1 Hardware supports pause */ - -#ifdef SUPPORT_ALSA_CHMAP -static int32_t GetChannelsNameFromUser(struct AudioCardInfo *cardIns, const char *channelsName) -{ - if (channelsName == NULL) { - AUDIO_FUNC_LOGE("channelsName is NULL!"); - return HDF_ERR_INVALID_PARAM; - } - - if (cardIns->hwRenderParams.channelsName == NULL) { - cardIns->hwRenderParams.channelsName = (char *)OsalMemCalloc(CHMAP_NAME_LENGHT_MAX); - if (cardIns->hwRenderParams.channelsName == NULL) { - AUDIO_FUNC_LOGE("Failed to allocate memory!"); - return HDF_ERR_MALLOC_FAIL; - } - } - - (void)memset_s(cardIns->hwRenderParams.channelsName, CHMAP_NAME_LENGHT_MAX, 0, CHMAP_NAME_LENGHT_MAX); - int32_t ret = strncpy_s(cardIns->hwRenderParams.channelsName, CHMAP_NAME_LENGHT_MAX - 1, - channelsName, strlen(channelsName)); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("strncpy_s failed!"); - AudioMemFree((void **)&(cardIns->hwRenderParams.channelsName)); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} -#endif - -static int32_t GetHwParams(struct AudioCardInfo *cardIns, const struct AudioHwRenderParam *handleData) -{ - if (cardIns == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } - cardIns->hwRenderParams.streamType = AUDIO_RENDER_STREAM; - cardIns->hwRenderParams.channels = handleData->frameRenderMode.attrs.channelCount; - cardIns->hwRenderParams.rate = handleData->frameRenderMode.attrs.sampleRate; - cardIns->hwRenderParams.periodSize = handleData->frameRenderMode.periodSize; - cardIns->hwRenderParams.periodCount = handleData->frameRenderMode.periodCount; - cardIns->hwRenderParams.format = handleData->frameRenderMode.attrs.format; - cardIns->hwRenderParams.period = handleData->frameRenderMode.attrs.period; - cardIns->hwRenderParams.frameSize = handleData->frameRenderMode.attrs.frameSize; - cardIns->hwRenderParams.isBigEndian = handleData->frameRenderMode.attrs.isBigEndian; - cardIns->hwRenderParams.isSignedData = handleData->frameRenderMode.attrs.isSignedData; - cardIns->hwRenderParams.startThreshold = handleData->frameRenderMode.attrs.startThreshold; - cardIns->hwRenderParams.stopThreshold = handleData->frameRenderMode.attrs.stopThreshold; - cardIns->hwRenderParams.silenceThreshold = handleData->frameRenderMode.attrs.silenceThreshold; -#ifdef SUPPORT_ALSA_CHMAP - /* param 2 by handleData->frameRenderMode.attrs.channelsName, sample channelsName is "FL, FR" */ - if (GetChannelsNameFromUser(cardIns, "FL, FR") != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("GetChannelsNameFromUser failed"); - return HDF_FAILURE; - } -#endif - return HDF_SUCCESS; -} +#define HDF_LOG_TAG HDF_AUDIO_HAL_RENDER -static int32_t AudioSetMixerVolume(snd_mixer_elem_t *pcmElemen, long vol) +int32_t AudioCtlRenderSetVolume( + const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { int32_t ret; - - if (pcmElemen == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } - - /* Judge whether it is mono or stereo */ - if (snd_mixer_selem_is_playback_mono(pcmElemen)) { - ret = snd_mixer_selem_set_playback_volume(pcmElemen, SND_MIXER_SCHN_FRONT_LEFT, vol); - if (ret < 0) { - AUDIO_FUNC_LOGE("AudioSetMixerVolume failed: %{public}s.", snd_strerror(ret)); - return HDF_FAILURE; - } - } else { - ret = snd_mixer_selem_set_playback_volume_all(pcmElemen, vol); - if (ret < 0) { - AUDIO_FUNC_LOGE("AudioSetMixerVolume failed: %{public}s.", snd_strerror(ret)); - return HDF_FAILURE; - } - } - - return HDF_SUCCESS; -} - -static int32_t AudioSetVolumeSub(snd_mixer_elem_t *CtlVolume, long vol) -{ - if (CtlVolume == NULL) { - AUDIO_FUNC_LOGE("CtlVolume is NULL!"); - return HDF_FAILURE; - } - - int32_t ret = AudioSetMixerVolume(CtlVolume, vol); - if (ret < 0) { - AUDIO_FUNC_LOGE("AudioSetMixerVolume fail!"); - return ret; - } - return HDF_SUCCESS; -} - -int32_t AudioCtlRenderSetVolume(const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) -{ long vol; - int32_t ret; - int32_t index; - struct AudioCardInfo *cardIns = NULL; - - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Invalid parameters!!"); - return HDF_FAILURE; - } + struct AlsaRender *renderIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - const char *adapterName = handleData->renderMode.hwInfo.adapterName; - cardIns = GetCardIns(adapterName); - if (cardIns == NULL) { - AUDIO_FUNC_LOGE("Get card instance failed!"); - return HDF_FAILURE; - } + renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); vol = (long)handleData->renderMode.ctlParam.volume; - if (strncmp(adapterName, PRIMARY, strlen(PRIMARY)) == 0) { - if (cardIns->volElemList == NULL) { - AUDIO_FUNC_LOGE("primaryVolElems is NULL!"); - return HDF_FAILURE; - } - for (index = 0; index < (int32_t)cardIns->volElemCount; index++) { - ret = AudioSetVolumeSub(cardIns->volElemList[index].elem, vol); - if (ret < 0) { - AUDIO_FUNC_LOGE("primary set volume failed!"); - return ret; - } - } - } else if (strncmp(adapterName, USB, strlen(USB)) == 0) { - ret = AudioSetVolumeSub(cardIns->usbCtlVolume, vol); - if (ret < 0) { - AUDIO_FUNC_LOGE("usb set volume failed!"); - return ret; - } - } else if (strncmp(adapterName, HDMI, strlen(HDMI)) == 0) { - AUDIO_FUNC_LOGI("HDMI no control is present!"); - return HDF_ERR_NOT_SUPPORT; - } else { - AUDIO_FUNC_LOGE("This type of sound card: %{public}s is not supported temporarily!", adapterName); - return HDF_ERR_NOT_SUPPORT; - } - - return HDF_SUCCESS; -} - -static int32_t MixerGetVolume(snd_mixer_t *mixer, snd_mixer_elem_t *pcmElemen, long *vol) -{ - long volLeft = MIN_VOLUME; - long volRight = MIN_VOLUME; - - if (mixer == NULL || pcmElemen == NULL || vol == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } - /* Handling events */ - int32_t ret = snd_mixer_handle_events(mixer); - if (ret < 0) { - AUDIO_FUNC_LOGE("snd_mixer_handle_events fail!"); - return HDF_FAILURE; - } - - /* Left channel */ - ret = snd_mixer_selem_get_playback_volume(pcmElemen, SND_MIXER_SCHN_FRONT_LEFT, &volLeft); - if (ret < 0) { - AUDIO_FUNC_LOGE("Get left channel fail!"); - return HDF_FAILURE; - } - /* right channel */ - ret = snd_mixer_selem_get_playback_volume(pcmElemen, SND_MIXER_SCHN_FRONT_RIGHT, &volRight); - if (ret < 0) { - AUDIO_FUNC_LOGE("Get right channel fail!"); + ret = renderIns->SetVolume(renderIns, vol); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Render SetVolume fail!"); return HDF_FAILURE; } - *vol = (volLeft + volRight) / 2; return HDF_SUCCESS; } -static int32_t AudioRenderGetVolumeSub(struct AudioCardInfo *cardIns, long *vol, const char *adapterName) -{ - int32_t ret; - - if (cardIns == NULL || cardIns->mixer == NULL || vol == NULL || adapterName == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } - if (strncmp(adapterName, PRIMARY, strlen(PRIMARY)) == 0) { - if (cardIns->volElemList == NULL || cardIns->volElemList[0].elem == NULL) { - AUDIO_FUNC_LOGE("ctrlVolumeList is NULL!"); - return HDF_FAILURE; - } - ret = MixerGetVolume(cardIns->mixer, cardIns->volElemList[0].elem, vol); - } else if (strncmp(adapterName, USB, strlen(USB)) == 0) { - if (cardIns->usbCtlVolume == NULL) { - AUDIO_FUNC_LOGE("usbCtlVolume is NULL!"); - return HDF_FAILURE; - } - ret = MixerGetVolume(cardIns->mixer, cardIns->usbCtlVolume, vol); - } else if (strncmp(adapterName, HDMI, strlen(HDMI)) == 0) { - AUDIO_FUNC_LOGI("HDMI no control is present."); - return HDF_ERR_NOT_SUPPORT; - } else { - AUDIO_FUNC_LOGE("This type of sound card: %{public}s is not supported temporarily!", adapterName); - return HDF_ERR_NOT_SUPPORT; - } - - return ret; -} - -int32_t AudioCtlRenderGetVolume(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderGetVolume( + const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) { int32_t ret; long vol; - struct AudioCardInfo *cardIns = NULL; + struct AlsaRender *renderIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } + renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); - const char *adapterName = handleData->renderMode.hwInfo.adapterName; - cardIns = GetCardIns(adapterName); - ret = AudioRenderGetVolumeSub(cardIns, &vol, adapterName); + ret = renderIns->GetVolume(renderIns, &vol); if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("AudioRenderGetVolumeSub failed!"); - return ret; + AUDIO_FUNC_LOGE("Render GetVolume failed!"); + return HDF_FAILURE; } - handleData->renderMode.ctlParam.volume = (float)vol; return HDF_SUCCESS; @@ -281,168 +62,93 @@ int32_t AudioCtlRenderGetVolume(const struct DevHandle *handle, int cmdId, struc int32_t AudioCtlRenderSetPauseStu( const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); + int32_t ret; + struct AlsaRender *renderIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); + + renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); + + ret = SndPcmPause(&renderIns->soundCard, handleData->renderMode.ctlParam.pause); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Render set pause failed!"); return HDF_FAILURE; } - /* The hardware does not support pause/resume, - * so a success message is returned. - * The software processing scheme is implemented - * in AudioOutputRenderWrite interface. - */ return HDF_SUCCESS; } -static int32_t RenderSetMuteStuSub(snd_mixer_elem_t *pcmElemen, int32_t muteState) +int32_t AudioCtlRenderSetMuteStu( + const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { int32_t ret; + struct AlsaRender *renderIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - if (pcmElemen == NULL) { - AUDIO_FUNC_LOGE("cardIns is NULL!"); - return HDF_FAILURE; - } + renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); - ret = snd_mixer_selem_has_playback_switch(pcmElemen); - if (ret == 1) { // 1: Controlled switch - ret = snd_mixer_selem_set_playback_switch_all(pcmElemen, muteState); - if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to play mixer switch "); - return HDF_FAILURE; - } - } else { // 0: no control - AUDIO_FUNC_LOGE("it's no control is present"); + ret = renderIns->SetMute(renderIns, handleData->renderMode.ctlParam.mute); + if (ret < 0) { + AUDIO_FUNC_LOGE("Render SetMute failed!"); return HDF_FAILURE; } return HDF_SUCCESS; } -static int32_t AudioPrimarySetMuteState( - struct AudioCardInfo *cardIns, int32_t muteState, const char *adapterName, float volume) +int32_t AudioCtlRenderGetMuteStu( + const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) { - long vol; - long alsaVol; - float volRangeMin = 0.0; - float volRangeMax = 100.0; - if (cardIns == NULL || cardIns->volElemList == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } - int32_t ret = AudioRenderGetVolumeSub(cardIns, &vol, adapterName); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("AudioRenderGetVolumeSub error!"); - return HDF_FAILURE; - } + struct AlsaRender *renderIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - if (muteState == false) { - alsaVol = 0; /* 0 for mute */ - cardIns->tempVolume = (float)vol; - } else { - if (volume > volRangeMin && volume <= volRangeMax) { - alsaVol = (long)volume; - } else { - alsaVol = (long)cardIns->tempVolume; - } - } - - for (int i = 0; i < (int32_t)cardIns->volElemCount; i++) { - if (cardIns->volElemList[i].elem != NULL) { - ret = AudioSetMixerVolume(cardIns->volElemList[i].elem, alsaVol); - if (ret < 0) { - AUDIO_FUNC_LOGE("AudioSetMixerVolume left fail!"); - return HDF_FAILURE; - } - } - } + renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); + handleData->renderMode.ctlParam.mute = renderIns->GetMute(renderIns); return HDF_SUCCESS; } -int32_t AudioCtlRenderSetMuteStu(const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderSetGainStu( + const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { int32_t ret; - int32_t muteState; + float gainValue; + struct AlsaRender *renderIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } - - const char *adapterName = handleData->renderMode.hwInfo.adapterName; - struct AudioCardInfo *cardIns = GetCardIns(adapterName); - if (cardIns == NULL) { - AUDIO_FUNC_LOGE("GetCardIns error!!!"); - return HDF_FAILURE; - } - - muteState = cardIns->renderMuteValue; - if (strncmp(adapterName, PRIMARY, strlen(PRIMARY)) == 0) { - ret = AudioPrimarySetMuteState(cardIns, muteState, adapterName, handleData->renderMode.ctlParam.volume); - if (ret < 0) { - AUDIO_FUNC_LOGE("Render primary sound card SetMute failed!"); - return HDF_FAILURE; - } - } - - if (strncmp(adapterName, USB, strlen(USB)) == 0) { - if (cardIns->usbCtlVolume == NULL) { - AUDIO_FUNC_LOGE("usbCtlVolume is NULL!"); - return HDF_FAILURE; - } - ret = RenderSetMuteStuSub(cardIns->usbCtlVolume, muteState); - if (ret < 0) { - AUDIO_FUNC_LOGE("Render usb sound card SetMute failed!"); - return HDF_FAILURE; - } - } - cardIns->renderMuteValue = (int32_t)handleData->renderMode.ctlParam.mute; - - return HDF_SUCCESS; -} - -int32_t AudioCtlRenderGetMuteStu(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) -{ - struct AudioCardInfo *cardInstance = NULL; + renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } - - const char *adapterName = handleData->renderMode.hwInfo.adapterName; - cardInstance = GetCardIns(adapterName); - if (cardInstance == NULL) { - AUDIO_FUNC_LOGE("cardInstance is NULL!"); + gainValue = handleData->renderMode.ctlParam.audioGain.gain; + ret = renderIns->SetGain(renderIns, gainValue); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Render set gain failed!"); return HDF_FAILURE; } - handleData->renderMode.ctlParam.mute = (bool)cardInstance->renderMuteValue; return HDF_SUCCESS; } -int32_t AudioCtlRenderSetGainStu(const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderGetGainStu( + const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) { - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } + int32_t ret; + float gainValue; + struct AlsaRender *renderIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - return HDF_SUCCESS; -} + renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); -int32_t AudioCtlRenderGetGainStu(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) -{ - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); + ret = renderIns->GetGain(renderIns, &gainValue); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Render get gain failed!"); return HDF_FAILURE; } - + handleData->renderMode.ctlParam.audioGain.gain = gainValue; + return HDF_SUCCESS; } @@ -450,95 +156,66 @@ int32_t AudioCtlRenderSceneSelect( const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { int32_t ret; - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Invalid parameters!"); + enum AudioPortPin descPins; + const struct PathDeviceInfo *deviceInfo; + struct AlsaRender *renderIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); + + renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); + + descPins = handleData->renderMode.hwInfo.deviceDescript.pins; + deviceInfo = &handleData->renderMode.hwInfo.pathSelect.deviceInfo; + ret = renderIns->SelectScene(renderIns, descPins, deviceInfo); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Render select scene pin: (0x%{public}x) failed!",descPins); return HDF_FAILURE; } - if (strcmp(handleData->renderMode.hwInfo.adapterName, USB) == 0 || - strcmp(handleData->renderMode.hwInfo.adapterName, HDMI) == 0) { - return HDF_SUCCESS; - } - ret = EnableAudioRenderRoute(handleData); - if (ret < 0) { - AUDIO_FUNC_LOGE("EnableAudioRoute failed!"); - return ret; - } + AUDIO_FUNC_LOGD("Render scene select pin: (0x%{public}x) success",descPins); return HDF_SUCCESS; } int32_t AudioCtlRenderSceneGetGainThreshold( const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) { - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } + int32_t ret; + float gainMin = 0.0; + float gainMax = 1.0; + struct AlsaRender *renderIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - return HDF_SUCCESS; -} + renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); -static int32_t MixerGetVolumeRange(snd_mixer_elem_t *ctlElem, long *volMin, long *volMax) -{ - if (ctlElem == NULL || volMin == NULL || volMax == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } - - int32_t ret = snd_mixer_selem_get_playback_volume_range(ctlElem, volMin, volMax); - if (ret < 0) { - AUDIO_FUNC_LOGE("Failed to get playback volume range: %{public}s", snd_strerror(ret)); + ret = renderIns->GetGainThreshold(renderIns, &gainMin, &gainMax); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Render get gain threshold failed"); return HDF_FAILURE; } + handleData->renderMode.ctlParam.audioGain.gainMin = gainMin; + handleData->renderMode.ctlParam.audioGain.gainMax = gainMax; return HDF_SUCCESS; } -int32_t AudioCtlRenderGetVolThreshold(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderGetVolThreshold( + const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) { int32_t ret; long volMin = MIN_VOLUME; long volMax = MIN_VOLUME; - struct AudioCardInfo *cardIns = NULL; - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } + struct AlsaRender *renderIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - const char *adapterName = handleData->renderMode.hwInfo.adapterName; - cardIns = GetCardIns(adapterName); - if (cardIns == NULL) { - AUDIO_FUNC_LOGE("cardIns is NULL!"); - return HDF_FAILURE; - } - /* use simple mixer control */ - if (strncmp(adapterName, PRIMARY, strlen(PRIMARY)) == 0) { - if (cardIns->volElemList[0].elem == NULL) { - AUDIO_FUNC_LOGE("simple mixer control is NULL."); - return HDF_FAILURE; - } - ret = MixerGetVolumeRange(cardIns->volElemList[0].elem, &volMin, &volMax); - if (ret < 0) { - AUDIO_FUNC_LOGE("Get playback volume range fail."); - return HDF_FAILURE; - } - } else if (strncmp(adapterName, USB, strlen(USB)) == 0) { - ret = MixerGetVolumeRange(cardIns->usbCtlVolume, &volMin, &volMax); - if (ret < 0) { - AUDIO_FUNC_LOGE("Get playback volume range fail."); - return HDF_FAILURE; - } - } else if (strncmp(adapterName, HDMI, strlen(HDMI)) == 0) { - AUDIO_FUNC_LOGI("HDMI not ctlElement."); - return HDF_SUCCESS; - } else { - AUDIO_FUNC_LOGE("This type of sound card: %{public}s is not supported temporarily!", adapterName); + renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); + + ret = renderIns->GetVolThreshold(renderIns, &volMin, &volMax); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Render get volume threshold failed!"); return HDF_FAILURE; } - handleData->renderMode.ctlParam.volThreshold.volMin = (int)volMin; handleData->renderMode.ctlParam.volThreshold.volMax = (int)volMax; @@ -548,37 +225,49 @@ int32_t AudioCtlRenderGetVolThreshold(const struct DevHandle *handle, int cmdId, int32_t AudioCtlRenderSetChannelMode( const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); + int32_t ret; + enum AudioChannelMode mode; + struct AlsaRender *renderIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); + + renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); + + mode = handleData->frameRenderMode.mode; + ret = renderIns->SetChannelMode(renderIns, mode); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Render set channel mode failed!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlRenderGetChannelMode(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioCtlRenderGetChannelMode( + const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) { - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); + int32_t ret; + enum AudioChannelMode mode; + struct AlsaRender *renderIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); + + renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); + + ret = renderIns->GetChannelMode(renderIns, &mode); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Render get channel mode failed!"); return HDF_FAILURE; } - + handleData->frameRenderMode.mode = mode; + return HDF_SUCCESS; } -int32_t AudioInterfaceLibCtlRender(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioInterfaceLibCtlRender( + const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) { - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } - - if (cmdId < AUDIODRV_CTL_IOCTL_ELEM_INFO || cmdId > AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ) { - AUDIO_FUNC_LOGE("cmdId Not Supported!"); - return HDF_FAILURE; - } + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); switch (cmdId) { case AUDIODRV_CTL_IOCTL_ELEM_READ: @@ -611,696 +300,153 @@ int32_t AudioInterfaceLibCtlRender(const struct DevHandle *handle, int cmdId, st return HDF_FAILURE; } -static int32_t SetHWParamsSub( - snd_pcm_t *handle, snd_pcm_hw_params_t *params, struct AudioPcmHwParams hwParams, snd_pcm_access_t access) -{ - int32_t ret; - snd_pcm_format_t pcmFormat = SND_PCM_FORMAT_S16_LE; - - if (handle == NULL || params == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } - - /* set hardware resampling */ - ret = snd_pcm_hw_params_set_rate_resample(handle, params, g_resample); - if (ret < 0) { - AUDIO_FUNC_LOGE("Resampling setup failed for playback: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - /* set the interleaved read/write format */ - ret = snd_pcm_hw_params_set_access(handle, params, access); - if (ret < 0) { - AUDIO_FUNC_LOGE("Access type not available for playback: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - ret = CheckParaFormat(hwParams, &pcmFormat); - if (ret < 0) { - AUDIO_FUNC_LOGE("CheckParaFormat error."); - return HDF_FAILURE; - } - /* set the sample format */ - ret = snd_pcm_hw_params_set_format(handle, params, pcmFormat); - if (ret < 0) { - AUDIO_FUNC_LOGE( - "Sample format not available for playback: %{public}s, format: %{public}d.", snd_strerror(ret), pcmFormat); - return HDF_FAILURE; - } - /* set the count of channels */ - ret = snd_pcm_hw_params_set_channels(handle, params, hwParams.channels); - if (ret < 0) { - AUDIO_FUNC_LOGE("Channels count (%{public}u) not available for playbacks: %{public}s", hwParams.channels, - snd_strerror(ret)); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -static int32_t SetHWRate(snd_pcm_t *handle, snd_pcm_hw_params_t *params, uint32_t *rate) -{ - int32_t ret; - uint32_t rRate; - int dir = 0; /* dir Value range (-1,0,1) */ - - if (handle == NULL || params == NULL || rate == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } - - /* set the stream rate */ - rRate = *rate; - ret = snd_pcm_hw_params_set_rate_near(handle, params, &rRate, &dir); - if (ret < 0) { - AUDIO_FUNC_LOGE("Rate %{public}uHz not available for playback: %{public}s.", *rate, snd_strerror(ret)); - return HDF_FAILURE; - } - - if (rRate != *rate) { - ret = snd_pcm_hw_params_set_rate_near(handle, params, &rRate, &dir); - if (ret < 0) { - AUDIO_FUNC_LOGE("Rate %{public}uHz not available for playback: %{public}s.", *rate, snd_strerror(ret)); - return HDF_FAILURE; - } - } - /* Update to hardware supported rate */ - *rate = rRate; - g_canPause = snd_pcm_hw_params_can_pause(params); - - return HDF_SUCCESS; -} -static int32_t SetHWParams( - snd_pcm_t *handle, snd_pcm_hw_params_t *params, struct AudioPcmHwParams hwParams, snd_pcm_access_t access) -{ - int ret; - int dir = 0; /* dir Value range (-1,0,1) */ - - if (handle == NULL || params == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } - - snd_pcm_uframes_t size; - ret = snd_pcm_hw_params_any(handle, params); // choose all parameters - if (ret < 0) { - AUDIO_FUNC_LOGE("No configurations available: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - if (SetHWParamsSub(handle, params, hwParams, access) < 0) { - AUDIO_FUNC_LOGE("SetHWParamsSub failed!"); - return HDF_FAILURE; - } - if (SetHWRate(handle, params, &(hwParams.rate)) < 0) { - AUDIO_FUNC_LOGE("SetHWRate failed!"); - return HDF_FAILURE; - } - ret = snd_pcm_hw_params_set_buffer_time_near(handle, params, &g_bufferTime, &dir); - if (ret < 0) { - AUDIO_FUNC_LOGE("Set buffer time %{public}u failed: %{public}s", g_bufferTime, snd_strerror(ret)); - return HDF_FAILURE; - } - ret = snd_pcm_hw_params_get_buffer_size(params, &size); - if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to get buffer size for playback: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - g_bufferSize = size; - ret = snd_pcm_hw_params_set_period_time_near(handle, params, &g_periodTime, &dir); - if (ret < 0) { - AUDIO_FUNC_LOGE("Set period time %{public}u failed: %{public}s", g_bufferTime, snd_strerror(ret)); - return HDF_FAILURE; - } - ret = snd_pcm_hw_params_get_period_size(params, &size, &dir); - if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to get period size for playback: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - g_periodSize = size; - ret = snd_pcm_hw_params(handle, params); // write the parameters to device - if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to set hw params for playback: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -static int32_t SetSWParams(snd_pcm_t *handle, snd_pcm_sw_params_t *swparams) -{ - int32_t ret; - int32_t val = 1; /* val 0 = disable period event, 1 = enable period event */ - - if (handle == NULL || swparams == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } - - /* get the current swparams */ - ret = snd_pcm_sw_params_current(handle, swparams); - if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to determine current swparams for playback: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - /* start the transfer when the buffer is almost full: */ - /* (buffer_size / avail_min) * avail_min */ - if (g_periodSize == 0) { - AUDIO_FUNC_LOGE("g_periodSize=0"); - return HDF_FAILURE; - } - ret = snd_pcm_sw_params_set_start_threshold(handle, swparams, (g_bufferSize / g_periodSize) * g_periodSize); - if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to set start threshold mode for playback: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - /* allow the transfer when at least period_size samples can be processed */ - /* or disable this mechanism when period event is enabled (aka interrupt like style processing) */ - ret = snd_pcm_sw_params_set_avail_min(handle, swparams, g_periodEvent ? g_bufferSize : g_periodSize); - if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to set avail min for playback: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - - /* enable period events when requested */ - if (g_periodEvent) { - ret = snd_pcm_sw_params_set_period_event(handle, swparams, val); - if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to set period event: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - } - - /* write the parameters to the playback device */ - ret = snd_pcm_sw_params(handle, swparams); - if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to set sw params for playback: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -static int32_t AudioResetParams(snd_pcm_t *handle, struct AudioPcmHwParams audioHwParams, snd_pcm_access_t access) -{ - int32_t ret; - snd_pcm_hw_params_t *hwParams = NULL; - snd_pcm_sw_params_t *swParams = NULL; - - if (handle == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } - - snd_pcm_hw_params_alloca(&hwParams); - snd_pcm_sw_params_alloca(&swParams); - ret = SetHWParams(handle, hwParams, audioHwParams, access); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("Setting of hwparams failed."); - return ret; - } - - ret = SetSWParams(handle, swParams); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("Setting of swparams failed."); - return ret; - } - - return HDF_SUCCESS; -} - -#ifdef SUPPORT_ALSA_CHMAP -static void PrintChannels(const snd_pcm_chmap_t *map) -{ - char tmp[CHMAP_NAME_LENGHT_MAX] = {0}; - if (snd_pcm_chmap_print(map, sizeof(tmp), tmp) > 0) { - HDF_LOGI("print_channels: %{public}s.", tmp); - } -} - -static int32_t QueryChmaps(snd_pcm_t *pcm) -{ - snd_pcm_chmap_query_t **pChmap = NULL; - snd_pcm_chmap_query_t *chmap = NULL; - const char *champType = NULL; - snd_pcm_chmap_query_t **hwChmap = snd_pcm_query_chmaps(pcm); - if (hwChmap == NULL) { - AUDIO_FUNC_LOGE("This sound card has no chmap component, cannot query maps."); - return HDF_FAILURE; - } - - for (pChmap = hwChmap; (chmap = *pChmap) != NULL; pChmap++) { - champType = snd_pcm_chmap_type_name(chmap->type); - HDF_LOGI("Channel Type = %{public}s, Channels = %{public}d.", champType, chmap->map.channels); - if (strncmp(champType, CHANNEL_MAP_TYPE_FIXED, strlen(CHANNEL_MAP_TYPE_FIXED)) == 0) { - HDF_LOGW("Fixed channel type does not support modification temporarily!"); - } - PrintChannels(&chmap->map); - } - - snd_pcm_free_chmaps(hwChmap); - return HDF_SUCCESS; -} - -static int32_t SetChmap(snd_pcm_t *pcm, struct AudioPcmHwParams *hwRenderParams) -{ - if (hwRenderParams == NULL || hwRenderParams->channelsName == NULL) { - AUDIO_FUNC_LOGE("Parameter is NULL!"); - return HDF_FAILURE; - } - - snd_pcm_chmap_t *chmap = snd_pcm_chmap_parse_string(hwRenderParams->channelsName); - if (chmap == NULL) { - AUDIO_FUNC_LOGE("parse chmap error!"); - return HDF_FAILURE; - } - - if (snd_pcm_set_chmap(pcm, chmap) < 0) { - AUDIO_FUNC_LOGE("Cannot set chmap!"); - free((void *)chmap); - return HDF_ERR_NOT_SUPPORT; - } - free((void *)chmap); - - chmap = snd_pcm_get_chmap(pcm); - if (chmap == NULL) { - AUDIO_FUNC_LOGE("Cannot get chmap!"); - return HDF_ERR_NOT_SUPPORT; - } - - PrintChannels(chmap); - free((void *)chmap); - return HDF_SUCCESS; -} - -static int32_t AudioOutputRenderHwParamsChmaps(struct AudioCardInfo *cardIns) -{ - if (QueryChmaps(cardIns->renderPcmHandle) != HDF_SUCCESS) { - AUDIO_FUNC_LOGW("QueryChmaps failed."); - return HDF_SUCCESS; - } - if (SetChmap(cardIns->renderPcmHandle, &cardIns->hwRenderParams) != HDF_SUCCESS) { - AUDIO_FUNC_LOGW("SetChmap failed."); - } - - return HDF_SUCCESS; -} -#endif - int32_t AudioOutputRenderHwParams( const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { int32_t ret; - struct AudioCardInfo *cardIns = NULL; - snd_pcm_hw_params_t *hwParams = NULL; - snd_pcm_sw_params_t *swParams = NULL; + struct AlsaRender *renderIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } + renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns->soundCard.pcmHandle); - cardIns = GetCardIns(handleData->renderMode.hwInfo.adapterName); - if (cardIns == NULL) { - AUDIO_FUNC_LOGE("cardIns is NULL!"); - return HDF_FAILURE; - } - if (cardIns->renderPcmHandle == NULL) { - AUDIO_FUNC_LOGE("pcm handle is null!"); - return HDF_FAILURE; - } - ret = (int32_t)snd_pcm_state(cardIns->renderPcmHandle); - if (ret >= SND_PCM_STATE_RUNNING) { + if (SndGetRunState(&renderIns->soundCard) >= SND_PCM_STATE_RUNNING) { AUDIO_FUNC_LOGE("Unable to set parameters during playback!"); return HDF_FAILURE; } - ret = GetHwParams(cardIns, handleData); - if (ret < 0) { - AUDIO_FUNC_LOGE("GetHwParams error."); - return HDF_FAILURE; - } - - snd_pcm_hw_params_alloca(&hwParams); - snd_pcm_sw_params_alloca(&swParams); - ret = SetHWParams(cardIns->renderPcmHandle, hwParams, cardIns->hwRenderParams, SND_PCM_ACCESS_RW_INTERLEAVED); - if (ret < 0) { - AUDIO_FUNC_LOGE("Setting of hwparams failed."); + ret = RenderSetParams(renderIns, handleData); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Render set parameters failed!"); return HDF_FAILURE; } - ret = SetSWParams(cardIns->renderPcmHandle, swParams); - if (ret < 0) { - AUDIO_FUNC_LOGE("Setting of swparams failed."); - return HDF_FAILURE; - } -#ifdef SUPPORT_ALSA_CHMAP - return AudioOutputRenderHwParamsChmaps(cardIns); -#endif + AUDIO_FUNC_LOGI("Render set parameters success."); return HDF_SUCCESS; } -static int32_t AudioRenderWriteFrameSub(snd_pcm_t *pcm, char *dataBuf, size_t bufSize) +/* + * brief: Opens a PCM + * param mode Open mode (see #SND_PCM_NONBLOCK, #SND_PCM_ASYNC) + */ +int32_t AudioOutputRenderOpen( + const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { int32_t ret; - long frames; - int32_t tryNum = AUDIO_ALSALIB_RETYR; - - if (pcm == NULL || dataBuf == NULL || bufSize == 0) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } + struct AlsaRender * renderIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - do { - /* Write interleaved frames to a PCM. */ - frames = snd_pcm_writei(pcm, dataBuf, bufSize); - if (frames > 0) { - return HDF_SUCCESS; - } - - if (frames == -EBADFD) { - /* not #SND_PCM_STATE_PREPARED or #SND_PCM_STATE_RUNNING */ - AUDIO_FUNC_LOGE("render PCM is not in the right state: %{public}s", snd_strerror(frames)); - ret = snd_pcm_prepare(pcm); - if (ret < 0) { - AUDIO_FUNC_LOGE("render snd_pcm_prepare fail: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - } else { - /* -ESTRPIPE: a suspend event occurred, - * stream is suspended and waiting for an application recovery. - * -EPIPE: an underrun occurred. - */ - ret = snd_pcm_recover(pcm, frames, 0); // 0 for open render recover log. - if (ret < 0) { - AUDIO_FUNC_LOGE("snd_pcm_writei failed: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - usleep(AUDIO_RENDER_RECOVER_DELAY); - } - tryNum--; - } while (tryNum > 0); + renderIns = RenderCreateInstance(handleData->renderMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); - return HDF_SUCCESS; -} - -static int32_t AudioRenderWriteFrame(snd_pcm_t *pcm, const struct AudioHwRenderParam *handleData) -{ - int32_t ret; - size_t sbufFrameSize; - snd_pcm_state_t state; - - if (pcm == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); + ret = renderIns->Open(renderIns); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Render open pcm failed!"); return HDF_FAILURE; } - /* Check whether the PCM status is normal */ - state = snd_pcm_state(pcm); - if (state == SND_PCM_STATE_SETUP) { - ret = snd_pcm_prepare(pcm); - if (ret < 0) { - AUDIO_FUNC_LOGE("snd_pcm_prepare fail: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - } - - sbufFrameSize = (size_t)handleData->frameRenderMode.bufferFrameSize; - ret = AudioRenderWriteFrameSub(pcm, handleData->frameRenderMode.buffer, sbufFrameSize); + ret = renderIns->Init(renderIns); if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("AudioRenderWriteFrameSub failed!"); + AUDIO_FUNC_LOGE("Render init failed!"); return HDF_FAILURE; } + AUDIO_FUNC_LOGI("Render open success."); return HDF_SUCCESS; } -int32_t AudioOutputRenderWrite(const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) +int32_t AudioOutputRenderWrite( + const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { int32_t ret; - struct AudioCardInfo *cardIns = NULL; - - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } - - if (g_canPause == 0) { /* Hardware does not support pause, enable soft solution */ - if (handleData->renderMode.ctlParam.pause) { - AUDIO_FUNC_LOGE("Currently in pause, please check!"); - return HDF_FAILURE; - } - } + struct AlsaRender *renderIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - const char *adapterName = handleData->renderMode.hwInfo.adapterName; - cardIns = GetCardIns(adapterName); - if (cardIns == NULL) { - AUDIO_FUNC_LOGE("cardIns is NULL!"); - return HDF_FAILURE; - } - if (!cardIns->renderMmapFlag) { - ret = AudioResetParams(cardIns->renderPcmHandle, cardIns->hwRenderParams, SND_PCM_ACCESS_RW_INTERLEAVED); - if (ret < 0) { - AUDIO_FUNC_LOGE("AudioSetParamsMmap failed!"); - return HDF_FAILURE; - } - cardIns->renderMmapFlag = true; - } + renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); - ret = AudioRenderWriteFrame(cardIns->renderPcmHandle, handleData); + ret = renderIns->Write(renderIns, handleData); if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("AudioRenderWriteFrame failed!"); + AUDIO_FUNC_LOGE("Render wirte frame failed!"); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioOutputRenderPrepare(const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) +int32_t AudioOutputRenderPrepare( + const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { int32_t ret; - struct AudioCardInfo *sndCardIns = NULL; - - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } - - const char *sndCardName = handleData->renderMode.hwInfo.adapterName; - sndCardIns = GetCardIns(sndCardName); - if (sndCardIns == NULL) { - AUDIO_FUNC_LOGE("sndCardIns is NULL!"); - return HDF_FAILURE; - } + struct AlsaRender *renderIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - ret = snd_pcm_prepare(sndCardIns->renderPcmHandle); + renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); + + ret = SndPcmPrepare(&renderIns->soundCard); if (ret < 0) { - AUDIO_FUNC_LOGE("snd_pcm_prepare fail: %{public}s", snd_strerror(ret)); + AUDIO_FUNC_LOGE("Render pcm prepare failed"); return HDF_FAILURE; } return HDF_SUCCESS; } -/* - * brief: Opens a PCM - * param mode Open mode (see #SND_PCM_NONBLOCK, #SND_PCM_ASYNC) - */ -int32_t AudioOutputRenderOpen(const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) +int32_t AudioOutputRenderStart( + const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { int32_t ret; - struct AudioCardInfo *cardIns = NULL; + struct AlsaRender *renderIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("The parameter is empty."); - return HDF_FAILURE; - } - - const char *adapterName = handleData->renderMode.hwInfo.adapterName; - cardIns = AudioGetCardInstance(adapterName); - if (cardIns == NULL) { - AUDIO_FUNC_LOGE("AudioRenderGetCardIns failed."); - (void)DestroyCardList(); - return HDF_FAILURE; - } + renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); - ret = AudioGetCardInfo(cardIns, adapterName, SND_PCM_STREAM_PLAYBACK); + ret = renderIns->Start(renderIns); if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("AudioGetCardInfo failed."); - CheckCardStatus(cardIns); - (void)DestroyCardList(); - return HDF_FAILURE; - } - - if (cardIns->renderPcmHandle != NULL) { - AUDIO_FUNC_LOGE("Resource busy!!"); - CheckCardStatus(cardIns); - (void)DestroyCardList(); - return HDF_ERR_DEVICE_BUSY; - } - - ret = snd_pcm_open(&cardIns->renderPcmHandle, cardIns->devName, SND_PCM_STREAM_PLAYBACK, 0); - if (ret < 0) { - AUDIO_FUNC_LOGE("AudioOutputRenderOpen fail: %{public}s!", snd_strerror(ret)); - CheckCardStatus(cardIns); - (void)DestroyCardList(); - return HDF_FAILURE; - } - - InitSound(&cardIns->mixer, cardIns->ctrlName); - ret = InitMixerCtlElement(adapterName, cardIns, cardIns->mixer, SND_PCM_STREAM_PLAYBACK); - if (ret < 0) { - AUDIO_FUNC_LOGE("InitMixerCtlElement failed!"); - (void)CloseMixerHandle(cardIns->mixer); - CheckCardStatus(cardIns); - (void)DestroyCardList(); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -int32_t AudioOutputRenderStop(const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) -{ - int32_t ret; - struct AudioCardInfo *cardIns = NULL; - - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("The parameter is empty."); - return HDF_FAILURE; - } - - const char *adapterName = handleData->renderMode.hwInfo.adapterName; - cardIns = GetCardIns(adapterName); - if (cardIns == NULL || cardIns->renderPcmHandle == NULL) { - AUDIO_FUNC_LOGE("cardIns is NULL!"); - return HDF_FAILURE; - } - /**For playback, snd_ pcm_ Drain will wait for all pending data frames to be broadcast before turning off PCM */ - ret = snd_pcm_drain(cardIns->renderPcmHandle); - if (ret < 0) { - AUDIO_FUNC_LOGE("AudioOutputRenderStop fail!"); - return HDF_FAILURE; + AUDIO_FUNC_LOGE("Render start failed!"); + return ret; } + AUDIO_FUNC_LOGI("Render start success."); return HDF_SUCCESS; } -int32_t AudioOutputRenderClose(const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) +int32_t AudioOutputRenderStop( + const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { int32_t ret; - struct AudioCardInfo *alsaCardIns = NULL; - - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("parameter error!!"); - return HDF_FAILURE; - } + struct AlsaRender *renderIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - const char *adapterName = handleData->renderMode.hwInfo.adapterName; - /* Gets the specified sound card instance */ - alsaCardIns = GetCardIns(adapterName); - if (alsaCardIns == NULL) { - AUDIO_FUNC_LOGE("cardInstance is empty pointer!"); - return HDF_FAILURE; - } - AudioMemFree((void **)&alsaCardIns->volElemList); -#ifdef SUPPORT_ALSA_CHMAP - AudioMemFree((void **)&alsaCardIns->hwRenderParams.channelsName); -#endif - if (alsaCardIns->renderPcmHandle != NULL) { - ret = snd_pcm_close(alsaCardIns->renderPcmHandle); - if (ret < 0) { - AUDIO_FUNC_LOGE("snd_pcm_close fail: %{public}s", snd_strerror(ret)); - } - alsaCardIns->renderPcmHandle = NULL; - } + renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); - if (alsaCardIns->cardStatus > 0) { - alsaCardIns->cardStatus -= 1; - } - if (alsaCardIns->cardStatus == 0) { - if (alsaCardIns->mixer != NULL) { - ret = snd_mixer_close(alsaCardIns->mixer); - if (ret < 0) { - AUDIO_FUNC_LOGE("snd_mixer_close fail: %{public}s", snd_strerror(ret)); - } - alsaCardIns->mixer = NULL; - } - (void)memset_s(alsaCardIns->cardName, MAX_CARD_NAME_LEN + 1, 0, MAX_CARD_NAME_LEN + 1); - ret = DestroyCardList(); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("DestroyCardList failed, reason: %{public}d.", ret); - return ret; - } + ret = renderIns->Stop(renderIns); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Render stop failed!"); + return ret; } + AUDIO_FUNC_LOGI("Render stop success."); return HDF_SUCCESS; } -int32_t AudioOutputRenderStart(const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) +int32_t AudioOutputRenderClose( + const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } + struct AlsaRender *renderIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - return HDF_SUCCESS; -} + renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); -static int32_t RenderWriteiMmap(const struct AudioHwRenderParam *handleData, struct AudioCardInfo *cardIns) -{ - int32_t ret; - uint32_t frameSize; - uint32_t totalSize; - uint32_t lastBuffSize; - uint32_t loopTimes; - uint32_t looper = 0; - uint32_t copyLen; - int32_t count = 0; - struct AudioMmapBufferDescriptor *mmapBufDesc = NULL; - - if (handleData == NULL || cardIns == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } - - frameSize = cardIns->hwRenderParams.channels * cardIns->hwRenderParams.format; - if (frameSize == 0) { - AUDIO_FUNC_LOGE("frame size = 0!"); - return HDF_FAILURE; - } - mmapBufDesc = (struct AudioMmapBufferDescriptor *)&(handleData->frameRenderMode.mmapBufDesc); - totalSize = (uint32_t)mmapBufDesc->totalBufferFrames * frameSize; - lastBuffSize = ((totalSize % MIN_PERIOD_SIZE) == 0) ? MIN_PERIOD_SIZE : (totalSize % MIN_PERIOD_SIZE); - loopTimes = (lastBuffSize == MIN_PERIOD_SIZE) ? (totalSize / MIN_PERIOD_SIZE) : (totalSize / MIN_PERIOD_SIZE + 1); - while (looper < loopTimes) { - copyLen = (looper < (loopTimes - 1)) ? MIN_PERIOD_SIZE : lastBuffSize; - snd_pcm_uframes_t frames = (snd_pcm_uframes_t)(copyLen / frameSize); - ret = snd_pcm_mmap_writei( - cardIns->renderPcmHandle, (char *)mmapBufDesc->memoryAddress + mmapBufDesc->offset, frames); - if (ret == -EAGAIN) { - count++; - if (count > AUDIO_ALSALIB_MMAP_MAX) { - AUDIO_FUNC_LOGE("loop > max !"); - return HDF_FAILURE; - } - continue; - } - count = 0; - if (ret < 0) { - AUDIO_FUNC_LOGE("Write error: %{public}s\n", snd_strerror(ret)); - return HDF_FAILURE; - } - looper++; - mmapBufDesc->offset += copyLen; - cardIns->renderMmapFrames += (uint64_t)frames; - } + renderIns->Close(renderIns); + AUDIO_FUNC_LOGI("Render close success."); return HDF_SUCCESS; } @@ -1308,73 +454,40 @@ int32_t AudioOutputRenderReqMmapBuffer( const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { int32_t ret; - struct AudioCardInfo *mmapCardIns = NULL; - - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } - - const char *adapterName = handleData->renderMode.hwInfo.adapterName; - mmapCardIns = GetCardIns(adapterName); - if (mmapCardIns == NULL) { - AUDIO_FUNC_LOGE("cardInstance is NULL!"); - return HDF_FAILURE; - } - mmapCardIns->renderMmapFlag = false; + struct AlsaRender *renderIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - ret = AudioResetParams(mmapCardIns->renderPcmHandle, mmapCardIns->hwRenderParams, SND_PCM_ACCESS_MMAP_INTERLEAVED); - if (ret < 0) { - AUDIO_FUNC_LOGE("AudioSetParamsMmap failed!"); - return HDF_FAILURE; - } + renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); - ret = RenderWriteiMmap(handleData, mmapCardIns); - if (ret < 0) { - AUDIO_FUNC_LOGE("RenderWriteiMmap error!"); + ret = renderIns->MmapWrite(renderIns, handleData); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Render MmapWrite error!"); return HDF_FAILURE; } - + return HDF_SUCCESS; } int32_t AudioOutputRenderGetMmapPosition( const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) { - struct AudioCardInfo *alsaMmapCardIns = NULL; + struct AlsaRender *renderIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } + renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); - /* Get the ALSA sound card instance corresponding to AdapterName */ - const char *adapterName = handleData->renderMode.hwInfo.adapterName; - alsaMmapCardIns = GetCardIns(adapterName); - if (alsaMmapCardIns == NULL) { - AUDIO_FUNC_LOGE("Can't find card Instance!"); - return HDF_FAILURE; - } - handleData->frameRenderMode.frames = alsaMmapCardIns->renderMmapFrames; + handleData->frameRenderMode.frames = renderIns->GetMmapPosition(renderIns); return HDF_SUCCESS; } -int32_t AudioInterfaceLibOutputRender(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) +int32_t AudioInterfaceLibOutputRender( + const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData) { int32_t ret; - - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } - - if (handle->object == NULL) { - AUDIO_FUNC_LOGE("handle's object is null!"); - return HDF_FAILURE; - } + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); switch (cmdId) { case AUDIO_DRV_PCM_IOCTL_HW_PARAMS: @@ -1416,12 +529,10 @@ int32_t AudioInterfaceLibOutputRender(const struct DevHandle *handle, int cmdId, return ret; } -int32_t AudioInterfaceLibModeRender(const struct DevHandle *handle, struct AudioHwRenderParam *handleData, int cmdId) +int32_t AudioInterfaceLibModeRender( + const struct DevHandle *handle, struct AudioHwRenderParam *handleData, int cmdId) { - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("paras is NULL!"); - return HDF_FAILURE; - } + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); switch (cmdId) { case AUDIO_DRV_PCM_IOCTL_HW_PARAMS: -- Gitee From 858021190373cd63b32af863f487b999dbfa3d12 Mon Sep 17 00:00:00 2001 From: xiesicong Date: Fri, 22 Sep 2023 10:14:44 +0800 Subject: [PATCH 08/14] =?UTF-8?q?=E4=BF=AE=E6=94=B9capture=E5=8D=97?= =?UTF-8?q?=E5=90=91=E6=8E=A5=E5=8F=A3=E5=AE=9E=E7=8E=B0=E4=B8=BA=E6=8A=BD?= =?UTF-8?q?=E8=B1=A1=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xiesicong --- .../alsa_adapter/include/alsa_lib_capture.h | 3 +- .../alsa_adapter/src/alsa_lib_capture.c | 1327 +++-------------- 2 files changed, 195 insertions(+), 1135 deletions(-) diff --git a/audio/supportlibs/alsa_adapter/include/alsa_lib_capture.h b/audio/supportlibs/alsa_adapter/include/alsa_lib_capture.h index d5b8ee5383..8e16840086 100644 --- a/audio/supportlibs/alsa_adapter/include/alsa_lib_capture.h +++ b/audio/supportlibs/alsa_adapter/include/alsa_lib_capture.h @@ -16,7 +16,8 @@ #ifndef ALSA_LIB_CAPTURE_H #define ALSA_LIB_CAPTURE_H -#include "alsa_lib_common.h" #include "audio_if_lib_capture.h" +#include "alsa_soundcard.h" +#include "alsa_snd_capture.h" #endif /* ALSA_LIB_CAPTURE_H */ diff --git a/audio/supportlibs/alsa_adapter/src/alsa_lib_capture.c b/audio/supportlibs/alsa_adapter/src/alsa_lib_capture.c index f4135049bb..13fd484702 100644 --- a/audio/supportlibs/alsa_adapter/src/alsa_lib_capture.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_lib_capture.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Copyright (c) 2022 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 @@ -14,430 +14,187 @@ */ #include "alsa_lib_capture.h" -#include "audio_common.h" -#include "osal_mem.h" -#include "securec.h" - -#define HDF_LOG_TAG HDF_AUDIO_HAL_LIB - -#define AUDIO_TIMESTAMP_FREQ 8 /* Hz */ -#define AUDIO_SAMPLE_FREQ 48000 -#define AUDIO_PERIOD ((AUDIO_SAMPLE_FREQ) / (AUDIO_TIMESTAMP_FREQ)) -#define AUDIO_PCM_WAIT 100 -#define AUDIO_RESUME_POLL (10 * (AUDIO_PCM_WAIT)) // 1s -#define ALSA_CAP_BUFFER_SIZE (2 * 2 * 6000) // format(S16LE) * channels(2) * period. - -static unsigned int g_bufferTime = 500000; /* (0.5s): ring buffer length in us */ -static unsigned int g_periodTime = 100000; /* (0.1s): period time in us */ -static snd_pcm_uframes_t g_bufferSize = 0; -static snd_pcm_uframes_t g_periodSize = 0; -static int g_resample = 1; /* enable alsa-lib resampling */ -static bool g_periodEvent = false; /* produce poll event after each period */ -static int g_canPause = 0; /* 0 Hardware doesn't support pause, 1 Hardware supports pause */ - -static int32_t AudioCaptureSetPauseState(snd_pcm_t *pcm, int32_t pause) -{ - int32_t ret; - - if (pcm == NULL) { - AUDIO_FUNC_LOGE("Param is NULL!"); - return HDF_FAILURE; - } - - if (pause == AUDIO_ALSALIB_IOCTRL_RESUME) { - ret = snd_pcm_prepare(pcm); - if (ret < 0) { - AUDIO_FUNC_LOGE("snd_pcm_prepare fail: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - ret = snd_pcm_start(pcm); - if (ret < 0) { - AUDIO_FUNC_LOGE("snd_pcm_start fail. %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - } - - if (pause == AUDIO_ALSALIB_IOCTRL_PAUSE) { - ret = snd_pcm_drop(pcm); - if (ret < 0) { - AUDIO_FUNC_LOGE("Pause fail: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - } - return HDF_SUCCESS; -} +#define HDF_LOG_TAG HDF_AUDIO_HAL_CAPTURE int32_t AudioCtlCaptureSetPauseStu( const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData) { int32_t ret; - int32_t pause; - struct AudioCardInfo *cardIns; - - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Param is NULL!"); - return HDF_FAILURE; - } + struct AlsaCapture *captureIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - const char *adapterName = handleData->captureMode.hwInfo.adapterName; - cardIns = GetCardIns(adapterName); - if (cardIns == NULL) { - AUDIO_FUNC_LOGE("cardIns or capturePcmHandle is NULL!"); - return HDF_FAILURE; - } - - pause = handleData->captureMode.ctlParam.pause ? AUDIO_ALSALIB_IOCTRL_PAUSE : AUDIO_ALSALIB_IOCTRL_RESUME; - ret = AudioCaptureSetPauseState(cardIns->capturePcmHandle, pause); + captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); + + ret = SndPcmPause(&captureIns->soundCard, handleData->captureMode.ctlParam.pause); if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("set pause error!"); + AUDIO_FUNC_LOGE("Capture set pause failed!"); return HDF_FAILURE; } return HDF_SUCCESS; } -static int32_t AudioCaptureMixerGetVolume(snd_mixer_t *mixer, snd_mixer_elem_t *pcmElemen, long *vol) -{ - long volLeft = MIN_VOLUME; - long volRight = MIN_VOLUME; - - if (mixer == NULL || pcmElemen == NULL || vol == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); - return HDF_FAILURE; - } - /* Handling events */ - int32_t ret = snd_mixer_handle_events(mixer); - if (ret < 0) { - AUDIO_FUNC_LOGE("snd_mixer_handle_events fail!"); - return HDF_FAILURE; - } - - /* Left channel */ - ret = snd_mixer_selem_get_capture_volume(pcmElemen, SND_MIXER_SCHN_FRONT_LEFT, &volLeft); - if (ret < 0) { - AUDIO_FUNC_LOGE("Get left channel fail!"); - return HDF_FAILURE; - } - /* right channel */ - ret = snd_mixer_selem_get_capture_volume(pcmElemen, SND_MIXER_SCHN_FRONT_RIGHT, &volRight); - if (ret < 0) { - AUDIO_FUNC_LOGE("Get right channel fail!"); - return HDF_FAILURE; - } - *vol = (volLeft + volRight) / 2; - - return HDF_SUCCESS; -} - -int32_t AudioCtlCaptureGetVolume(const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureGetVolume( + const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData) { int32_t ret; - long vol = 0; - struct AudioCardInfo *cardIns; + long vol; + struct AlsaCapture *captureIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("AudioCtlCaptureSetVolume parameter is NULL!"); - return HDF_FAILURE; - } + captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); - const char *adapterName = handleData->captureMode.hwInfo.adapterName; - cardIns = GetCardIns(adapterName); - if (cardIns == NULL) { - AUDIO_FUNC_LOGE("Unable to obtain correct sound card information!"); + ret = captureIns->GetVolume(captureIns, &vol); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Capture GetVolume failed!"); return HDF_FAILURE; } + handleData->captureMode.ctlParam.volume = (float)vol; - if (strncmp(adapterName, PRIMARY, strlen(PRIMARY)) == 0) { - if (cardIns->volElemList == NULL || cardIns->volElemList[0].elem == NULL) { - AUDIO_FUNC_LOGE("ctrlVolumeList is NULL!"); - return HDF_FAILURE; - } - ret = AudioCaptureMixerGetVolume(cardIns->mixer, cardIns->volElemList[0].elem, &vol); - if (ret < 0) { - AUDIO_FUNC_LOGE("Get primary volume failed!"); - return ret; - } - handleData->captureMode.ctlParam.volume = (float)(vol); - return HDF_SUCCESS; - } - - if (strncmp(adapterName, USB, strlen(USB)) == 0) { - if (cardIns->usbCtlVolume == NULL) { - AUDIO_FUNC_LOGE("usbCtlVolume is NULL, the volume setting may not be supported!"); - return HDF_FAILURE; - } - ret = AudioCaptureMixerGetVolume(cardIns->mixer, cardIns->usbCtlVolume, &vol); - if (ret < 0) { - AUDIO_FUNC_LOGE("Get usb volume failed!"); - return ret; - } - handleData->captureMode.ctlParam.volume = (float)(vol); - return HDF_SUCCESS; - } - /* Special external sound recording card, no volume control, return not supported */ - return HDF_ERR_NOT_SUPPORT; + return HDF_SUCCESS; } -static int32_t AudioCaptureSetMixerVolume(snd_mixer_elem_t *pcmElemen, long vol) +int32_t AudioCtlCaptureSetVolume( + const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData) { int32_t ret; + long vol; + struct AlsaCapture *captureIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - if (pcmElemen == NULL) { - AUDIO_FUNC_LOGE("parameter is NULL!"); - return HDF_FAILURE; - } + captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); - /* Judge whether it is mono or stereo */ - ret = snd_mixer_selem_is_capture_mono(pcmElemen); - if (ret == 1) { // mono - ret = snd_mixer_selem_set_capture_volume(pcmElemen, SND_MIXER_SCHN_MONO, vol); - if (ret < 0) { - AUDIO_FUNC_LOGE("Failed to set volume: %{public}s.", snd_strerror(ret)); - return HDF_FAILURE; - } - } else { // ret == 0: is not mono. (stereo) - ret = snd_mixer_selem_set_capture_volume_all(pcmElemen, vol); - if (ret < 0) { - AUDIO_FUNC_LOGE("Failed to set all channel volume: %{public}s.", snd_strerror(ret)); - return HDF_FAILURE; - } + vol = (long)handleData->captureMode.ctlParam.volume; + ret = captureIns->SetVolume(captureIns, vol); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Capture SetVolume fail!"); + return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCtlCaptureSetVolume( +int32_t AudioCtlCaptureSetMuteStu( const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData) { int32_t ret; - int32_t vol; - struct AudioCardInfo *cardIns; + struct AlsaCapture *captureIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("parameter is NULL!"); - return HDF_FAILURE; - } - - vol = (int32_t)handleData->captureMode.ctlParam.volume; - const char *adapterName = handleData->captureMode.hwInfo.adapterName; - cardIns = GetCardIns(adapterName); - if (cardIns == NULL) { - AUDIO_FUNC_LOGE("cardIns is NULL!"); - return HDF_FAILURE; - } + captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); - if (strncmp(adapterName, PRIMARY, strlen(PRIMARY)) == 0) { - if (cardIns->volElemList == NULL) { - AUDIO_FUNC_LOGE("Get capture ctrlVolumeList is NULL!"); - return HDF_FAILURE; - } - for (int32_t index = 0; index < (int32_t)cardIns->volElemCount; index++) { - if (cardIns->volElemList[index].elem == NULL) { - AUDIO_FUNC_LOGE("Get capture ctrlVolume is NULL!"); - return HDF_FAILURE; - } - ret = AudioCaptureSetMixerVolume(cardIns->volElemList[index].elem, vol); - if (ret < 0) { - AUDIO_FUNC_LOGE("primary set volume failed!"); - return ret; - } - } - return HDF_SUCCESS; - } - - if (strncmp(adapterName, USB, strlen(USB)) == 0) { - if (cardIns->usbCtlVolume != NULL) { - ret = AudioCaptureSetMixerVolume(cardIns->usbCtlVolume, vol); - if (ret < 0) { - AUDIO_FUNC_LOGE("usb set volume failed!"); - return ret; - } - return HDF_SUCCESS; - } - } - - /* Special external sound recording card, no volume control, return not supported */ - return HDF_ERR_NOT_SUPPORT; -} - -static int32_t AudioCaptureSetMuteState( - struct AudioCardInfo *cardIns, int32_t muteState, const char *adapterName, float volume) -{ - long vol; - long setVol; - float volRangeMin = 0.0; - float volRangeMax = 100.0; - if (cardIns == NULL || cardIns->volElemList == NULL) { - AUDIO_FUNC_LOGE("Parameter error!"); + ret = captureIns->SetMute(captureIns, handleData->captureMode.ctlParam.mute); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Capture set mute failed!"); return HDF_FAILURE; } - int32_t ret = AudioCaptureMixerGetVolume(cardIns->mixer, cardIns->volElemList[0].elem, &vol); - if (ret < 0) { - AUDIO_FUNC_LOGE("AudioCaptureMixerGetVolume fail!"); - return ret; - } - - if (muteState == false) { - setVol = 0; // 0 for mute - cardIns->tempVolume = (float)vol; - } else { - if (volume > volRangeMin && volume <= volRangeMax) { - setVol = (long)volume; - } else { - setVol = (long)cardIns->tempVolume; - } - } - for (int i = 0; i < (int32_t)cardIns->volElemCount; i++) { - if (cardIns->volElemList[i].elem == NULL) { - AUDIO_FUNC_LOGE("AudioCapture get volElemList fail!"); - return HDF_FAILURE; - } - ret = AudioCaptureSetMixerVolume(cardIns->volElemList[i].elem, setVol); - if (ret < 0) { - AUDIO_FUNC_LOGE("AudioCaptureSetMixerVolume fail!"); - return HDF_FAILURE; - } - } return HDF_SUCCESS; } -static int32_t AudioUsbSetMute(snd_mixer_elem_t *pcmElemen, int32_t muteState) +int32_t AudioCtlCaptureGetMuteStu( + const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData) { - int32_t ret; - - if (pcmElemen == NULL) { - AUDIO_FUNC_LOGE("cardIns is NULL!"); - return HDF_FAILURE; - } - ret = snd_mixer_selem_has_capture_switch(pcmElemen); - if (ret == 1) { // 1: Controlled switch - ret = snd_mixer_selem_set_capture_switch_all(pcmElemen, muteState); - if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to set mute: %{public}s.", snd_strerror(ret)); - return HDF_FAILURE; - } - } else { // 0: no control - AUDIO_FUNC_LOGE("it's no control is present"); - return HDF_FAILURE; - } + struct AlsaCapture *captureIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); + captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); + handleData->captureMode.ctlParam.mute = captureIns->GetMute(captureIns); + return HDF_SUCCESS; } -int32_t AudioCtlCaptureSetMuteStu( +int32_t AudioCtlCaptureSetGainStu( const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData) { int32_t ret; - bool muteState; + float gainValue; + struct AlsaCapture *captureIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("param is NULL!"); - return HDF_FAILURE; - } + captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); - const char *adapterName = handleData->captureMode.hwInfo.adapterName; - struct AudioCardInfo *cardIns = GetCardIns(adapterName); - if (cardIns == NULL) { - AUDIO_FUNC_LOGE("cardIns is empty pointer!!!"); + gainValue = handleData->captureMode.ctlParam.audioGain.gain; + ret = captureIns->SetGain(captureIns, gainValue); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Capture can not set gain!"); return HDF_FAILURE; } - muteState = (bool)cardIns->captureMuteValue; - if (strncmp(adapterName, USB, strlen(USB)) == 0) { - if (AudioUsbSetMute(cardIns->usbCtlVolume, muteState) != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("AudioUsbSetMute failed!"); - return HDF_FAILURE; - } - } - if (strncmp(adapterName, PRIMARY, strlen(PRIMARY)) == 0) { - ret = AudioCaptureSetMuteState(cardIns, muteState, adapterName, handleData->captureMode.ctlParam.volume); - if (ret < 0) { - AUDIO_FUNC_LOGE("Render primary sound card SetMute failed!"); - return HDF_FAILURE; - } - } - cardIns->captureMuteValue = (int32_t)handleData->captureMode.ctlParam.mute; return HDF_SUCCESS; } -int32_t AudioCtlCaptureGetMuteStu(const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData) +int32_t AudioCtlCaptureGetGainStu( + const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData) { - struct AudioCardInfo *cardInstance; + int32_t ret; + float gainValue; + struct AlsaCapture *captureIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("param is NULL!"); - return HDF_FAILURE; - } + captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); - const char *adapterName = handleData->captureMode.hwInfo.adapterName; - cardInstance = GetCardIns(adapterName); - if (cardInstance == NULL) { - AUDIO_FUNC_LOGE("cardInsance is null pointer!!"); + ret = captureIns->GetGain(captureIns, &gainValue); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Capture get gain failed!"); return HDF_FAILURE; } - - handleData->captureMode.ctlParam.mute = (bool)cardInstance->captureMuteValue; + handleData->captureMode.ctlParam.audioGain.gain = gainValue; + return HDF_SUCCESS; } -int32_t AudioCtlCaptureSetGainStu( +int32_t AudioCtlCaptureSceneSelect( const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData) { - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("param is NULL!"); - return HDF_FAILURE; - } + int32_t ret; + enum AudioPortPin descPins; + const struct PathDeviceInfo *deviceInfo; + struct AlsaCapture *captureIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - return HDF_SUCCESS; -} + captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); -int32_t AudioCtlCaptureGetGainStu(const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData) -{ - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("param is NULL!"); + descPins = handleData->captureMode.hwInfo.deviceDescript.pins; + deviceInfo = &handleData->captureMode.hwInfo.pathSelect.deviceInfo; + ret = captureIns->SelectScene(captureIns, descPins, deviceInfo); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Capture select scene pin: (0x%{public}x) failed",descPins); return HDF_FAILURE; } - return HDF_SUCCESS; -} - -int32_t AudioCtlCaptureSceneSelect( - const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData) -{ - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("param is NULL!"); - return HDF_FAILURE; - } - if (strcmp(handleData->captureMode.hwInfo.adapterName, USB) == 0 || - strcmp(handleData->captureMode.hwInfo.adapterName, HDMI) == 0) { - return HDF_SUCCESS; - } - int32_t ret = EnableAudioCaptureRoute(handleData); - if (ret < 0) { - AUDIO_FUNC_LOGE("EnableAudioRoute failed!"); - return ret; - } + AUDIO_FUNC_LOGD("Capture scene select pin: (0x%{public}x) success",descPins); return HDF_SUCCESS; } int32_t AudioCtlCaptureGetGainThreshold( const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData) { - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("param is NULL!"); + int32_t ret; + float gainMin = 0.0; + float gainMax = 1.0; + struct AlsaCapture *captureIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); + + captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); + + ret = captureIns->GetGainThreshold(captureIns, &gainMin, &gainMax); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Capture get gain threshold failed"); return HDF_FAILURE; } + handleData->captureMode.ctlParam.audioGain.gainMin = gainMin; + handleData->captureMode.ctlParam.audioGain.gainMax = gainMax; return HDF_SUCCESS; } @@ -448,30 +205,15 @@ int32_t AudioCtlCaptureGetVolThreshold( int32_t ret; long volMax = MIN_VOLUME; long volMin = MIN_VOLUME; + struct AlsaCapture * captureIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Param is NULL!"); - return HDF_FAILURE; - } - - const char *adapterName = handleData->captureMode.hwInfo.adapterName; - struct AudioCardInfo *cardIns = GetCardIns(adapterName); - if (cardIns == NULL) { - AUDIO_FUNC_LOGE("cardIns is NULL!!!"); - return HDF_FAILURE; - } - - if (strncmp(adapterName, USB, strlen(USB)) == 0 || strncmp(adapterName, HDMI, strlen(HDMI)) == 0) { - handleData->captureMode.ctlParam.volThreshold.volMax = MAX_VOLUME; - handleData->captureMode.ctlParam.volThreshold.volMin = MIN_VOLUME; - return HDF_SUCCESS; - } - - ret = snd_mixer_selem_get_capture_volume_range(cardIns->volElemList[0].elem, &volMin, &volMax); - if (ret < 0) { - AUDIO_FUNC_LOGE("Get capture volume range fail: %{public}s.", snd_strerror(ret)); - return HDF_FAILURE; + captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); + + ret = captureIns->GetVolThreshold(captureIns, &volMin, &volMax); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Capture get volume threshold failed!"); } handleData->captureMode.ctlParam.volThreshold.volMax = (int)volMax; handleData->captureMode.ctlParam.volThreshold.volMin = (int)volMin; @@ -479,14 +221,12 @@ int32_t AudioCtlCaptureGetVolThreshold( return HDF_SUCCESS; } -int32_t AudioInterfaceLibCtlCapture(const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData) +int32_t AudioInterfaceLibCtlCapture( + const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData) { int32_t ret; - - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("param is NULL!"); - return HDF_FAILURE; - } + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); + CHECK_VALID_RANGE_RETURN(cmdId, AUDIODRV_CTL_IOCTL_ELEM_INFO_CAPTURE, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE, HDF_FAILURE); switch (cmdId) { /* setPara: */ @@ -527,318 +267,28 @@ int32_t AudioInterfaceLibCtlCapture(const struct DevHandle *handle, int cmdId, s return ret; } -static int32_t GetCapHwParams(struct AudioCardInfo *cardIns, const struct AudioHwCaptureParam *handleData) -{ - if (cardIns == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Parameter is NULL!"); - return HDF_FAILURE; - } - - cardIns->hwCaptureParams.streamType = AUDIO_CAPTURE_STREAM; - cardIns->hwCaptureParams.channels = handleData->frameCaptureMode.attrs.channelCount; - cardIns->hwCaptureParams.rate = handleData->frameCaptureMode.attrs.sampleRate; - cardIns->hwCaptureParams.periodSize = handleData->frameCaptureMode.periodSize; - cardIns->hwCaptureParams.periodCount = handleData->frameCaptureMode.periodCount; - cardIns->hwCaptureParams.format = handleData->frameCaptureMode.attrs.format; - cardIns->hwCaptureParams.period = handleData->frameCaptureMode.attrs.period; - cardIns->hwCaptureParams.frameSize = handleData->frameCaptureMode.attrs.frameSize; - cardIns->hwCaptureParams.isBigEndian = handleData->frameCaptureMode.attrs.isBigEndian; - cardIns->hwCaptureParams.isSignedData = handleData->frameCaptureMode.attrs.isSignedData; - cardIns->hwCaptureParams.startThreshold = handleData->frameCaptureMode.attrs.startThreshold; - cardIns->hwCaptureParams.stopThreshold = handleData->frameCaptureMode.attrs.stopThreshold; - cardIns->hwCaptureParams.silenceThreshold = handleData->frameCaptureMode.attrs.silenceThreshold; - - return HDF_SUCCESS; -} - -static int32_t SetHWParamsSub( - snd_pcm_t *handle, snd_pcm_hw_params_t *params, struct AudioPcmHwParams hwCapParams, snd_pcm_access_t access) -{ - int32_t ret; - snd_pcm_format_t pcmFormat; - - if (handle == NULL || params == NULL) { - AUDIO_FUNC_LOGE("SetHWParamsSub parameter is null!"); - return HDF_FAILURE; - } - - ret = snd_pcm_hw_params_set_rate_resample(handle, params, g_resample); - if (ret < 0) { - AUDIO_FUNC_LOGE("Resampling setup failed for capture: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - - /* set the interleaved read/write format */ - ret = snd_pcm_hw_params_set_access(handle, params, access); - if (ret < 0) { - AUDIO_FUNC_LOGE("Access type not available for capture: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - ret = CheckParaFormat(hwCapParams, &pcmFormat); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("CheckParaFormat error."); - return ret; - } - /* set the sample format */ - ret = snd_pcm_hw_params_set_format(handle, params, pcmFormat); - if (ret < 0) { - AUDIO_FUNC_LOGE("Sample format not available for capture: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - - /* set the count of channels */ - ret = snd_pcm_hw_params_set_channels(handle, params, hwCapParams.channels); - if (ret < 0) { - AUDIO_FUNC_LOGE("Channels count (%{public}u) not available for capture: %{public}s", hwCapParams.channels, - snd_strerror(ret)); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -static int32_t SetHWRate(snd_pcm_t *handle, snd_pcm_hw_params_t *params, uint32_t *rate) -{ - int32_t ret; - uint32_t rRate; - int32_t dir = 0; /* dir Value range (-1,0,1) */ - - if (handle == NULL || params == NULL || rate == NULL) { - AUDIO_FUNC_LOGE("SetHWParams parameter is null!"); - return HDF_FAILURE; - } - - /* set the stream rate */ - rRate = *rate; - ret = snd_pcm_hw_params_set_rate_near(handle, params, &rRate, &dir); - if (ret < 0) { - AUDIO_FUNC_LOGE("Rate %{public}uHz not available for capture: %{public}s", *rate, snd_strerror(ret)); - return HDF_FAILURE; - } - - if (rRate != *rate) { - ret = snd_pcm_hw_params_set_rate_near(handle, params, &rRate, &dir); - if (ret < 0) { - AUDIO_FUNC_LOGE("Rate %{public}uHz not available for capture: %{public}s", *rate, snd_strerror(ret)); - return HDF_FAILURE; - } - } - /* Update to hardware supported rate */ - *rate = rRate; - - g_canPause = snd_pcm_hw_params_can_pause(params); - - return HDF_SUCCESS; -} - -static int32_t SetHWBuffer(snd_pcm_t *handle, snd_pcm_hw_params_t *params) -{ - int32_t ret; - int32_t dir = 0; /* dir Value range (-1,0,1) */ - snd_pcm_uframes_t size = 0; - - if (handle == NULL || params == NULL) { - AUDIO_FUNC_LOGE("SetHWParams parameter is null!"); - return HDF_FAILURE; - } - - ret = snd_pcm_hw_params_set_buffer_time_near(handle, params, &g_bufferTime, &dir); - if (ret < 0) { - AUDIO_FUNC_LOGE( - "Unable to set buffer time %{public}u for capture: %{public}s", g_bufferTime, snd_strerror(ret)); - return HDF_FAILURE; - } - - ret = snd_pcm_hw_params_get_buffer_size(params, &size); - if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to get buffer size for capture: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - g_bufferSize = size; - - return HDF_SUCCESS; -} - -static int32_t SetHWPeriod(snd_pcm_t *handle, snd_pcm_hw_params_t *params) -{ - int32_t ret; - int32_t dir = 0; /* dir Value range (-1,0,1) */ - snd_pcm_uframes_t size = 0; - - if (handle == NULL || params == NULL) { - AUDIO_FUNC_LOGE("SetHWParams parameter is null!"); - return HDF_FAILURE; - } - - ret = snd_pcm_hw_params_set_period_time_near(handle, params, &g_periodTime, &dir); - if (ret < 0) { - AUDIO_FUNC_LOGE( - "Unable to set period time %{public}u for capture: %{public}s", g_periodTime, snd_strerror(ret)); - return HDF_FAILURE; - } - - ret = snd_pcm_hw_params_get_period_size(params, &size, &dir); - if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to get period size for capture: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - g_periodSize = size; - - return HDF_SUCCESS; -} - -static int32_t SetHWParams( - snd_pcm_t *handle, snd_pcm_hw_params_t *params, struct AudioPcmHwParams hwCapParams, snd_pcm_access_t access) -{ - int32_t ret; - - if (handle == NULL || params == NULL) { - AUDIO_FUNC_LOGE("SetHWParams parameter is null!"); - return HDF_FAILURE; - } - - ret = snd_pcm_hw_params_any(handle, params); // choose all parameters - if (ret < 0) { - AUDIO_FUNC_LOGE( - "Broken configuration for capture: no configurations available: %{public}s.", snd_strerror(ret)); - return HDF_FAILURE; - } - - ret = SetHWParamsSub(handle, params, hwCapParams, access); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("SetHWParamsSub failed!"); - return ret; - } - - ret = SetHWRate(handle, params, &(hwCapParams.rate)); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("SetHWRate failed!"); - return ret; - } - - ret = SetHWBuffer(handle, params); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("SetHWBuffer failed!"); - return ret; - } - - ret = SetHWPeriod(handle, params); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("SetHWPeriod failed!"); - return ret; - } - - /* write the parameters to device. */ - ret = snd_pcm_hw_params(handle, params); - if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to set hw params for capture: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -static int32_t SetSWParams(snd_pcm_t *handle, snd_pcm_sw_params_t *swparams) -{ - int32_t ret; - - if (handle == NULL || swparams == NULL) { - AUDIO_FUNC_LOGE("SetHWParams parameter is null!"); - return HDF_FAILURE; - } - - /* get the current swparams */ - ret = snd_pcm_sw_params_current(handle, swparams); - if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to determine current swparams for capture: %{public}s.", snd_strerror(ret)); - return HDF_FAILURE; - } - - if (g_periodSize == 0) { - AUDIO_FUNC_LOGE("error: g_periodSize cannot be zero!"); - return HDF_FAILURE; - } - /* start the transfer when the buffer is almost full: */ - /* (buffer_size / avail_min) * avail_min */ - ret = snd_pcm_sw_params_set_start_threshold(handle, swparams, (g_bufferSize / g_periodSize) * g_periodSize); - if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to set start threshold mode for capture: %{public}s.", snd_strerror(ret)); - return HDF_FAILURE; - } - - /* allow the transfer when at least period_size samples can be processed */ - /* or disable this mechanism when period event is enabled (aka interrupt like style processing) */ - ret = snd_pcm_sw_params_set_avail_min(handle, swparams, g_periodEvent ? g_bufferSize : g_periodSize); - if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to set avail min for capture: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - - /* enable period events when requested */ - if (g_periodEvent) { - ret = snd_pcm_sw_params_set_period_event(handle, swparams, 1); - if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to set period event: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - } - - /* write the parameters to the capture device */ - ret = snd_pcm_sw_params(handle, swparams); - if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to set sw params for capture: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - int32_t AudioOutputCaptureHwParams( const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData) { int32_t ret; - struct AudioCardInfo *cardIns; - snd_pcm_hw_params_t *hwParams = NULL; - snd_pcm_sw_params_t *swParams = NULL; + struct AlsaCapture *captureIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("The parameter is empty"); - return HDF_FAILURE; - } - - const char *adapterName = handleData->captureMode.hwInfo.adapterName; - cardIns = GetCardIns(adapterName); - if (cardIns == NULL) { - AUDIO_FUNC_LOGE("cardIns is NULL!"); - return HDF_FAILURE; - } + captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); - ret = (int32_t)snd_pcm_state(cardIns->capturePcmHandle); - if (ret >= SND_PCM_STATE_RUNNING) { - AUDIO_FUNC_LOGE("Unable to set parameters during capture!"); + if (SndGetRunState(&captureIns->soundCard) >= SND_PCM_STATE_RUNNING) { + AUDIO_FUNC_LOGE("Unable to set parameters during playback!"); return HDF_FAILURE; } - ret = GetCapHwParams(cardIns, handleData); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("GetCapHwParams error."); - return ret; - } - - snd_pcm_hw_params_alloca(&hwParams); - snd_pcm_sw_params_alloca(&swParams); - ret = SetHWParams(cardIns->capturePcmHandle, hwParams, cardIns->hwCaptureParams, SND_PCM_ACCESS_RW_INTERLEAVED); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("Setting of hwparams failed: %{public}d.", ret); - return ret; - } - ret = SetSWParams(cardIns->capturePcmHandle, swParams); + ret = CaptureSetParams(captureIns, handleData); if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("Setting of swparams failed: %{public}d.", ret); - return ret; + AUDIO_FUNC_LOGE("Capture set parameters failed!"); + return HDF_FAILURE; } - + + AUDIO_FUNC_LOGI("Capture set hwparams success."); return HDF_SUCCESS; } @@ -846,497 +296,123 @@ int32_t AudioOutputCaptureHwParams( * brief: Opens a capture PCM * param mode Open mode (see #SND_PCM_NONBLOCK, #SND_PCM_ASYNC) */ -int32_t AudioOutputCaptureOpen(const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData) +int32_t AudioOutputCaptureOpen( + const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData) { int32_t ret; - struct AudioCardInfo *cardIns; + struct AlsaCapture * captureIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Function parameter is NULL!"); - return HDF_FAILURE; - } + captureIns = CaptureCreateInstance(handleData->captureMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); - const char *adapterName = handleData->captureMode.hwInfo.adapterName; - cardIns = AudioGetCardInstance(adapterName); - if (cardIns == NULL) { - AUDIO_FUNC_LOGE("AudioCaptureGetCardIns failed."); - (void)DestroyCardList(); - return HDF_FAILURE; - } - ret = AudioGetCardInfo(cardIns, adapterName, SND_PCM_STREAM_CAPTURE); + ret = captureIns->Open(captureIns); if (ret != HDF_SUCCESS) { - CheckCardStatus(cardIns); - (void)DestroyCardList(); + AUDIO_FUNC_LOGE("Capture open pcm failed."); return HDF_FAILURE; } - if (cardIns->capturePcmHandle != NULL) { - AUDIO_FUNC_LOGE("Resource busy!!"); - CheckCardStatus(cardIns); - (void)DestroyCardList(); - return HDF_ERR_DEVICE_BUSY; - } - ret = snd_pcm_open(&cardIns->capturePcmHandle, cardIns->devName, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK); - if (ret < 0) { - AUDIO_FUNC_LOGE("Capture open device error: %{public}s.", snd_strerror(ret)); - CheckCardStatus(cardIns); - (void)DestroyCardList(); - return HDF_FAILURE; - } - InitSound(&cardIns->mixer, cardIns->ctrlName); - ret = InitMixerCtlElement(adapterName, cardIns, cardIns->mixer, SND_PCM_STREAM_CAPTURE); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("capture InitMixerCtlElement failed!"); - (void)CloseMixerHandle(cardIns->mixer); - CheckCardStatus(cardIns); - (void)DestroyCardList(); - return ret; - } - - return HDF_SUCCESS; -} - -int32_t AudioCaptureResetParams(snd_pcm_t *handle, struct AudioPcmHwParams audioHwParams, snd_pcm_access_t access) -{ - int32_t ret; - snd_pcm_hw_params_t *hwParams = NULL; - snd_pcm_sw_params_t *swParams = NULL; - - if (handle == NULL) { - AUDIO_FUNC_LOGE("handle is NULL!"); - return HDF_FAILURE; - } - - snd_pcm_hw_params_alloca(&hwParams); - snd_pcm_sw_params_alloca(&swParams); - ret = SetHWParams(handle, hwParams, audioHwParams, access); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("Setting of hwparams failed: %{public}d.", ret); - return ret; - } - - ret = SetSWParams(handle, swParams); + + ret = captureIns->Init(captureIns); if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("Setting of swparams failed: %{public}d.", ret); - return ret; - } - - return HDF_SUCCESS; -} - -static int32_t CaptureDataCopy(struct AudioHwCaptureParam *handleData, char *buffer, uint64_t frames) -{ - int32_t ret; - uint32_t channels; - uint32_t format; - uint64_t recvDataSize; - - if (handleData == NULL || buffer == NULL || frames == 0) { - AUDIO_FUNC_LOGE("Param is NULL!"); - return HDF_FAILURE; - } - - if (handleData->frameCaptureMode.buffer == NULL) { - AUDIO_FUNC_LOGE("frameCaptureMode.buffer is NULL!"); + AUDIO_FUNC_LOGE("Capture init failed."); return HDF_FAILURE; } - channels = handleData->frameCaptureMode.attrs.channelCount; - format = (uint32_t)handleData->frameCaptureMode.attrs.format; - recvDataSize = (uint64_t)(frames * channels * format); - ret = memcpy_s(handleData->frameCaptureMode.buffer, FRAME_DATA, buffer, recvDataSize); - if (ret != EOK) { - AUDIO_FUNC_LOGE("memcpy frame data failed!"); - return HDF_FAILURE; - } - handleData->frameCaptureMode.bufferSize = recvDataSize; - handleData->frameCaptureMode.bufferFrameSize = frames; + AUDIO_FUNC_LOGI("Capture open success."); return HDF_SUCCESS; } -static int32_t CheckCapFrameBufferSize(struct AudioHwCaptureParam *handleData, snd_pcm_uframes_t *periodSize) -{ - uint32_t capFrameSize; - uint64_t capReqBufferSize; - - if (handleData == NULL || periodSize == NULL) { - AUDIO_FUNC_LOGE("Param is NULL!"); - return HDF_FAILURE; - } - - capFrameSize = handleData->frameCaptureMode.attrs.channelCount * handleData->frameCaptureMode.attrs.format; - if (capFrameSize == 0) { - AUDIO_FUNC_LOGE("capFrameSize is zero."); - return HDF_FAILURE; - } - capReqBufferSize = capFrameSize * (*periodSize); - if (capReqBufferSize > FRAME_DATA) { - *periodSize = FRAME_DATA / capFrameSize; - } - - return HDF_SUCCESS; -} - -static int32_t CheckPcmStatus(snd_pcm_t *capturePcmHandle) -{ - int32_t ret; - - if (capturePcmHandle == NULL) { - AUDIO_FUNC_LOGE("Param is NULL."); - return HDF_FAILURE; - } - - ret = snd_pcm_wait(capturePcmHandle, -1); /* -1 for timeout, Waiting forever */ - if (ret < 0) { - AUDIO_FUNC_LOGE("snd_pcm_wait failed: %{public}s.", snd_strerror(ret)); - return HDF_FAILURE; - } - if (snd_pcm_state(capturePcmHandle) == SND_PCM_STATE_SETUP) { - ret = snd_pcm_prepare(capturePcmHandle); - if (ret < 0) { - AUDIO_FUNC_LOGE("snd_pcm_prepare fail: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - } - - return HDF_SUCCESS; -} - -static int32_t AudioCaptureReadFrameSub(snd_pcm_t *pcm, uint64_t *frameCnt, char *dataBuf, snd_pcm_uframes_t bufSize) +int32_t AudioOutputCaptureRead( + const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData) { int32_t ret; - long frames; - int32_t tryNum = AUDIO_ALSALIB_RETYR; + struct AlsaCapture *captureIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - if (pcm == NULL || frameCnt == NULL || dataBuf == NULL || bufSize == 0) { - AUDIO_FUNC_LOGE("The parameter is error."); - return HDF_FAILURE; - } + captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); - do { - /* Read interleaved frames to a PCM. */ - frames = snd_pcm_readi(pcm, dataBuf, bufSize); - if (frames > 0) { - *frameCnt = (uint64_t)frames; - return HDF_SUCCESS; - } - - if (frames == -EBADFD) { - AUDIO_FUNC_LOGE("capture PCM is not in the right state: %{public}s", snd_strerror(frames)); - ret = snd_pcm_prepare(pcm); - if (ret < 0) { - AUDIO_FUNC_LOGE("capture snd_pcm_prepare fail: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - } else { - /* -ESTRPIPE: a suspend event occurred, - * stream is suspended and waiting for an application recovery. - * -EPIPE: an underrun occurred. - */ - ret = snd_pcm_recover(pcm, frames, 0); // 0 for open capture recover log. - if (ret < 0) { - AUDIO_FUNC_LOGE("snd_pcm_readi failed: %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - } - ret = snd_pcm_start(pcm); - if (ret < 0) { - AUDIO_FUNC_LOGE("snd_pcm_start fail. %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - tryNum--; - } while (tryNum > 0); - - return HDF_SUCCESS; -} - -static int32_t AudioCaptureReadFrame( - struct AudioHwCaptureParam *handleData, struct AudioCardInfo *cardIns, snd_pcm_uframes_t periodSize) -{ - int32_t ret; - uint64_t frames = 0; - char *buffer = NULL; - - if (handleData == NULL || cardIns == NULL) { - AUDIO_FUNC_LOGE("Param is NULL!"); - return HDF_FAILURE; - } - - buffer = OsalMemCalloc(ALSA_CAP_BUFFER_SIZE); - if (buffer == NULL) { - AUDIO_FUNC_LOGE("Failed to Calloc buffer"); - return HDF_FAILURE; - } - - ret = CheckCapFrameBufferSize(handleData, &periodSize); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("CheckCapFrameBufferSize failed."); - AudioMemFree((void **)&buffer); - return ret; - } - - ret = CheckPcmStatus(cardIns->capturePcmHandle); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("CheckPcmStatus failed."); - AudioMemFree((void **)&buffer); - return ret; - } - - ret = AudioCaptureReadFrameSub(cardIns->capturePcmHandle, &frames, buffer, periodSize); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("AudioCaptureReadFrameSub is error!"); - AudioMemFree((void **)&buffer); - return ret; - } - - ret = CaptureDataCopy(handleData, buffer, frames); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("Failed to copy data. It may be paused. Check the status!"); - AudioMemFree((void **)&buffer); - return ret; - } - AudioMemFree((void **)&buffer); - - return HDF_SUCCESS; -} - -int32_t AudioOutputCaptureRead(const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData) -{ - int32_t ret; - snd_pcm_uframes_t bufferSize = 0; - snd_pcm_uframes_t periodSize = 0; - - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Param is NULL!"); - return HDF_FAILURE; - } - - const char *sndCardName = handleData->captureMode.hwInfo.adapterName; - struct AudioCardInfo *cardIns = GetCardIns(sndCardName); - if (cardIns == NULL) { - AUDIO_FUNC_LOGE("cardIns is NULL!"); - return HDF_FAILURE; - } - - ret = snd_pcm_get_params(cardIns->capturePcmHandle, &bufferSize, &periodSize); - if (ret < 0) { - AUDIO_FUNC_LOGE("Get capture params error: %{public}s.", snd_strerror(ret)); - return HDF_FAILURE; - } - - if (!cardIns->captureMmapFlag) { - ret = - AudioCaptureResetParams(cardIns->capturePcmHandle, cardIns->hwCaptureParams, SND_PCM_ACCESS_RW_INTERLEAVED); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("AudioSetParamsMmap failed!"); - return ret; - } - ret = snd_pcm_start(cardIns->capturePcmHandle); - if (ret < 0) { - AUDIO_FUNC_LOGE("snd_pcm_start fail. %{public}s", snd_strerror(ret)); - return HDF_FAILURE; - } - cardIns->captureMmapFlag = true; - } - - ret = AudioCaptureReadFrame(handleData, cardIns, periodSize); + ret = captureIns->Read(captureIns, handleData); if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("AudioOutputCaptureRead failed"); + AUDIO_FUNC_LOGE("CaptureReadFrame failed"); return ret; } return HDF_SUCCESS; } -int32_t AudioOutputCaptureStart(const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData) -{ - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Param is NULL!"); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - int32_t AudioOutputCapturePrepare( const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData) { int32_t ret; - struct AudioCardInfo *cardIns; + struct AlsaCapture *captureIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Invalid parameters!!!"); - return HDF_FAILURE; - } + captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); - const char *adapterName = handleData->captureMode.hwInfo.adapterName; - cardIns = GetCardIns(adapterName); - if (cardIns == NULL) { - AUDIO_FUNC_LOGE("Get cardIns is failed!!!"); - return HDF_FAILURE; - } - - ret = snd_pcm_prepare(cardIns->capturePcmHandle); + ret = SndPcmPrepare(&captureIns->soundCard); if (ret < 0) { - AUDIO_FUNC_LOGE("snd_pcm_prepare fail! %{public}s.", snd_strerror(ret)); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -int32_t AudioOutputCaptureClose(const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData) -{ - int32_t ret; - struct AudioCardInfo *cardIns; - - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Parameter is NULL!"); + AUDIO_FUNC_LOGE("pcm prepare fail"); return HDF_FAILURE; } - - const char *adapterName = handleData->captureMode.hwInfo.adapterName; - cardIns = GetCardIns(adapterName); - if (cardIns == NULL) { - AUDIO_FUNC_LOGE("cardIns is NULL!"); - return HDF_FAILURE; - } - - AudioMemFree((void **)&cardIns->volElemList); - if (cardIns->capturePcmHandle != NULL) { - (void)snd_pcm_close(cardIns->capturePcmHandle); - cardIns->capturePcmHandle = NULL; - } - - if (cardIns->cardStatus > 0) { - cardIns->cardStatus -= 1; - } - if (cardIns->cardStatus == 0) { - if (cardIns->mixer != NULL) { - (void)snd_mixer_close(cardIns->mixer); - cardIns->mixer = NULL; - } - (void)memset_s(cardIns->cardName, MAX_CARD_NAME_LEN + 1, 0, MAX_CARD_NAME_LEN + 1); - ret = DestroyCardList(); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("DestroyCardList failed: %{public}d.", ret); - return ret; - } - } - + return HDF_SUCCESS; } -int32_t AudioOutputCaptureStop(const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData) +int32_t AudioOutputCaptureStart( + const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData) { int32_t ret; - struct AudioCardInfo *cardIns; - - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Param is NULL!"); - return HDF_FAILURE; - } + struct AlsaCapture *captureIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - const char *adapterName = handleData->captureMode.hwInfo.adapterName; - cardIns = GetCardIns(adapterName); - if (cardIns == NULL) { - AUDIO_FUNC_LOGE("Can't find sound card instance!!!"); - return HDF_FAILURE; - } + captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); - /* pass the remaining samples, otherwise they're dropped in close */ - ret = snd_pcm_drop(cardIns->capturePcmHandle); - if (ret < 0) { - AUDIO_FUNC_LOGE("snd_pcm_drain failed: %{public}s.", snd_strerror(ret)); - return HDF_FAILURE; + ret = captureIns->Start(captureIns); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Capture start failed!"); + return ret; } + AUDIO_FUNC_LOGI("Capture start success."); return HDF_SUCCESS; } -static int32_t UpdateSetParams(struct AudioCardInfo *cardIns) +int32_t AudioOutputCaptureStop( + const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData) { int32_t ret; + struct AlsaCapture *captureIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - if (cardIns == NULL) { - AUDIO_FUNC_LOGE("param is NULL!"); - return HDF_FAILURE; - } + captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); - cardIns->captureMmapFlag = false; - ret = AudioCaptureResetParams(cardIns->capturePcmHandle, cardIns->hwCaptureParams, SND_PCM_ACCESS_MMAP_INTERLEAVED); + ret = captureIns->Stop(captureIns); if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("AudioSetParamsMmap failed!"); + AUDIO_FUNC_LOGE("Capture stop route failed!"); return ret; } - - ret = snd_pcm_start(cardIns->capturePcmHandle); - if (ret < 0) { - AUDIO_FUNC_LOGE("snd_pcm_start fail. %{public}s.", snd_strerror(ret)); - return HDF_FAILURE; - } - + + AUDIO_FUNC_LOGI("Capture stop success."); return HDF_SUCCESS; } -static int32_t MmapDescWriteBufferCapture(const struct AudioHwCaptureParam *handleData) +int32_t AudioOutputCaptureClose( + const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData) { - int32_t ret; - char *mmapAddr; - uint32_t frameSize; - snd_pcm_sframes_t xfer; - snd_pcm_uframes_t size; - struct AudioCardInfo *cardIns; - - if (handleData == NULL) { - AUDIO_FUNC_LOGE("param is NULL!"); - return HDF_FAILURE; - } - - const char *adapterName = handleData->captureMode.hwInfo.adapterName; - cardIns = GetCardIns(adapterName); - if (cardIns == NULL) { - AUDIO_FUNC_LOGE("cardIns is NULL!"); - return HDF_FAILURE; - } + struct AlsaCapture *captureIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - ret = UpdateSetParams(cardIns); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("Update set params failed!"); - return ret; - } + captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); - mmapAddr = (char *)handleData->frameCaptureMode.mmapBufDesc.memoryAddress; - if (mmapAddr == NULL) { - AUDIO_FUNC_LOGE("mmapAddr is NULL!"); - return HDF_FAILURE; - } - size = (snd_pcm_uframes_t)handleData->frameCaptureMode.mmapBufDesc.totalBufferFrames; - frameSize = handleData->frameCaptureMode.attrs.channelCount * handleData->frameCaptureMode.attrs.format; - while (size > 0) { - xfer = snd_pcm_mmap_readi(cardIns->capturePcmHandle, mmapAddr, size); - if (xfer < 0) { - if (xfer == -EAGAIN) { - snd_pcm_wait(cardIns->capturePcmHandle, AUDIO_PCM_WAIT); - continue; - } - AUDIO_FUNC_LOGE("snd_pcm_mmap_readi: %{public}s", snd_strerror(xfer)); - return HDF_FAILURE; - } - - if (xfer > 0) { - mmapAddr += xfer * frameSize; - size -= xfer; - cardIns->capMmapFrames += xfer; - } - } + captureIns->Close(captureIns); + AUDIO_FUNC_LOGI("Capture close success."); return HDF_SUCCESS; } @@ -1344,14 +420,13 @@ int32_t AudioOutputCaptureReqMmapBuffer( const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData) { int32_t ret; + struct AlsaCapture *captureIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("param is NULL!"); - return HDF_FAILURE; - } + captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); - ret = MmapDescWriteBufferCapture(handleData); + ret = captureIns->MmapRead(captureIns, handleData); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("Capture mmap write buffer failed!"); return ret; @@ -1363,21 +438,12 @@ int32_t AudioOutputCaptureReqMmapBuffer( int32_t AudioOutputCaptureGetMmapPosition( const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData) { - struct AudioCardInfo *cardIns; + struct AlsaCapture *captureIns = NULL; + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - (void)cmdId; - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("param is NULL!"); - return HDF_FAILURE; - } - - const char *cardName = handleData->captureMode.hwInfo.adapterName; - cardIns = GetCardIns(cardName); - if (cardIns == NULL) { - AUDIO_FUNC_LOGE("Get cardIns is NULL!"); - return HDF_FAILURE; - } - handleData->frameCaptureMode.frames = cardIns->capMmapFrames; + captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName); + CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); + handleData->frameCaptureMode.frames = captureIns->GetMmapPosition(captureIns); return HDF_SUCCESS; } @@ -1386,11 +452,7 @@ int32_t AudioInterfaceLibOutputCapture( const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData) { int32_t ret; - - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("Parameter is NULL!"); - return HDF_FAILURE; - } + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); switch (cmdId) { case AUDIO_DRV_PCM_IOCTL_HW_PARAMS: @@ -1432,13 +494,10 @@ int32_t AudioInterfaceLibOutputCapture( return ret; } -int32_t AudioInterfaceLibModeCapture(const struct DevHandle *handle, struct AudioHwCaptureParam *handleData, int cmdId) +int32_t AudioInterfaceLibModeCapture( + const struct DevHandle *handle, struct AudioHwCaptureParam *handleData, int cmdId) { - AUDIO_FUNC_LOGI(); - if (handle == NULL || handleData == NULL) { - AUDIO_FUNC_LOGE("paras is NULL!"); - return HDF_FAILURE; - } + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); switch (cmdId) { case AUDIO_DRV_PCM_IOCTL_HW_PARAMS: -- Gitee From a8adc50c022d5a7796862fc42395c7a5b02e6d93 Mon Sep 17 00:00:00 2001 From: xiesicong Date: Fri, 22 Sep 2023 15:12:28 +0800 Subject: [PATCH 09/14] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E6=95=B4=E7=90=86?= =?UTF-8?q?=E6=A0=BC=E5=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xiesicong --- .../alsa_adapter/include/alsa_soundcard.h | 20 +- .../alsa_adapter/src/alsa_lib_capture.c | 4 +- .../alsa_adapter/src/alsa_snd_render.c | 8 +- .../alsa_adapter/src/alsa_soundcard.c | 620 +++++++++--------- 4 files changed, 326 insertions(+), 326 deletions(-) diff --git a/audio/supportlibs/alsa_adapter/include/alsa_soundcard.h b/audio/supportlibs/alsa_adapter/include/alsa_soundcard.h index 2cbc40407c..f3bc7c16b2 100755 --- a/audio/supportlibs/alsa_adapter/include/alsa_soundcard.h +++ b/audio/supportlibs/alsa_adapter/include/alsa_soundcard.h @@ -78,9 +78,9 @@ struct AlsaMixerCtlElement { typedef struct AlsaSoundCard AlsaSoundCard; struct AlsaSoundCard{ - /* - save alsa soundcard base info and hardware params - */ + /* + save alsa soundcard base info and hardware params + */ enum SndCardType cardType; char adapterName[MAX_CARD_NAME_LEN + 1]; //save adapterName char devName[MAX_CARD_NAME_LEN + 1]; //device name hw:x @@ -88,18 +88,18 @@ struct AlsaSoundCard{ char ctrlName[MAX_CARD_NAME_LEN + 1]; struct AudioPcmHwParams hwParams; - /* - alsa soundcard driver handle - */ + /* + alsa soundcard driver handle + */ snd_pcm_t *pcmHandle; snd_mixer_t *mixerHandle; - /* - alsa soundcard public variable - */ + /* + alsa soundcard public variable + */ uint8_t cardStatus; bool canPause; - bool pauseState; + bool pauseState; int32_t muteValue; bool mmapFlag; uint64_t mmapFrames; diff --git a/audio/supportlibs/alsa_adapter/src/alsa_lib_capture.c b/audio/supportlibs/alsa_adapter/src/alsa_lib_capture.c index 13fd484702..d34a2d631c 100644 --- a/audio/supportlibs/alsa_adapter/src/alsa_lib_capture.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_lib_capture.c @@ -226,7 +226,7 @@ int32_t AudioInterfaceLibCtlCapture( { int32_t ret; CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - CHECK_VALID_RANGE_RETURN(cmdId, AUDIODRV_CTL_IOCTL_ELEM_INFO_CAPTURE, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE, HDF_FAILURE); + CHECK_VALID_RANGE_RETURN(cmdId, AUDIODRV_CTL_IOCTL_ELEM_INFO_CAPTURE, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE, HDF_FAILURE); switch (cmdId) { /* setPara: */ @@ -324,7 +324,7 @@ int32_t AudioOutputCaptureOpen( int32_t AudioOutputCaptureRead( - const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData) + const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData) { int32_t ret; struct AlsaCapture *captureIns = NULL; diff --git a/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c b/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c index f01a091523..5b5dbcf6e5 100755 --- a/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c @@ -745,10 +745,10 @@ int32_t RenderWriteImpl(struct AlsaRender *renderIns, const struct AudioHwRender struct AlsaSoundCard *cardIns = (struct AlsaSoundCard*)renderIns; CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); - if(cardIns->pauseState) { - AUDIO_FUNC_LOGE("Currently in pause, please check!"); - return HDF_FAILURE; - } + if(cardIns->pauseState) { + AUDIO_FUNC_LOGE("Currently in pause, please check!"); + return HDF_FAILURE; + } if (!cardIns->mmapFlag) { ret = ResetRenderParams(cardIns, SND_PCM_ACCESS_RW_INTERLEAVED); diff --git a/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c b/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c index 4f1979eb31..f03e34ec33 100755 --- a/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c @@ -32,8 +32,8 @@ struct AlsaAdapterCfgInfo { char cardName[MAX_CARD_NAME_LEN]; }; struct AlsaAdapterList { - int32_t num; - struct AlsaAdapterCfgInfo list[AUDIO_MAX_CARD_NUM]; + int32_t num; + struct AlsaAdapterCfgInfo list[AUDIO_MAX_CARD_NUM]; }; static struct AlsaAdapterList g_alsaAdapterList[SND_CARD_MAX]; @@ -44,7 +44,7 @@ struct AlsaDevInfo { int32_t device; }; struct AlsaCardsList { - int32_t num; + int32_t num; struct AlsaDevInfo alsaDevIns[MAX_CARD_NUM]; }; static struct AlsaCardsList g_alsaCardsDevList; @@ -107,54 +107,54 @@ static char *CfgReadAdapterFile(const char *fpath) static int32_t CfgGetAdapterCount() { - int32_t num = 0; - for(enum SndCardType type = SND_CARD_PRIMARY; type < SND_CARD_MAX; ++type) { - num += g_alsaAdapterList[type].num; - } - return num; + int32_t num = 0; + for(enum SndCardType type = SND_CARD_PRIMARY; type < SND_CARD_MAX; ++type) { + num += g_alsaAdapterList[type].num; + } + return num; } static enum SndCardType CfgGetAdapterCardType(const char* adapterName) { - if(adapterName == NULL) { - return SND_CARD_UNKNOWN; - } - + if(adapterName == NULL) { + return SND_CARD_UNKNOWN; + } + struct AlsaAdapterCfgInfo *info; - for(enum SndCardType type = SND_CARD_PRIMARY; type < SND_CARD_MAX; ++type) { - for(int32_t i = 0; i < g_alsaAdapterList[type].num; ++i) { - info = &g_alsaAdapterList[type].list[i]; - if(strcmp(adapterName, info->adapterName) == 0) { - return type; - } - } - } - return SND_CARD_UNKNOWN; + for(enum SndCardType type = SND_CARD_PRIMARY; type < SND_CARD_MAX; ++type) { + for(int32_t i = 0; i < g_alsaAdapterList[type].num; ++i) { + info = &g_alsaAdapterList[type].list[i]; + if(strcmp(adapterName, info->adapterName) == 0) { + return type; + } + } + } + return SND_CARD_UNKNOWN; } static struct AlsaAdapterCfgInfo *CfgGetAdapterInfo(const char* adapterName) { - if(adapterName == NULL) { - return NULL; - } - + if(adapterName == NULL) { + return NULL; + } + struct AlsaAdapterCfgInfo *info; - for(enum SndCardType type = SND_CARD_PRIMARY; type < SND_CARD_MAX; ++type) { - for(int32_t i = 0; i < g_alsaAdapterList[type].num; ++i) { - info = &g_alsaAdapterList[type].list[i]; - if(strcmp(adapterName, info->adapterName) == 0) { - return info; - } - } - } - return NULL; + for(enum SndCardType type = SND_CARD_PRIMARY; type < SND_CARD_MAX; ++type) { + for(int32_t i = 0; i < g_alsaAdapterList[type].num; ++i) { + info = &g_alsaAdapterList[type].list[i]; + if(strcmp(adapterName, info->adapterName) == 0) { + return info; + } + } + } + return NULL; } static int32_t CfgDumpAdapterInfo(struct AlsaAdapterCfgInfo *info) { - int32_t ret, idx; + int32_t ret, idx; enum SndCardType cardType = SND_CARD_UNKNOWN; - CHECK_NULL_PTR_RETURN_DEFAULT(info); + CHECK_NULL_PTR_RETURN_DEFAULT(info); if (strcmp(info->adapterName, "primary") == 0) { cardType = SND_CARD_PRIMARY; @@ -166,63 +166,63 @@ static int32_t CfgDumpAdapterInfo(struct AlsaAdapterCfgInfo *info) cardType = SND_CARD_BT; } - if(cardType == SND_CARD_UNKNOWN) { - AUDIO_FUNC_LOGE("Error: %{public}s is unspupported adapter name", info->adapterName); - } - - idx = g_alsaAdapterList[cardType].num; - ret = memcpy_s((void*)&g_alsaAdapterList[cardType].list[idx], sizeof(struct AlsaAdapterCfgInfo), - (void*)info, sizeof(struct AlsaAdapterCfgInfo)); - if (ret != EOK) { - AUDIO_FUNC_LOGE("memcpy_s g_alsaAdapterList fail!"); - return HDF_FAILURE; - } - g_alsaAdapterList[cardType].num++; - - AUDIO_FUNC_LOGI("cardId:%{public}d: adapterName:%{public}s, cardName:%{public}s", - g_alsaAdapterList[cardType].list[idx].cardId, - g_alsaAdapterList[cardType].list[idx].adapterName, - g_alsaAdapterList[cardType].list[idx].cardName); - return HDF_SUCCESS; + if(cardType == SND_CARD_UNKNOWN) { + AUDIO_FUNC_LOGE("Error: %{public}s is unspupported adapter name", info->adapterName); + } + + idx = g_alsaAdapterList[cardType].num; + ret = memcpy_s((void*)&g_alsaAdapterList[cardType].list[idx], sizeof(struct AlsaAdapterCfgInfo), + (void*)info, sizeof(struct AlsaAdapterCfgInfo)); + if (ret != EOK) { + AUDIO_FUNC_LOGE("memcpy_s g_alsaAdapterList fail!"); + return HDF_FAILURE; + } + g_alsaAdapterList[cardType].num++; + + AUDIO_FUNC_LOGI("cardId:%{public}d: adapterName:%{public}s, cardName:%{public}s", + g_alsaAdapterList[cardType].list[idx].cardId, + g_alsaAdapterList[cardType].list[idx].adapterName, + g_alsaAdapterList[cardType].list[idx].cardName); + return HDF_SUCCESS; } static int32_t CfgSaveAdapterStruct(cJSON *adapter, struct AlsaAdapterCfgInfo *info) { - int32_t ret; - cJSON *item; - CHECK_NULL_PTR_RETURN_DEFAULT(adapter); - CHECK_NULL_PTR_RETURN_DEFAULT(info); - - item = cJSON_GetObjectItem(adapter, "name"); - if (item == NULL || item->valuestring == NULL) { - AUDIO_FUNC_LOGE("adapter name is null!"); - return HDF_FAILURE; - } - ret = memcpy_s(info->adapterName, MAX_CARD_NAME_LEN - 1, item->valuestring, MAX_CARD_NAME_LEN - 1); - if (ret != EOK) { - AUDIO_FUNC_LOGE("memcpy_s adapterName fail!"); - return HDF_FAILURE; - } - - item = cJSON_GetObjectItem(adapter, "cardId"); - if (item == NULL) { - AUDIO_FUNC_LOGE("cardId not set!"); - return HDF_FAILURE; - } - info->cardId = item->valuedouble; - - item = cJSON_GetObjectItem(adapter, "cardName"); - if (item == NULL || item->valuestring == NULL) { - AUDIO_FUNC_LOGE("cardName is null!"); - return HDF_FAILURE; - } - ret = memcpy_s(info->cardName, MAX_CARD_NAME_LEN - 1, item->valuestring, MAX_CARD_NAME_LEN - 1); - if (ret != EOK) { - AUDIO_FUNC_LOGE("memcpy_s cardName fail!"); - return HDF_FAILURE; - } - - return HDF_SUCCESS; + int32_t ret; + cJSON *item; + CHECK_NULL_PTR_RETURN_DEFAULT(adapter); + CHECK_NULL_PTR_RETURN_DEFAULT(info); + + item = cJSON_GetObjectItem(adapter, "name"); + if (item == NULL || item->valuestring == NULL) { + AUDIO_FUNC_LOGE("adapter name is null!"); + return HDF_FAILURE; + } + ret = memcpy_s(info->adapterName, MAX_CARD_NAME_LEN - 1, item->valuestring, MAX_CARD_NAME_LEN - 1); + if (ret != EOK) { + AUDIO_FUNC_LOGE("memcpy_s adapterName fail!"); + return HDF_FAILURE; + } + + item = cJSON_GetObjectItem(adapter, "cardId"); + if (item == NULL) { + AUDIO_FUNC_LOGE("cardId not set!"); + return HDF_FAILURE; + } + info->cardId = item->valuedouble; + + item = cJSON_GetObjectItem(adapter, "cardName"); + if (item == NULL || item->valuestring == NULL) { + AUDIO_FUNC_LOGE("cardName is null!"); + return HDF_FAILURE; + } + ret = memcpy_s(info->cardName, MAX_CARD_NAME_LEN - 1, item->valuestring, MAX_CARD_NAME_LEN - 1); + if (ret != EOK) { + AUDIO_FUNC_LOGE("memcpy_s cardName fail!"); + return HDF_FAILURE; + } + + return HDF_SUCCESS; } static int32_t CfgSaveAdapterFromFile(void) @@ -230,13 +230,13 @@ static int32_t CfgSaveAdapterFromFile(void) int32_t ret, adapterNum; cJSON *adapterObj = NULL; cJSON *adapterItems = NULL; - char *configBuf = NULL; + char *configBuf = NULL; configBuf = CfgReadAdapterFile(ALSA_CARD_CONFIG_FILE); - if (configBuf == NULL) { - AUDIO_FUNC_LOGE("CfgReadAdapterFile failed!"); - return HDF_FAILURE; - } + if (configBuf == NULL) { + AUDIO_FUNC_LOGE("CfgReadAdapterFile failed!"); + return HDF_FAILURE; + } adapterObj = cJSON_Parse(configBuf); if (adapterObj == NULL) { AUDIO_FUNC_LOGE("Parse json file failed!"); @@ -245,7 +245,7 @@ static int32_t CfgSaveAdapterFromFile(void) } AudioMemFree((void **)&configBuf); - adapterItems = cJSON_GetObjectItem(adapterObj, "adapters"); + adapterItems = cJSON_GetObjectItem(adapterObj, "adapters"); if (adapterItems == NULL) { AUDIO_FUNC_LOGE("Get adapterItems from json failed!\n"); cJSON_Delete(adapterObj); @@ -264,181 +264,181 @@ static int32_t CfgSaveAdapterFromFile(void) } for(int32_t i = 0; i < adapterNum; ++i) { - cJSON *adapter; - struct AlsaAdapterCfgInfo info; + cJSON *adapter; + struct AlsaAdapterCfgInfo info; adapter = cJSON_GetArrayItem(adapterItems, i); - if(adapter == NULL) { - AUDIO_FUNC_LOGE("Get adapter item from array failed!"); - cJSON_Delete(adapterObj); - } - - ret = CfgSaveAdapterStruct(adapter, &info); - if(ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("CfgSaveAdapterStruct failed!"); - cJSON_Delete(adapterObj); - return HDF_FAILURE; - } - - ret = CfgDumpAdapterInfo(&info); - if(ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("CfgDumpAdapterInfo failed!"); - cJSON_Delete(adapterObj); - return HDF_FAILURE; - } - } - - return HDF_SUCCESS; + if(adapter == NULL) { + AUDIO_FUNC_LOGE("Get adapter item from array failed!"); + cJSON_Delete(adapterObj); + } + + ret = CfgSaveAdapterStruct(adapter, &info); + if(ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("CfgSaveAdapterStruct failed!"); + cJSON_Delete(adapterObj); + return HDF_FAILURE; + } + + ret = CfgDumpAdapterInfo(&info); + if(ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("CfgDumpAdapterInfo failed!"); + cJSON_Delete(adapterObj); + return HDF_FAILURE; + } + } + + return HDF_SUCCESS; } static struct AlsaDevInfo *DevGetInfoByCardId(int32_t cardId) { - struct AlsaDevInfo * info = NULL; - int num = g_alsaCardsDevList.num; - for(int i = 0; i < num; ++i) { - info = &g_alsaCardsDevList.alsaDevIns[i]; - if(info->card == cardId) { - return info; - } - } - return NULL; + struct AlsaDevInfo * info = NULL; + int num = g_alsaCardsDevList.num; + for(int i = 0; i < num; ++i) { + info = &g_alsaCardsDevList.alsaDevIns[i]; + if(info->card == cardId) { + return info; + } + } + return NULL; } static struct AlsaDevInfo *DevGetInfoByPcmInfoId(const char * name) { - struct AlsaDevInfo *info = NULL; - int num = g_alsaCardsDevList.num; - for(int i = 0; i < num; ++i) { - info = &g_alsaCardsDevList.alsaDevIns[i]; - if(strcmp(name, info->pcmInfoId) == 0) { - return info; - } - } + struct AlsaDevInfo *info = NULL; + int num = g_alsaCardsDevList.num; + for(int i = 0; i < num; ++i) { + info = &g_alsaCardsDevList.alsaDevIns[i]; + if(strcmp(name, info->pcmInfoId) == 0) { + return info; + } + } return NULL; } static int32_t DevSaveCardPcmInfo(snd_ctl_t *handle, snd_pcm_stream_t stream, int card, const char *deviceName) { - int32_t ret; - int pcmDev = -1; + int32_t ret; + int pcmDev = -1; snd_ctl_card_info_t *info = NULL; snd_pcm_info_t *pcminfo = NULL; - snd_ctl_card_info_alloca(&info); - snd_pcm_info_alloca(&pcminfo); + snd_ctl_card_info_alloca(&info); + snd_pcm_info_alloca(&pcminfo); - ret = snd_ctl_card_info(handle, info); - if(ret != 0) { - AUDIO_FUNC_LOGE("snd_ctl_card_info failed."); - return HDF_FAILURE; - } + ret = snd_ctl_card_info(handle, info); + if(ret != 0) { + AUDIO_FUNC_LOGE("snd_ctl_card_info failed."); + return HDF_FAILURE; + } - ret = snd_ctl_pcm_next_device(handle, &pcmDev); - if(ret < 0 || pcmDev < 0) { + ret = snd_ctl_pcm_next_device(handle, &pcmDev); + if(ret < 0 || pcmDev < 0) { AUDIO_FUNC_LOGE("No pcm device found: %{public}s.", snd_strerror(ret)); - return HDF_FAILURE; - } + return HDF_FAILURE; + } - while(pcmDev >= 0) { + while(pcmDev >= 0) { snd_pcm_info_set_device(pcminfo, pcmDev); snd_pcm_info_set_subdevice(pcminfo, 0); snd_pcm_info_set_stream(pcminfo, stream); - ret = snd_ctl_pcm_info(handle, pcminfo); - if(ret < 0) { - if (ret != -ENOENT) { + ret = snd_ctl_pcm_info(handle, pcminfo); + if(ret < 0) { + if (ret != -ENOENT) { AUDIO_FUNC_LOGE("control digital audio info (%{public}d): %{public}s", pcmDev, snd_strerror(ret)); } continue; - } + } - struct AlsaDevInfo *devInfo = &g_alsaCardsDevList.alsaDevIns[g_alsaCardsDevList.num]; + struct AlsaDevInfo *devInfo = &g_alsaCardsDevList.alsaDevIns[g_alsaCardsDevList.num]; const char *cardId = snd_ctl_card_info_get_id(info); const char *pcmInfoId = snd_pcm_info_get_id(pcminfo); - CHECK_NULL_PTR_RETURN_DEFAULT(cardId); - CHECK_NULL_PTR_RETURN_DEFAULT(pcmInfoId); - AUDIO_FUNC_LOGE("card %{public}s: pcm: %{public}s", cardId, pcmInfoId); - - devInfo->card = card; - devInfo->device = pcmDev; - ret = strncpy_s(devInfo->cardId, MAX_CARD_NAME_LEN + 1, cardId, strlen(cardId)); - if (ret != 0) { - AUDIO_FUNC_LOGE("strncpy_s failed!"); - return HDF_FAILURE; - } - ret = strncpy_s(devInfo->pcmInfoId, MAX_CARD_NAME_LEN + 1, pcmInfoId, strlen(pcmInfoId)); - if (ret != 0) { - AUDIO_FUNC_LOGE("strncpy_s failed!"); - return HDF_FAILURE; - } - g_alsaCardsDevList.num++; - - ret = snd_ctl_pcm_next_device(handle, &pcmDev); - if(ret < 0) { - AUDIO_FUNC_LOGE("snd_ctl_pcm_next_device error: %{public}s.", snd_strerror(ret)); - return HDF_FAILURE; - } - } - - return HDF_SUCCESS; + CHECK_NULL_PTR_RETURN_DEFAULT(cardId); + CHECK_NULL_PTR_RETURN_DEFAULT(pcmInfoId); + AUDIO_FUNC_LOGE("card %{public}s: pcm: %{public}s", cardId, pcmInfoId); + + devInfo->card = card; + devInfo->device = pcmDev; + ret = strncpy_s(devInfo->cardId, MAX_CARD_NAME_LEN + 1, cardId, strlen(cardId)); + if (ret != 0) { + AUDIO_FUNC_LOGE("strncpy_s failed!"); + return HDF_FAILURE; + } + ret = strncpy_s(devInfo->pcmInfoId, MAX_CARD_NAME_LEN + 1, pcmInfoId, strlen(pcmInfoId)); + if (ret != 0) { + AUDIO_FUNC_LOGE("strncpy_s failed!"); + return HDF_FAILURE; + } + g_alsaCardsDevList.num++; + + ret = snd_ctl_pcm_next_device(handle, &pcmDev); + if(ret < 0) { + AUDIO_FUNC_LOGE("snd_ctl_pcm_next_device error: %{public}s.", snd_strerror(ret)); + return HDF_FAILURE; + } + } + + return HDF_SUCCESS; } static int32_t DevSaveDriverInfo(snd_pcm_stream_t stream) { int32_t ret; - snd_ctl_t *handle; + snd_ctl_t *handle; int card = -1; char deviceName[MAX_CARD_NAME_LEN] = {0}; - ret = snd_card_next(&card); + ret = snd_card_next(&card); if (ret < 0 || card < 0) { AUDIO_FUNC_LOGE("No soundcards found: %{public}s.", snd_strerror(ret)); return HDF_FAILURE; } - while (card >= 0) { + while (card >= 0) { (void)memset_s(deviceName, MAX_CARD_NAME_LEN, 0, MAX_CARD_NAME_LEN); ret = snprintf_s(deviceName, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "hw:%d", card); if (ret < 0) { AUDIO_FUNC_LOGE("snprintf_s failed"); - snd_ctl_close(handle); + snd_ctl_close(handle); return HDF_FAILURE; } - ret = snd_ctl_open(&handle, deviceName, 0); - if(ret != 0) { - AUDIO_FUNC_LOGE("snd_ctl_open failed."); - return HDF_FAILURE; - } - - ret = DevSaveCardPcmInfo(handle, stream, card, deviceName); - if(ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("save alsa sound cards %{public}s pcm info failed!",deviceName); - } - - ret = snd_ctl_close(handle); - if (ret < 0) { - AUDIO_FUNC_LOGE("snd_ctl_close error: %{public}s.", snd_strerror(ret)); - return HDF_FAILURE; - } + ret = snd_ctl_open(&handle, deviceName, 0); + if(ret != 0) { + AUDIO_FUNC_LOGE("snd_ctl_open failed."); + return HDF_FAILURE; + } + + ret = DevSaveCardPcmInfo(handle, stream, card, deviceName); + if(ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("save alsa sound cards %{public}s pcm info failed!",deviceName); + } + + ret = snd_ctl_close(handle); + if (ret < 0) { + AUDIO_FUNC_LOGE("snd_ctl_close error: %{public}s.", snd_strerror(ret)); + return HDF_FAILURE; + } ret = snd_card_next(&card); if (ret < 0) { AUDIO_FUNC_LOGE("snd_card_next error: %{public}s", snd_strerror(ret)); return HDF_FAILURE; } - } + } - return HDF_SUCCESS; + return HDF_SUCCESS; } int32_t SndSaveCardListInfo(snd_pcm_stream_t stream) { - int32_t ret; + int32_t ret; (void)memset_s(&g_alsaAdapterList, sizeof(struct AlsaAdapterList) * SND_CARD_MAX, - 0, sizeof(struct AlsaAdapterList) * SND_CARD_MAX); + 0, sizeof(struct AlsaAdapterList) * SND_CARD_MAX); (void)memset_s(&g_alsaCardsDevList, sizeof(struct AlsaCardsList), - 0, sizeof(struct AlsaCardsList)); + 0, sizeof(struct AlsaCardsList)); /* Parse sound card from configuration file */ ret = CfgSaveAdapterFromFile(); @@ -448,23 +448,23 @@ int32_t SndSaveCardListInfo(snd_pcm_stream_t stream) } /* Read sound card list from alsa hardware */ - ret = DevSaveDriverInfo(stream); + ret = DevSaveDriverInfo(stream); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("failed to save alsa sound cards driver info"); return HDF_FAILURE; } - /* if the alsa hardware include usb then add to adapter list */ - struct AlsaDevInfo *devInfo = DevGetInfoByPcmInfoId(USB_AUDIO); - if(devInfo != NULL) { - g_alsaAdapterList[SND_CARD_USB].num = 1; - ret = memcpy_s((void*)&g_alsaAdapterList[SND_CARD_USB].list[0].adapterName, MAX_CARD_NAME_LEN, - USB_AUDIO, sizeof(USB_AUDIO)); - if (ret != EOK) { - AUDIO_FUNC_LOGE("memcpy_s adapterName fail!"); - return HDF_FAILURE; - } - } + /* if the alsa hardware include usb then add to adapter list */ + struct AlsaDevInfo *devInfo = DevGetInfoByPcmInfoId(USB_AUDIO); + if(devInfo != NULL) { + g_alsaAdapterList[SND_CARD_USB].num = 1; + ret = memcpy_s((void*)&g_alsaAdapterList[SND_CARD_USB].list[0].adapterName, MAX_CARD_NAME_LEN, + USB_AUDIO, sizeof(USB_AUDIO)); + if (ret != EOK) { + AUDIO_FUNC_LOGE("memcpy_s adapterName fail!"); + return HDF_FAILURE; + } + } return HDF_SUCCESS; } @@ -472,46 +472,46 @@ int32_t SndSaveCardListInfo(snd_pcm_stream_t stream) int32_t SndMatchSelAdapter(struct AlsaSoundCard *cardIns, const char *adapterName) { int32_t ret; - enum SndCardType cardType; - struct AlsaAdapterCfgInfo *info = NULL; - struct AlsaDevInfo * devInfo = NULL; + enum SndCardType cardType; + struct AlsaAdapterCfgInfo *info = NULL; + struct AlsaDevInfo * devInfo = NULL; CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); CHECK_NULL_PTR_RETURN_DEFAULT(adapterName); - cardType = CfgGetAdapterCardType(adapterName); - if(cardType == SND_CARD_UNKNOWN) { - AUDIO_FUNC_LOGE("unknow card type error."); - return HDF_FAILURE; - } - cardIns->cardType = cardType; + cardType = CfgGetAdapterCardType(adapterName); + if(cardType == SND_CARD_UNKNOWN) { + AUDIO_FUNC_LOGE("unknow card type error."); + return HDF_FAILURE; + } + cardIns->cardType = cardType; - info = CfgGetAdapterInfo(adapterName); - if(info == NULL) { + info = CfgGetAdapterInfo(adapterName); + if(info == NULL) { AUDIO_FUNC_LOGE("adapter %{public}s is not exits.", cardIns->adapterName); return HDF_FAILURE; - } + } - devInfo = DevGetInfoByCardId(info->cardId); - if(devInfo == NULL) { + devInfo = DevGetInfoByCardId(info->cardId); + if(devInfo == NULL) { AUDIO_FUNC_LOGE("adapter %{public}s cant not find sound card device.", cardIns->adapterName); return HDF_FAILURE; - } + } ret = snprintf_s(cardIns->devName, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "hw:%d,%d", devInfo->card, devInfo->device); - if(ret < 0) { + if(ret < 0) { AUDIO_FUNC_LOGE("%{public}s snprintf_s devName failed",cardIns->adapterName); - return HDF_FAILURE; - } - ret = snprintf_s(cardIns->ctrlName, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "hw:%d", devInfo->card); - if(ret < 0) { + return HDF_FAILURE; + } + ret = snprintf_s(cardIns->ctrlName, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "hw:%d", devInfo->card); + if(ret < 0) { AUDIO_FUNC_LOGE("%{public}s snprintf_s ctrlName failed",cardIns->adapterName); - return HDF_FAILURE; - } - ret = snprintf_s(cardIns->alsaCardId, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "%s", devInfo->cardId); - if(ret < 0) { + return HDF_FAILURE; + } + ret = snprintf_s(cardIns->alsaCardId, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "%s", devInfo->cardId); + if(ret < 0) { AUDIO_FUNC_LOGE("%{public}s snprintf_s alsaCardId failed",cardIns->adapterName); - return HDF_FAILURE; - } + return HDF_FAILURE; + } return HDF_SUCCESS; } @@ -539,7 +539,7 @@ int32_t SndConverAlsaPcmFormat(const struct AudioPcmHwParams *hwParams, snd_pcm_ *alsaPcmFormat = SND_PCM_FORMAT_S32_LE; /** Signed 32 bit Little Endian */ break; default: - AUDIO_FUNC_LOGE("not support format %{public}d",audioFormat); + AUDIO_FUNC_LOGE("not support format %{public}d",audioFormat); return HDF_ERR_NOT_SUPPORT; } } else { /** Big Endian */ @@ -557,7 +557,7 @@ int32_t SndConverAlsaPcmFormat(const struct AudioPcmHwParams *hwParams, snd_pcm_ *alsaPcmFormat = SND_PCM_FORMAT_S32_BE; /** Signed 32 bit Big Endian */ break; default: - AUDIO_FUNC_LOGE("not support format %{public}d",audioFormat); + AUDIO_FUNC_LOGE("not support format %{public}d",audioFormat); return HDF_ERR_NOT_SUPPORT; } } @@ -589,12 +589,12 @@ int32_t SndPcmPause(struct AlsaSoundCard *cardIns, bool state) } } else { if(enable == AUDIO_ALSALIB_IOCTRL_PAUSE) { - snd_pcm_drop(cardIns->pcmHandle); + snd_pcm_drop(cardIns->pcmHandle); } else { - snd_pcm_prepare(cardIns->pcmHandle); - } + snd_pcm_prepare(cardIns->pcmHandle); + } } - cardIns->pauseState = state; + cardIns->pauseState = state; return HDF_SUCCESS; } @@ -695,86 +695,86 @@ static void AudioInitPortOutAndIn(struct AudioPort *audioPort) static int32_t AudioInitPorts(struct AudioAdapterDescriptor *desc, enum SndCardType type) { - uint8_t portNum; - CHECK_NULL_PTR_RETURN_DEFAULT(desc); - - switch(type) - { - case SND_CARD_PRIMARY: - portNum = PORT_OUT_IN; - break; - case SND_CARD_HDMI: - portNum = PORT_OUT; - break; - case SND_CARD_USB: - portNum = PORT_IN; - break; - default: - AUDIO_FUNC_LOGE("Unknown sound card type does not support this sound card temporarily!"); + uint8_t portNum; + CHECK_NULL_PTR_RETURN_DEFAULT(desc); + + switch(type) + { + case SND_CARD_PRIMARY: + portNum = PORT_OUT_IN; + break; + case SND_CARD_HDMI: + portNum = PORT_OUT; + break; + case SND_CARD_USB: + portNum = PORT_IN; + break; + default: + AUDIO_FUNC_LOGE("Unknown sound card type does not support this sound card temporarily!"); return HDF_FAILURE; - } + } #ifndef AUDIO_HDI_SERVICE_MODE - desc->portNum = portNum; + desc->portNum = portNum; #else - desc->portsLen = portNum; + desc->portsLen = portNum; #endif - desc->ports = (struct AudioPort *)OsalMemCalloc(sizeof(struct AudioPort) * portNum); - if (desc->ports == NULL) { - AUDIO_FUNC_LOGE("OsalMemCalloc failed!"); - return HDF_ERR_MALLOC_FAIL; - } - - if(type == SND_CARD_PRIMARY) { - AudioInitPortOut(&desc->ports[0]); - AudioInitPortIn(&desc->ports[SUPPORT_CAPTURE_OR_RENDER]); - AudioInitPortOutAndIn(&desc->ports[SUPPORT_CAPTURE_AND_RENDER]); - } else if (type == SND_CARD_HDMI) { - AudioInitPortOut(&desc->ports[0]); - } else if (type == SND_CARD_USB) { - AudioInitPortOut(&desc->ports[0]); - AudioInitPortIn(&desc->ports[SUPPORT_CAPTURE_OR_RENDER]); - } else { - AUDIO_FUNC_LOGE("adapter list not support sound card type %{public}d", type); - return HDF_FAILURE; - } - - return HDF_SUCCESS; + desc->ports = (struct AudioPort *)OsalMemCalloc(sizeof(struct AudioPort) * portNum); + if (desc->ports == NULL) { + AUDIO_FUNC_LOGE("OsalMemCalloc failed!"); + return HDF_ERR_MALLOC_FAIL; + } + + if(type == SND_CARD_PRIMARY) { + AudioInitPortOut(&desc->ports[0]); + AudioInitPortIn(&desc->ports[SUPPORT_CAPTURE_OR_RENDER]); + AudioInitPortOutAndIn(&desc->ports[SUPPORT_CAPTURE_AND_RENDER]); + } else if (type == SND_CARD_HDMI) { + AudioInitPortOut(&desc->ports[0]); + } else if (type == SND_CARD_USB) { + AudioInitPortOut(&desc->ports[0]); + AudioInitPortIn(&desc->ports[SUPPORT_CAPTURE_OR_RENDER]); + } else { + AUDIO_FUNC_LOGE("adapter list not support sound card type %{public}d", type); + return HDF_FAILURE; + } + + return HDF_SUCCESS; } int32_t AudioGetAllCardInfo(struct AudioAdapterDescriptor **descs, int32_t *sndCardNum) { int32_t ret, idx; - int32_t adapterNum; - CHECK_NULL_PTR_RETURN_DEFAULT(descs); - CHECK_NULL_PTR_RETURN_DEFAULT(sndCardNum); + int32_t adapterNum; + CHECK_NULL_PTR_RETURN_DEFAULT(descs); + CHECK_NULL_PTR_RETURN_DEFAULT(sndCardNum); ret = SndSaveCardListInfo(SND_PCM_STREAM_PLAYBACK); if (ret != HDF_SUCCESS) { return HDF_FAILURE; } - adapterNum = CfgGetAdapterCount(); - if (*descs == NULL) { - AUDIO_FUNC_LOGW("*descs is null, need memcalloc."); - *descs = (struct AudioAdapterDescriptor *)OsalMemCalloc(sizeof(struct AudioAdapterDescriptor) * adapterNum); - if (*descs == NULL) { - AUDIO_FUNC_LOGE("OsalMemCalloc descs is NULL"); - return HDF_ERR_MALLOC_FAIL; - } - } - *sndCardNum = adapterNum; + adapterNum = CfgGetAdapterCount(); + if (*descs == NULL) { + AUDIO_FUNC_LOGW("*descs is null, need memcalloc."); + *descs = (struct AudioAdapterDescriptor *)OsalMemCalloc(sizeof(struct AudioAdapterDescriptor) * adapterNum); + if (*descs == NULL) { + AUDIO_FUNC_LOGE("OsalMemCalloc descs is NULL"); + return HDF_ERR_MALLOC_FAIL; + } + } + *sndCardNum = adapterNum; idx = 0; - for(enum SndCardType type = SND_CARD_PRIMARY; type < SND_CARD_MAX; ++type) { - for(int32_t i = 0; i < g_alsaAdapterList[type].num; ++i) { - (*descs)[idx].adapterName = strdup(g_alsaAdapterList[type].list[i].adapterName); - AudioInitPorts(&(*descs)[idx], type); - AUDIO_FUNC_LOGI("adapter name : %{public}s", (*descs)[idx].adapterName); - idx++; - } - } + for(enum SndCardType type = SND_CARD_PRIMARY; type < SND_CARD_MAX; ++type) { + for(int32_t i = 0; i < g_alsaAdapterList[type].num; ++i) { + (*descs)[idx].adapterName = strdup(g_alsaAdapterList[type].list[i].adapterName); + AudioInitPorts(&(*descs)[idx], type); + AUDIO_FUNC_LOGI("adapter name : %{public}s", (*descs)[idx].adapterName); + idx++; + } + } return HDF_SUCCESS; } -- Gitee From cc3e9746f6f827c556400ecb0a4d5af75950d449 Mon Sep 17 00:00:00 2001 From: xiesicong Date: Fri, 22 Sep 2023 17:26:54 +0800 Subject: [PATCH 10/14] =?UTF-8?q?=E4=BF=AE=E6=94=B9BUILD.gn=E6=A0=BC?= =?UTF-8?q?=E5=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xiesicong --- audio/hdi_service/supportlibs/BUILD.gn | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/audio/hdi_service/supportlibs/BUILD.gn b/audio/hdi_service/supportlibs/BUILD.gn index 385878a8a6..f60a9652fa 100644 --- a/audio/hdi_service/supportlibs/BUILD.gn +++ b/audio/hdi_service/supportlibs/BUILD.gn @@ -159,7 +159,7 @@ if (defined(ohos_lite)) { "//third_party/cJSON", "//third_party/alsa-lib/include", "$hdf_audio_path/supportlibs/alsa_adapter/include", - "//device/board/${product_company}/${device_name}/audio_alsa", + "//device/board/${product_company}/${device_name}/audio_alsa", ] public_deps += [ "//third_party/alsa-lib:libasound" ] } else { -- Gitee From d9824e412cc33b0963ee804d6251f50f73c9ca83 Mon Sep 17 00:00:00 2001 From: xiesicong Date: Mon, 25 Sep 2023 14:14:10 +0800 Subject: [PATCH 11/14] =?UTF-8?q?=E4=BF=AE=E6=94=B9audiocardconfig=5Ffuzze?= =?UTF-8?q?r=20=E4=BE=9D=E8=B5=96=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xiesicong --- audio/supportlibs/alsa_adapter/src/alsa_soundcard.c | 2 +- .../audio_config_fuzzer/audiocardconfig_fuzzer/BUILD.gn | 3 ++- .../audiocardconfig_fuzzer/audiocardconfig_fuzzer.cpp | 4 ++-- 3 files changed, 5 insertions(+), 4 deletions(-) diff --git a/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c b/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c index f03e34ec33..303c895a04 100755 --- a/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c @@ -225,7 +225,7 @@ static int32_t CfgSaveAdapterStruct(cJSON *adapter, struct AlsaAdapterCfgInfo *i return HDF_SUCCESS; } -static int32_t CfgSaveAdapterFromFile(void) +int32_t CfgSaveAdapterFromFile(void) { int32_t ret, adapterNum; cJSON *adapterObj = NULL; diff --git a/audio/test/fuzztest/audio_config_fuzzer/audiocardconfig_fuzzer/BUILD.gn b/audio/test/fuzztest/audio_config_fuzzer/audiocardconfig_fuzzer/BUILD.gn index e2b9378d48..b7c307c085 100644 --- a/audio/test/fuzztest/audio_config_fuzzer/audiocardconfig_fuzzer/BUILD.gn +++ b/audio/test/fuzztest/audio_config_fuzzer/audiocardconfig_fuzzer/BUILD.gn @@ -24,10 +24,11 @@ ohos_fuzztest("AudioCardConfigFuzzTest") { sources = [ "$hdf_audio_path/hal/hdi_passthrough/src/audio_common.c", - "$hdf_audio_path/supportlibs/alsa_adapter/src/alsa_lib_common.c", + "$hdf_audio_path/supportlibs/alsa_adapter/src/alsa_soundcard.c", "audiocardconfig_fuzzer.cpp", ] include_dirs = [ + "$hdf_audio_path/hdi_service/vendor_interface/utils", "$hdf_audio_path/hal/hdi_passthrough/include", "$hdf_audio_path/supportlibs/alsa_adapter/include", "$hdf_audio_path/supportlibs/interfaces/include", diff --git a/audio/test/fuzztest/audio_config_fuzzer/audiocardconfig_fuzzer/audiocardconfig_fuzzer.cpp b/audio/test/fuzztest/audio_config_fuzzer/audiocardconfig_fuzzer/audiocardconfig_fuzzer.cpp index 6dfedec83d..963eaeaf2a 100644 --- a/audio/test/fuzztest/audio_config_fuzzer/audiocardconfig_fuzzer/audiocardconfig_fuzzer.cpp +++ b/audio/test/fuzztest/audio_config_fuzzer/audiocardconfig_fuzzer/audiocardconfig_fuzzer.cpp @@ -20,7 +20,7 @@ #ifdef __cplusplus extern "C" { - int32_t CardInfoParseFromConfig(void); + int32_t CfgSaveAdapterFromFile(void); } #endif @@ -40,7 +40,7 @@ static bool DoSomethingInterestingWithMyAPI(const uint8_t *rawData, size_t size) close(fd); // Call the interface with the temporary file - int32_t ret = CardInfoParseFromConfig(); + int32_t ret = CfgSaveAdapterFromFile(); if (ret != HDF_SUCCESS) { return false; } -- Gitee From 6130d2a44eca8cf8d7c4dc4c01d201c056220513 Mon Sep 17 00:00:00 2001 From: xiesicong Date: Mon, 25 Sep 2023 16:02:39 +0800 Subject: [PATCH 12/14] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E5=87=A0=E4=B8=AA?= =?UTF-8?q?=E6=96=87=E4=BB=B6=E7=9A=84=E6=A0=BC=E5=BC=8F=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xiesicong --- audio/supportlibs/alsa_adapter/include/alsa_snd_capture.h | 4 ++-- audio/supportlibs/alsa_adapter/include/alsa_snd_render.h | 4 ++-- audio/supportlibs/alsa_adapter/include/alsa_soundcard.h | 3 +-- 3 files changed, 5 insertions(+), 6 deletions(-) diff --git a/audio/supportlibs/alsa_adapter/include/alsa_snd_capture.h b/audio/supportlibs/alsa_adapter/include/alsa_snd_capture.h index 9e44236cd2..d5f05a89e7 100755 --- a/audio/supportlibs/alsa_adapter/include/alsa_snd_capture.h +++ b/audio/supportlibs/alsa_adapter/include/alsa_snd_capture.h @@ -36,7 +36,7 @@ struct AlsaCapture{ unsigned int periodTime; /* (0.1s): period time in us */ int resample; /* enable alsa-lib resampling */ CapturePriData priData; - + /* Capture scene */ int32_t (*Init)(struct AlsaCapture*); int32_t (*Open)(struct AlsaCapture *); @@ -71,7 +71,7 @@ CapturePriData CaptureGetPriData(struct AlsaCapture *captureIns); /* Different platforms implement this function rewriting capture implementation - */ +*/ int32_t CaptureOverrideFunc(struct AlsaCapture *captureIns); #ifdef __cplusplus diff --git a/audio/supportlibs/alsa_adapter/include/alsa_snd_render.h b/audio/supportlibs/alsa_adapter/include/alsa_snd_render.h index b4327566aa..da56e41c78 100755 --- a/audio/supportlibs/alsa_adapter/include/alsa_snd_render.h +++ b/audio/supportlibs/alsa_adapter/include/alsa_snd_render.h @@ -35,7 +35,7 @@ struct AlsaRender{ unsigned int bufferTime; /* (0.5s): ring buffer length in us */ unsigned int periodTime; /* (0.1s): period time in us */ RenderPriData priData; - + /* render scene */ int32_t (*Init)(struct AlsaRender*); int32_t (*SelectScene)(struct AlsaRender *, enum AudioPortPin, const struct PathDeviceInfo *); @@ -74,7 +74,7 @@ RenderPriData RenderGetPriData(struct AlsaRender *renderIns); /* Different platforms implement this function rewriting render implementation - */ +*/ int32_t RenderOverrideFunc(struct AlsaRender *renderIns); #ifdef __cplusplus diff --git a/audio/supportlibs/alsa_adapter/include/alsa_soundcard.h b/audio/supportlibs/alsa_adapter/include/alsa_soundcard.h index f3bc7c16b2..788d7f7fa6 100755 --- a/audio/supportlibs/alsa_adapter/include/alsa_soundcard.h +++ b/audio/supportlibs/alsa_adapter/include/alsa_soundcard.h @@ -129,8 +129,7 @@ int32_t SndElementWriteEnum(struct AlsaSoundCard *cardIns, const struct AlsaMixe int32_t SndElementWriteSwitch(struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, bool on); int32_t SndElementWrite(struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem); int32_t SndElementGroupWrite(struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement* elemGroup, int32_t groupSize); -int32_t SndTraversalMixerElement(struct AlsaSoundCard *cardIns, - bool (*callback)(void *data, snd_ctl_elem_id_t *elem_id), void *data); +int32_t SndTraversalMixerElement(struct AlsaSoundCard *cardIns, bool (*callback)(void *data, snd_ctl_elem_id_t *elem_id), void *data); #ifdef __cplusplus } -- Gitee From 2c0e57991066355293c0b74a2d1db9f2dafcad9d Mon Sep 17 00:00:00 2001 From: xiesicong Date: Mon, 25 Sep 2023 21:03:47 +0800 Subject: [PATCH 13/14] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E4=BB=A3=E7=A0=81?= =?UTF-8?q?=E6=A0=BC=E5=BC=8F=E9=97=AE=E9=A2=98=EF=BC=8C=E5=87=8F=E5=B0=91?= =?UTF-8?q?=E9=95=BF=E5=87=BD=E6=95=B0=E8=A1=8C=E6=95=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xiesicong --- .../alsa_adapter/include/alsa_snd_capture.h | 8 +- .../alsa_adapter/include/alsa_snd_render.h | 12 +- .../alsa_adapter/include/alsa_soundcard.h | 35 ++- .../alsa_adapter/src/alsa_lib_capture.c | 25 +- .../alsa_adapter/src/alsa_lib_render.c | 20 +- .../alsa_adapter/src/alsa_snd_capture.c | 38 +-- .../alsa_adapter/src/alsa_snd_render.c | 114 ++++----- .../alsa_adapter/src/alsa_soundcard.c | 239 +++++++++--------- 8 files changed, 244 insertions(+), 247 deletions(-) diff --git a/audio/supportlibs/alsa_adapter/include/alsa_snd_capture.h b/audio/supportlibs/alsa_adapter/include/alsa_snd_capture.h index d5f05a89e7..71ada69aac 100755 --- a/audio/supportlibs/alsa_adapter/include/alsa_snd_capture.h +++ b/audio/supportlibs/alsa_adapter/include/alsa_snd_capture.h @@ -25,7 +25,7 @@ extern "C" { typedef void* CapturePriData; typedef struct AlsaCapture AlsaCapture; -struct AlsaCapture{ +struct AlsaCapture { struct AlsaSoundCard soundCard; enum AudioPortPin descPins; bool muteState; @@ -52,7 +52,7 @@ struct AlsaCapture{ int32_t (*GetVolThreshold)(struct AlsaCapture *, long *, long *); int32_t (*GetVolume)(struct AlsaCapture *, long *); int32_t (*SetVolume)(struct AlsaCapture *, long); - + /* gain operation */ int32_t (*GetGainThreshold)(struct AlsaCapture *, float *, float *); int32_t (*GetGain)(struct AlsaCapture *, float *); @@ -60,7 +60,7 @@ struct AlsaCapture{ /* mute operation */ bool (*GetMute)(struct AlsaCapture *); - int32_t (*SetMute)(struct AlsaCapture *,bool); + int32_t (*SetMute)(struct AlsaCapture *, bool); }; struct AlsaCapture *CaptureCreateInstance(const char* adapterName); @@ -71,7 +71,7 @@ CapturePriData CaptureGetPriData(struct AlsaCapture *captureIns); /* Different platforms implement this function rewriting capture implementation -*/ + */ int32_t CaptureOverrideFunc(struct AlsaCapture *captureIns); #ifdef __cplusplus diff --git a/audio/supportlibs/alsa_adapter/include/alsa_snd_render.h b/audio/supportlibs/alsa_adapter/include/alsa_snd_render.h index da56e41c78..2a1664741a 100755 --- a/audio/supportlibs/alsa_adapter/include/alsa_snd_render.h +++ b/audio/supportlibs/alsa_adapter/include/alsa_snd_render.h @@ -46,16 +46,16 @@ struct AlsaRender{ int32_t (*Write)(struct AlsaRender *, const struct AudioHwRenderParam *); int32_t (*GetMmapPosition)(struct AlsaRender *); int32_t (*MmapWrite)(struct AlsaRender *, const struct AudioHwRenderParam *); - + /* volume operation */ int32_t (*GetVolThreshold)(struct AlsaRender *, long *, long *); int32_t (*GetVolume)(struct AlsaRender *, long *); - int32_t (*SetVolume)(struct AlsaRender *, long ); - + int32_t (*SetVolume)(struct AlsaRender *, long); + /* gain operation */ int32_t (*GetGainThreshold)(struct AlsaRender *, float *, float *); int32_t (*GetGain)(struct AlsaRender *, float *); - int32_t (*SetGain)(struct AlsaRender *, float ); + int32_t (*SetGain)(struct AlsaRender *, float); /* mute operation */ bool (*GetMute)(struct AlsaRender *); @@ -63,7 +63,7 @@ struct AlsaRender{ /* channel mode operation */ int32_t (*GetChannelMode)(struct AlsaRender *, enum AudioChannelMode *); - int32_t (*SetChannelMode)(struct AlsaRender *, enum AudioChannelMode ); + int32_t (*SetChannelMode)(struct AlsaRender *, enum AudioChannelMode); }; struct AlsaRender *RenderCreateInstance(const char* adapterName); @@ -74,7 +74,7 @@ RenderPriData RenderGetPriData(struct AlsaRender *renderIns); /* Different platforms implement this function rewriting render implementation -*/ + */ int32_t RenderOverrideFunc(struct AlsaRender *renderIns); #ifdef __cplusplus diff --git a/audio/supportlibs/alsa_adapter/include/alsa_soundcard.h b/audio/supportlibs/alsa_adapter/include/alsa_soundcard.h index 788d7f7fa6..14e3b39aa2 100755 --- a/audio/supportlibs/alsa_adapter/include/alsa_soundcard.h +++ b/audio/supportlibs/alsa_adapter/include/alsa_soundcard.h @@ -97,7 +97,7 @@ struct AlsaSoundCard{ /* alsa soundcard public variable */ - uint8_t cardStatus; + uint8_t cardStatus; bool canPause; bool pauseState; int32_t muteValue; @@ -110,7 +110,8 @@ void AudioCloseService(const struct DevHandle *handle); struct HdfIoService *HdfIoServiceBindName(const char *serviceName); int32_t SndMatchSelAdapter(struct AlsaSoundCard *cardIns, const char *adapterName); -int32_t SndConverAlsaPcmFormat(const struct AudioPcmHwParams *hwParams, snd_pcm_format_t *alsaPcmFormat); +int32_t SndConverAlsaPcmFormat(const struct AudioPcmHwParams *hwParams, + snd_pcm_format_t *alsaPcmFormat); int32_t SndSaveCardListInfo(snd_pcm_stream_t stream); bool SndisBusy(struct AlsaSoundCard *cardIns); int32_t SndOpenMixer(struct AlsaSoundCard *cardIns); @@ -120,16 +121,26 @@ snd_pcm_state_t SndGetRunState(struct AlsaSoundCard *cardIns); void SndCloseHandle(struct AlsaSoundCard *cardIns); void SndElementItemInit(struct AlsaMixerCtlElement *m); -int32_t SndElementReadInt(struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, long *value); -int32_t SndElementReadEnum(struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, unsigned int *item); -int32_t SndElementReadRange(struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, long *mix, long *max); -int32_t SndElementReadSwitch(struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, bool *on); -int32_t SndElementWriteInt(struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, long value); -int32_t SndElementWriteEnum(struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, unsigned int item); -int32_t SndElementWriteSwitch(struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, bool on); -int32_t SndElementWrite(struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem); -int32_t SndElementGroupWrite(struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement* elemGroup, int32_t groupSize); -int32_t SndTraversalMixerElement(struct AlsaSoundCard *cardIns, bool (*callback)(void *data, snd_ctl_elem_id_t *elem_id), void *data); +int32_t SndElementReadInt(struct AlsaSoundCard *cardIns, + const struct AlsaMixerCtlElement *ctlElem, long *value); +int32_t SndElementReadEnum(struct AlsaSoundCard *cardIns, + const struct AlsaMixerCtlElement *ctlElem, unsigned int *item); +int32_t SndElementReadRange(struct AlsaSoundCard *cardIns, + const struct AlsaMixerCtlElement *ctlElem, long *mix, long *max); +int32_t SndElementReadSwitch(struct AlsaSoundCard *cardIns, + const struct AlsaMixerCtlElement *ctlElem, bool *on); +int32_t SndElementWriteInt(struct AlsaSoundCard *cardIns, + const struct AlsaMixerCtlElement *ctlElem, long value); +int32_t SndElementWriteEnum(struct AlsaSoundCard *cardIns, + const struct AlsaMixerCtlElement *ctlElem, unsigned int item); +int32_t SndElementWriteSwitch(struct AlsaSoundCard *cardIns, + const struct AlsaMixerCtlElement *ctlElem, bool on); +int32_t SndElementWrite(struct AlsaSoundCard *cardIns, + const struct AlsaMixerCtlElement *ctlElem); +int32_t SndElementGroupWrite(struct AlsaSoundCard *cardIns, + const struct AlsaMixerCtlElement* elemGroup, int32_t groupSize); +int32_t SndTraversalMixerElement(struct AlsaSoundCard *cardIns, + bool (*callback)(void *data, snd_ctl_elem_id_t *elem_id), void *data); #ifdef __cplusplus } diff --git a/audio/supportlibs/alsa_adapter/src/alsa_lib_capture.c b/audio/supportlibs/alsa_adapter/src/alsa_lib_capture.c index d34a2d631c..9597542389 100644 --- a/audio/supportlibs/alsa_adapter/src/alsa_lib_capture.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_lib_capture.c @@ -26,7 +26,7 @@ int32_t AudioCtlCaptureSetPauseStu( captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName); CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); - + ret = SndPcmPause(&captureIns->soundCard, handleData->captureMode.ctlParam.pause); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("Capture set pause failed!"); @@ -72,7 +72,7 @@ int32_t AudioCtlCaptureSetVolume( ret = captureIns->SetVolume(captureIns, vol); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("Capture SetVolume fail!"); - return HDF_FAILURE; + return HDF_FAILURE; } return HDF_SUCCESS; @@ -106,7 +106,7 @@ int32_t AudioCtlCaptureGetMuteStu( captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName); CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); handleData->captureMode.ctlParam.mute = captureIns->GetMute(captureIns); - + return HDF_SUCCESS; } @@ -148,7 +148,7 @@ int32_t AudioCtlCaptureGetGainStu( return HDF_FAILURE; } handleData->captureMode.ctlParam.audioGain.gain = gainValue; - + return HDF_SUCCESS; } @@ -168,11 +168,11 @@ int32_t AudioCtlCaptureSceneSelect( deviceInfo = &handleData->captureMode.hwInfo.pathSelect.deviceInfo; ret = captureIns->SelectScene(captureIns, descPins, deviceInfo); if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("Capture select scene pin: (0x%{public}x) failed",descPins); + AUDIO_FUNC_LOGE("Capture select scene pin: (0x%{public}x) failed", descPins); return HDF_FAILURE; } - AUDIO_FUNC_LOGD("Capture scene select pin: (0x%{public}x) success",descPins); + AUDIO_FUNC_LOGD("Capture scene select pin: (0x%{public}x) success", descPins); return HDF_SUCCESS; } @@ -187,7 +187,7 @@ int32_t AudioCtlCaptureGetGainThreshold( captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName); CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); - + ret = captureIns->GetGainThreshold(captureIns, &gainMin, &gainMax); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("Capture get gain threshold failed"); @@ -210,7 +210,7 @@ int32_t AudioCtlCaptureGetVolThreshold( captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName); CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); - + ret = captureIns->GetVolThreshold(captureIns, &volMin, &volMax); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("Capture get volume threshold failed!"); @@ -226,7 +226,6 @@ int32_t AudioInterfaceLibCtlCapture( { int32_t ret; CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - CHECK_VALID_RANGE_RETURN(cmdId, AUDIODRV_CTL_IOCTL_ELEM_INFO_CAPTURE, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE, HDF_FAILURE); switch (cmdId) { /* setPara: */ @@ -287,7 +286,7 @@ int32_t AudioOutputCaptureHwParams( AUDIO_FUNC_LOGE("Capture set parameters failed!"); return HDF_FAILURE; } - + AUDIO_FUNC_LOGI("Capture set hwparams success."); return HDF_SUCCESS; } @@ -311,7 +310,7 @@ int32_t AudioOutputCaptureOpen( AUDIO_FUNC_LOGE("Capture open pcm failed."); return HDF_FAILURE; } - + ret = captureIns->Init(captureIns); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("Capture init failed."); @@ -357,7 +356,7 @@ int32_t AudioOutputCapturePrepare( AUDIO_FUNC_LOGE("pcm prepare fail"); return HDF_FAILURE; } - + return HDF_SUCCESS; } @@ -396,7 +395,7 @@ int32_t AudioOutputCaptureStop( AUDIO_FUNC_LOGE("Capture stop route failed!"); return ret; } - + AUDIO_FUNC_LOGI("Capture stop success."); return HDF_SUCCESS; } diff --git a/audio/supportlibs/alsa_adapter/src/alsa_lib_render.c b/audio/supportlibs/alsa_adapter/src/alsa_lib_render.c index 135d94c521..286ec253a0 100644 --- a/audio/supportlibs/alsa_adapter/src/alsa_lib_render.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_lib_render.c @@ -65,10 +65,10 @@ int32_t AudioCtlRenderSetPauseStu( int32_t ret; struct AlsaRender *renderIns = NULL; CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - + renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName); CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); - + ret = SndPcmPause(&renderIns->soundCard, handleData->renderMode.ctlParam.pause); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("Render set pause failed!"); @@ -148,7 +148,7 @@ int32_t AudioCtlRenderGetGainStu( return HDF_FAILURE; } handleData->renderMode.ctlParam.audioGain.gain = gainValue; - + return HDF_SUCCESS; } @@ -168,11 +168,11 @@ int32_t AudioCtlRenderSceneSelect( deviceInfo = &handleData->renderMode.hwInfo.pathSelect.deviceInfo; ret = renderIns->SelectScene(renderIns, descPins, deviceInfo); if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("Render select scene pin: (0x%{public}x) failed!",descPins); + AUDIO_FUNC_LOGE("Render select scene pin: (0x%{public}x) failed!", descPins); return HDF_FAILURE; } - AUDIO_FUNC_LOGD("Render scene select pin: (0x%{public}x) success",descPins); + AUDIO_FUNC_LOGD("Render scene select pin: (0x%{public}x) success", descPins); return HDF_SUCCESS; } @@ -232,7 +232,7 @@ int32_t AudioCtlRenderSetChannelMode( renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName); CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); - + mode = handleData->frameRenderMode.mode; ret = renderIns->SetChannelMode(renderIns, mode); if (ret != HDF_SUCCESS) { @@ -253,14 +253,14 @@ int32_t AudioCtlRenderGetChannelMode( renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName); CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); - + ret = renderIns->GetChannelMode(renderIns, &mode); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("Render get channel mode failed!"); return HDF_FAILURE; } handleData->frameRenderMode.mode = mode; - + return HDF_SUCCESS; } @@ -385,7 +385,7 @@ int32_t AudioOutputRenderPrepare( renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName); CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); - + ret = SndPcmPrepare(&renderIns->soundCard); if (ret < 0) { AUDIO_FUNC_LOGE("Render pcm prepare failed"); @@ -465,7 +465,7 @@ int32_t AudioOutputRenderReqMmapBuffer( AUDIO_FUNC_LOGE("Render MmapWrite error!"); return HDF_FAILURE; } - + return HDF_SUCCESS; } diff --git a/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c b/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c index abd15208c7..c58b76023f 100755 --- a/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c @@ -122,14 +122,16 @@ static int32_t SetHWRate(struct AlsaSoundCard *cardIns, snd_pcm_hw_params_t *par rRate = cardIns->hwParams.rate; ret = snd_pcm_hw_params_set_rate_near(cardIns->pcmHandle, params, &rRate, &dir); if (ret < 0) { - AUDIO_FUNC_LOGE("Rate %{public}uHz not available for capture: %{public}s", cardIns->hwParams.rate, snd_strerror(ret)); + AUDIO_FUNC_LOGE("Rate %{public}uHz not available for capture: %{public}s", + cardIns->hwParams.rate, snd_strerror(ret)); return HDF_FAILURE; } if (rRate != cardIns->hwParams.rate) { ret = snd_pcm_hw_params_set_rate_near(cardIns->pcmHandle, params, &rRate, &dir); if (ret < 0) { - AUDIO_FUNC_LOGE("Rate %{public}uHz not available for capture: %{public}s", cardIns->hwParams.rate, snd_strerror(ret)); + AUDIO_FUNC_LOGE("Rate %{public}uHz not available for capture: %{public}s", + cardIns->hwParams.rate, snd_strerror(ret)); return HDF_FAILURE; } } @@ -150,7 +152,7 @@ static int32_t SetHWBuffer(struct AlsaSoundCard *cardIns, snd_pcm_hw_params_t *p ret = snd_pcm_hw_params_set_buffer_time_near(cardIns->pcmHandle, params, &captureIns->bufferTime, &dir); if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to set buffer time %{public}u for capture: %{public}s", + AUDIO_FUNC_LOGE("Unable to set buffer time %{public}u for capture: %{public}s", captureIns->bufferTime, snd_strerror(ret)); return HDF_FAILURE; } @@ -176,7 +178,7 @@ static int32_t SetHWPeriod(struct AlsaSoundCard *cardIns, snd_pcm_hw_params_t *p ret = snd_pcm_hw_params_set_period_time_near(cardIns->pcmHandle, params, &captureIns->periodTime, &dir); if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to set period time %{public}u for capture: %{public}s", + AUDIO_FUNC_LOGE("Unable to set period time %{public}u for capture: %{public}s", captureIns->periodTime, snd_strerror(ret)); return HDF_FAILURE; } @@ -202,7 +204,7 @@ static int32_t SetHWParams(struct AlsaSoundCard *cardIns, snd_pcm_access_t acces snd_pcm_hw_params_alloca(&hwParams); ret = snd_pcm_hw_params_any(handle, hwParams); // choose all parameters if (ret < 0) { - AUDIO_FUNC_LOGE("Broken configuration for capture: no configurations available: %{public}s.", + AUDIO_FUNC_LOGE("Broken configuration for capture: no configurations available: %{public}s.", snd_strerror(ret)); return HDF_FAILURE; } @@ -267,7 +269,7 @@ static int32_t SetSWParams(struct AlsaSoundCard *cardIns) } /* start the transfer when the buffer is almost full: */ /* (buffer_size / avail_min) * avail_min */ - ret = snd_pcm_sw_params_set_start_threshold(handle, swParams, + ret = snd_pcm_sw_params_set_start_threshold(handle, swParams, (captureIns->bufferSize / captureIns->periodSize) * captureIns->periodSize); if (ret < 0) { AUDIO_FUNC_LOGE("Unable to set start threshold mode for capture: %{public}s.", snd_strerror(ret)); @@ -276,7 +278,7 @@ static int32_t SetSWParams(struct AlsaSoundCard *cardIns) /* allow the transfer when at least period_size samples can be processed */ /* or disable this mechanism when period event is enabled (aka interrupt like style processing) */ - ret = snd_pcm_sw_params_set_avail_min(handle, swParams, + ret = snd_pcm_sw_params_set_avail_min(handle, swParams, captureIns->periodEvent ? captureIns->bufferSize : captureIns->periodSize); if (ret < 0) { AUDIO_FUNC_LOGE("Unable to set avail min for capture: %{public}s", snd_strerror(ret)); @@ -408,7 +410,7 @@ static struct AlsaCapture *GetCaptureInsByName(const char *adapterName) } } } - + for (i = 0; i < MAX_CARD_NUM; i++) { captureIns = &g_alsaCaptureList[i]; alsaSnd = (struct AlsaSoundCard *)&g_alsaCaptureList[i]; @@ -428,7 +430,7 @@ static struct AlsaCapture *GetCaptureInsByName(const char *adapterName) return captureIns; } } - AUDIO_FUNC_LOGE("Failed to AddCardIns!"); + AUDIO_FUNC_LOGE("Failed to AddCardIns!"); return NULL; } @@ -476,7 +478,7 @@ struct AlsaCapture *CaptureCreateInstance(const char* adapterName) struct AlsaCapture *CaptureGetInstance(const char *adapterName) { int32_t i; - + if (adapterName == NULL || strlen(adapterName) == 0) { AUDIO_FUNC_LOGE("Invalid cardName!"); return NULL; @@ -623,21 +625,21 @@ static int32_t CaptureOpenImpl(struct AlsaCapture *captureIns) { int32_t ret; CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); - + if (SndisBusy(&captureIns->soundCard)) { AUDIO_FUNC_LOGE("Resource busy!!"); SndCloseHandle(&captureIns->soundCard); return HDF_ERR_DEVICE_BUSY; } - ret = snd_pcm_open(&captureIns->soundCard.pcmHandle, captureIns->soundCard.devName, + ret = snd_pcm_open(&captureIns->soundCard.pcmHandle, captureIns->soundCard.devName, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK); if (ret < 0) { AUDIO_FUNC_LOGE("snd_pcm_open fail: %{public}s!", snd_strerror(ret)); CaptureFreeMemory(); return HDF_FAILURE; } - + ret = snd_pcm_nonblock(captureIns->soundCard.pcmHandle, 1); if (ret < 0) { AUDIO_FUNC_LOGE("snd_pcm_nonblock fail: %{public}s!", snd_strerror(ret)); @@ -653,7 +655,7 @@ static int32_t CaptureOpenImpl(struct AlsaCapture *captureIns) CaptureFreeMemory(); return HDF_FAILURE; } - + return HDF_SUCCESS; } @@ -787,20 +789,20 @@ static int32_t CaptureMmapReadImpl(struct AlsaCapture *captureIns, const struct static int32_t CaptureInitImpl(struct AlsaCapture* captureIns) { AUDIO_FUNC_LOGE("Not yet realized"); - return HDF_SUCCESS; + return HDF_SUCCESS; } static int32_t CaptureSelectSceneImpl(struct AlsaCapture *captureIns, enum AudioPortPin descPins, const struct PathDeviceInfo *deviceInfo) { AUDIO_FUNC_LOGE("Not yet realized"); - return HDF_SUCCESS; + return HDF_SUCCESS; } static int32_t CaptureStartImpl(struct AlsaCapture *captureIns) { AUDIO_FUNC_LOGE("Not yet realized"); - return HDF_SUCCESS; + return HDF_SUCCESS; } static int32_t CaptureStopImpl(struct AlsaCapture *captureIns) @@ -862,7 +864,7 @@ static void RegisterCaptureImpl(struct AlsaCapture *captureIns) if (captureIns == NULL) { AUDIO_FUNC_LOGE("captureIns is NULL!"); } - + captureIns->Init = CaptureInitImpl; captureIns->Open = CaptureOpenImpl; captureIns->Close = CaptureCloseImpl; diff --git a/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c b/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c index 5b5dbcf6e5..57f97ba402 100755 --- a/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c @@ -25,6 +25,9 @@ #define POLL_EVENT_DEF false #define AUDIO_BUFFER_TIME_DEF 500000 #define AUDIO_PERIOD_TIME_DEF 100000 +#define AUDIO_PERIOD_TIME_RATIO 4 +#define BIT_COUNT_OF_BYTE 8 +#define PCM_WAIT_TIMEOUT_MS 100 #ifdef SUPPORT_ALSA_CHMAP #define CHMAP_NAME_LENGHT_MAX 256 @@ -62,14 +65,14 @@ static int32_t CreateRenderIns(void) static int32_t RenderFreeMemory(void) { int32_t i; - + if (g_alsaRenderList != NULL) { for (i = 0; i < MAX_CARD_NUM; i++) { if (g_alsaRenderList[i].soundCard.cardStatus != 0) { AUDIO_FUNC_LOGE("refCount is not zero, Sound card in use!"); return HDF_ERR_DEVICE_BUSY; } - + if (g_alsaRenderList[i].priData != NULL) { OsalMemFree(g_alsaRenderList[i].priData); g_alsaRenderList[i].priData = NULL; @@ -110,7 +113,8 @@ static int32_t SetHWParamsSub( /* set the sample format */ ret = snd_pcm_hw_params_set_format(handle, params, pcmFormat); if (ret < 0) { - AUDIO_FUNC_LOGE("Sample format not available for playback: %{public}s, format: %{public}d", snd_strerror(ret), pcmFormat); + AUDIO_FUNC_LOGE("Sample format not available for playback: %{public}s, format: %{public}d", + snd_strerror(ret), pcmFormat); return HDF_FAILURE; } /* set the count of channels */ @@ -150,76 +154,58 @@ static int32_t SetHWRate(snd_pcm_t *handle, snd_pcm_hw_params_t *params, uint32_ } /* Update to hardware supported rate */ *rate = rRate; - + return HDF_SUCCESS; } static int32_t SetHWParams(struct AlsaSoundCard *cardIns, snd_pcm_access_t access) { - int ret; int dir = 0; /* dir Value range (-1,0,1) */ snd_pcm_uframes_t size; snd_pcm_hw_params_t *hwParams = NULL; - snd_pcm_t *handle = cardIns->pcmHandle; struct AlsaRender *renderIns = (struct AlsaRender*)cardIns; - CHECK_NULL_PTR_RETURN_DEFAULT(handle); - + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns->pcmHandle); + snd_pcm_hw_params_alloca(&hwParams); - ret = snd_pcm_hw_params_any(handle, hwParams); // choose all parameters - if (ret < 0) { - AUDIO_FUNC_LOGE("No configurations available: %{public}s", snd_strerror(ret)); + if (snd_pcm_hw_params_any(cardIns->pcmHandle, hwParams) < 0) { + AUDIO_FUNC_LOGE("No configurations available"); return HDF_FAILURE; } - - ret = SetHWParamsSub(handle, hwParams, &cardIns->hwParams, access); - if (ret != HDF_SUCCESS) { + if (SetHWParamsSub(cardIns->pcmHandle, hwParams, &cardIns->hwParams, access) != HDF_SUCCESS) { AUDIO_FUNC_LOGE("SetHWParamsSub failed!"); - return ret; + return HDF_FAILURE; } - - ret = SetHWRate(handle, hwParams, &(cardIns->hwParams.rate)); - if (ret != HDF_SUCCESS) { + if (SetHWRate(cardIns->pcmHandle, hwParams, &(cardIns->hwParams.rate)) != HDF_SUCCESS) { AUDIO_FUNC_LOGE("SetHWRate failed!"); - return ret; + return HDF_FAILURE; } - - snd_pcm_hw_params_get_buffer_time_max(hwParams, &renderIns->bufferTime, &dir); - if (renderIns->bufferTime > 500000) - renderIns->bufferTime = 500000; - renderIns->periodTime = renderIns->bufferTime / 4; - - ret = snd_pcm_hw_params_set_buffer_time_near(handle, hwParams, &renderIns->bufferTime, &dir); - if (ret < 0) { - AUDIO_FUNC_LOGE("Set buffer time %{public}u failed: %{public}s", renderIns->bufferTime, snd_strerror(ret)); + snd_pcm_hw_params_get_buffer_time_max(hwParams, &renderIns->bufferTime, &dir); + if (renderIns->bufferTime > AUDIO_BUFFER_TIME_DEF) + renderIns->bufferTime = AUDIO_BUFFER_TIME_DEF; + renderIns->periodTime = renderIns->bufferTime / AUDIO_PERIOD_TIME_RATIO; + if (snd_pcm_hw_params_set_buffer_time_near(cardIns->pcmHandle, hwParams, &renderIns->bufferTime, &dir) < 0) { + AUDIO_FUNC_LOGE("Set buffer time %{public}u failed", renderIns->bufferTime); return HDF_FAILURE; } - - ret = snd_pcm_hw_params_get_buffer_size(hwParams, &size); - if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to get buffer size for playback: %{public}s", snd_strerror(ret)); + if (snd_pcm_hw_params_get_buffer_size(hwParams, &size) < 0) { + AUDIO_FUNC_LOGE("Unable to get buffer size for playback"); return HDF_FAILURE; } renderIns->bufferSize = size; - - ret = snd_pcm_hw_params_set_period_time_near(handle, hwParams, &renderIns->periodTime, &dir); - if (ret < 0) { - AUDIO_FUNC_LOGE("Set period time %{public}u failed: %{public}s", renderIns->bufferTime, snd_strerror(ret)); + if (snd_pcm_hw_params_set_period_time_near(cardIns->pcmHandle, hwParams, &renderIns->periodTime, &dir) < 0) { + AUDIO_FUNC_LOGE("Set period time %{public}u failed", renderIns->bufferTime); return HDF_FAILURE; } - - ret = snd_pcm_hw_params_get_period_size(hwParams, &size, &dir); - if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to get period size for playback: %{public}s", snd_strerror(ret)); + if (snd_pcm_hw_params_get_period_size(hwParams, &size, &dir) < 0) { + AUDIO_FUNC_LOGE("Unable to get period size for playback"); return HDF_FAILURE; } renderIns->periodSize = size; - - ret = snd_pcm_hw_params(handle, hwParams); // write the parameters to device - if (ret < 0) { - AUDIO_FUNC_LOGE("Unable to set hw params for playback: %{public}s", snd_strerror(ret)); + if (snd_pcm_hw_params(cardIns->pcmHandle, hwParams) < 0) { + AUDIO_FUNC_LOGE("Unable to set hw params for playback"); return HDF_FAILURE; } - + cardIns->canPause = snd_pcm_hw_params_can_pause(hwParams); return HDF_SUCCESS; } @@ -247,7 +233,7 @@ static int32_t SetSWParams(struct AlsaSoundCard *cardIns) AUDIO_FUNC_LOGE("g_periodSize=0"); return HDF_FAILURE; } - ret = snd_pcm_sw_params_set_start_threshold(handle, swParams, + ret = snd_pcm_sw_params_set_start_threshold(handle, swParams, (renderIns->bufferSize / renderIns->periodSize) * renderIns->periodSize); if (ret < 0) { AUDIO_FUNC_LOGE("Unable to set start threshold mode for playback: %{public}s", snd_strerror(ret)); @@ -255,7 +241,7 @@ static int32_t SetSWParams(struct AlsaSoundCard *cardIns) } /* allow the transfer when at least period_size samples can be processed */ /* or disable this mechanism when period event is enabled (aka interrupt like style processing) */ - ret = snd_pcm_sw_params_set_avail_min(handle, swParams, + ret = snd_pcm_sw_params_set_avail_min(handle, swParams, renderIns->periodEvent ? renderIns->bufferSize : renderIns->periodSize); if (ret < 0) { AUDIO_FUNC_LOGE("Unable to set avail min for playback: %{public}s", snd_strerror(ret)); @@ -319,7 +305,7 @@ static struct AlsaRender *GetRenderInsByName(const char *adapterName) } } } - + for (i = 0; i < MAX_CARD_NUM; i++) { renderIns = &g_alsaRenderList[i]; alsaSnd = (struct AlsaSoundCard *)&g_alsaRenderList[i]; @@ -338,7 +324,7 @@ static struct AlsaRender *GetRenderInsByName(const char *adapterName) return renderIns; } } - AUDIO_FUNC_LOGE("Failed to AddCardIns!"); + AUDIO_FUNC_LOGE("Failed to AddCardIns!"); return NULL; } @@ -572,7 +558,7 @@ int32_t RenderSetParams(struct AlsaRender *renderIns, const struct AudioHwRender SndConverAlsaPcmFormat(&cardIns->hwParams, &fmt); bits_per_sample = snd_pcm_format_physical_width(fmt); cardIns->hwParams.bitsPerFrame = bits_per_sample * cardIns->hwParams.channels; - + return HDF_SUCCESS; } @@ -585,8 +571,6 @@ static int32_t RenderWritei(snd_pcm_t *pcm, const struct AudioHwRenderParam *han size_t sbufFrameSize; snd_pcm_state_t state; int32_t tryNum = AUDIO_ALSALIB_RETYR; - CHECK_NULL_PTR_RETURN_DEFAULT(pcm); - CHECK_NULL_PTR_RETURN_DEFAULT(handleData); /* Check whether the PCM status is normal */ state = snd_pcm_state(pcm); @@ -596,18 +580,18 @@ static int32_t RenderWritei(snd_pcm_t *pcm, const struct AudioHwRenderParam *han AUDIO_FUNC_LOGE("snd_pcm_prepare fail: %{public}s", snd_strerror(ret)); return HDF_FAILURE; } - } + } sbufFrameSize = (size_t)handleData->frameRenderMode.bufferFrameSize; dataBuf = handleData->frameRenderMode.buffer; - offset = hwParams->bitsPerFrame /8; + offset = hwParams->bitsPerFrame / BIT_COUNT_OF_BYTE; while (sbufFrameSize > 0) { frames = snd_pcm_writei(pcm, dataBuf, sbufFrameSize); if (frames > 0) { sbufFrameSize -= frames; dataBuf += frames * offset; - } else if (frames == -EAGAIN){ - snd_pcm_wait(pcm, 100); + } else if (frames == -EAGAIN) { + snd_pcm_wait(pcm, PCM_WAIT_TIMEOUT_MS); tryNum--; if (tryNum == 0) { return HDF_SUCCESS; @@ -622,7 +606,7 @@ static int32_t RenderWritei(snd_pcm_t *pcm, const struct AudioHwRenderParam *han * stream is suspended and waiting for an application recovery. * -EPIPE: an underrun occurred. */ - AUDIO_FUNC_LOGI("err: %{public}s",snd_strerror(ret)); + AUDIO_FUNC_LOGI("err: %{public}s", snd_strerror(ret)); ret = snd_pcm_recover(pcm, frames, 0); // 0 for open render recover log. if (ret < 0) { AUDIO_FUNC_LOGE("snd_pcm_writei failed: %{public}s", snd_strerror(ret)); @@ -701,14 +685,14 @@ static int32_t RenderOpenImpl(struct AlsaRender *renderIns) return HDF_ERR_DEVICE_BUSY; } - ret = snd_pcm_open(&cardIns->pcmHandle, cardIns->devName, + ret = snd_pcm_open(&cardIns->pcmHandle, cardIns->devName, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK); if (ret < 0) { AUDIO_FUNC_LOGE("snd_pcm_open fail: %{public}s!", snd_strerror(ret)); RenderFreeMemory(); return HDF_FAILURE; } - + ret = snd_pcm_nonblock(cardIns->pcmHandle, 1); if (ret < 0) { AUDIO_FUNC_LOGE("snd_pcm_nonblock fail: %{public}s!", snd_strerror(ret)); @@ -745,11 +729,11 @@ int32_t RenderWriteImpl(struct AlsaRender *renderIns, const struct AudioHwRender struct AlsaSoundCard *cardIns = (struct AlsaSoundCard*)renderIns; CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); - if(cardIns->pauseState) { + if (cardIns->pauseState) { AUDIO_FUNC_LOGE("Currently in pause, please check!"); return HDF_FAILURE; } - + if (!cardIns->mmapFlag) { ret = ResetRenderParams(cardIns, SND_PCM_ACCESS_RW_INTERLEAVED); if (ret < 0) { @@ -798,20 +782,20 @@ int32_t RenderMmapWriteImpl(struct AlsaRender *renderIns, const struct AudioHwRe static int32_t RenderInitImpl(struct AlsaRender* renderIns) { AUDIO_FUNC_LOGE("Not yet realized"); - return HDF_SUCCESS; + return HDF_SUCCESS; } static int32_t RenderSelectSceneImpl(struct AlsaRender *renderIns, enum AudioPortPin descPins, const struct PathDeviceInfo *deviceInfo) { AUDIO_FUNC_LOGE("Not yet realized"); - return HDF_SUCCESS; + return HDF_SUCCESS; } static int32_t RenderStartImpl(struct AlsaRender *renderIns) { AUDIO_FUNC_LOGE("Not yet realized"); - return HDF_SUCCESS; + return HDF_SUCCESS; } static int32_t RenderStopImpl(struct AlsaRender *renderIns) @@ -885,7 +869,7 @@ static void RegisterRenderImpl(struct AlsaRender *renderIns) if (renderIns == NULL) { AUDIO_FUNC_LOGE("renderIns is NULL!"); } - + renderIns->Init = RenderInitImpl; renderIns->Open = RenderOpenImpl; renderIns->SelectScene = RenderSelectSceneImpl; diff --git a/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c b/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c index 303c895a04..5453ef7dda 100755 --- a/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c @@ -119,7 +119,7 @@ static enum SndCardType CfgGetAdapterCardType(const char* adapterName) if(adapterName == NULL) { return SND_CARD_UNKNOWN; } - + struct AlsaAdapterCfgInfo *info; for(enum SndCardType type = SND_CARD_PRIMARY; type < SND_CARD_MAX; ++type) { for(int32_t i = 0; i < g_alsaAdapterList[type].num; ++i) { @@ -137,7 +137,7 @@ static struct AlsaAdapterCfgInfo *CfgGetAdapterInfo(const char* adapterName) if(adapterName == NULL) { return NULL; } - + struct AlsaAdapterCfgInfo *info; for(enum SndCardType type = SND_CARD_PRIMARY; type < SND_CARD_MAX; ++type) { for(int32_t i = 0; i < g_alsaAdapterList[type].num; ++i) { @@ -171,14 +171,14 @@ static int32_t CfgDumpAdapterInfo(struct AlsaAdapterCfgInfo *info) } idx = g_alsaAdapterList[cardType].num; - ret = memcpy_s((void*)&g_alsaAdapterList[cardType].list[idx], sizeof(struct AlsaAdapterCfgInfo), + ret = memcpy_s((void*)&g_alsaAdapterList[cardType].list[idx], sizeof(struct AlsaAdapterCfgInfo), (void*)info, sizeof(struct AlsaAdapterCfgInfo)); if (ret != EOK) { AUDIO_FUNC_LOGE("memcpy_s g_alsaAdapterList fail!"); return HDF_FAILURE; } g_alsaAdapterList[cardType].num++; - + AUDIO_FUNC_LOGI("cardId:%{public}d: adapterName:%{public}s, cardName:%{public}s", g_alsaAdapterList[cardType].list[idx].cardId, g_alsaAdapterList[cardType].list[idx].adapterName, @@ -192,7 +192,7 @@ static int32_t CfgSaveAdapterStruct(cJSON *adapter, struct AlsaAdapterCfgInfo *i cJSON *item; CHECK_NULL_PTR_RETURN_DEFAULT(adapter); CHECK_NULL_PTR_RETURN_DEFAULT(info); - + item = cJSON_GetObjectItem(adapter, "name"); if (item == NULL || item->valuestring == NULL) { AUDIO_FUNC_LOGE("adapter name is null!"); @@ -203,14 +203,14 @@ static int32_t CfgSaveAdapterStruct(cJSON *adapter, struct AlsaAdapterCfgInfo *i AUDIO_FUNC_LOGE("memcpy_s adapterName fail!"); return HDF_FAILURE; } - + item = cJSON_GetObjectItem(adapter, "cardId"); if (item == NULL) { AUDIO_FUNC_LOGE("cardId not set!"); return HDF_FAILURE; } info->cardId = item->valuedouble; - + item = cJSON_GetObjectItem(adapter, "cardName"); if (item == NULL || item->valuestring == NULL) { AUDIO_FUNC_LOGE("cardName is null!"); @@ -225,41 +225,23 @@ static int32_t CfgSaveAdapterStruct(cJSON *adapter, struct AlsaAdapterCfgInfo *i return HDF_SUCCESS; } -int32_t CfgSaveAdapterFromFile(void) +static int32_t CfgParseAdapterItems(cJSON *adapterObj) { - int32_t ret, adapterNum; - cJSON *adapterObj = NULL; + int32_t ret, adapterNum; cJSON *adapterItems = NULL; - char *configBuf = NULL; - - configBuf = CfgReadAdapterFile(ALSA_CARD_CONFIG_FILE); - if (configBuf == NULL) { - AUDIO_FUNC_LOGE("CfgReadAdapterFile failed!"); - return HDF_FAILURE; - } - adapterObj = cJSON_Parse(configBuf); - if (adapterObj == NULL) { - AUDIO_FUNC_LOGE("Parse json file failed!"); - AudioMemFree((void **)&configBuf); - return HDF_FAILURE; - } - AudioMemFree((void **)&configBuf); adapterItems = cJSON_GetObjectItem(adapterObj, "adapters"); if (adapterItems == NULL) { AUDIO_FUNC_LOGE("Get adapterItems from json failed!\n"); - cJSON_Delete(adapterObj); return HDF_FAILURE; } adapterNum = cJSON_GetArraySize(adapterItems); if (adapterNum <= 0) { AUDIO_FUNC_LOGE("Get adapter number failed!"); - cJSON_Delete(adapterObj); return HDF_FAILURE; } else if (adapterNum > MAX_CARD_NUM) { AUDIO_FUNC_LOGE("Read adapters number is %{public}d over max num %{public}d!", adapterNum, MAX_CARD_NUM); - cJSON_Delete(adapterObj); return HDF_FAILURE; } @@ -269,24 +251,51 @@ int32_t CfgSaveAdapterFromFile(void) adapter = cJSON_GetArrayItem(adapterItems, i); if(adapter == NULL) { AUDIO_FUNC_LOGE("Get adapter item from array failed!"); - cJSON_Delete(adapterObj); } ret = CfgSaveAdapterStruct(adapter, &info); if(ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("CfgSaveAdapterStruct failed!"); - cJSON_Delete(adapterObj); return HDF_FAILURE; } ret = CfgDumpAdapterInfo(&info); if(ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("CfgDumpAdapterInfo failed!"); - cJSON_Delete(adapterObj); return HDF_FAILURE; } } + return HDF_SUCCESS; +} + +int32_t CfgSaveAdapterFromFile(void) +{ + int32_t ret; + cJSON *adapterObj = NULL; + char *configBuf = NULL; + + configBuf = CfgReadAdapterFile(ALSA_CARD_CONFIG_FILE); + if (configBuf == NULL) { + AUDIO_FUNC_LOGE("CfgReadAdapterFile failed!"); + return HDF_FAILURE; + } + adapterObj = cJSON_Parse(configBuf); + if (adapterObj == NULL) { + AUDIO_FUNC_LOGE("Parse json file failed!"); + AudioMemFree((void **)&configBuf); + return HDF_FAILURE; + } + AudioMemFree((void **)&configBuf); + + ret = CfgParseAdapterItems(adapterObj); + if(ret != HDF_SUCCESS) { + cJSON_Delete(adapterObj); + AUDIO_FUNC_LOGE("Parse adapter items failed!"); + return HDF_FAILURE; + } + + cJSON_Delete(adapterObj); return HDF_SUCCESS; } @@ -323,62 +332,47 @@ static int32_t DevSaveCardPcmInfo(snd_ctl_t *handle, snd_pcm_stream_t stream, in int pcmDev = -1; snd_ctl_card_info_t *info = NULL; snd_pcm_info_t *pcminfo = NULL; - snd_ctl_card_info_alloca(&info); snd_pcm_info_alloca(&pcminfo); - ret = snd_ctl_card_info(handle, info); - if(ret != 0) { + if (snd_ctl_card_info(handle, info) != 0) { AUDIO_FUNC_LOGE("snd_ctl_card_info failed."); return HDF_FAILURE; } - - ret = snd_ctl_pcm_next_device(handle, &pcmDev); - if(ret < 0 || pcmDev < 0) { - AUDIO_FUNC_LOGE("No pcm device found: %{public}s.", snd_strerror(ret)); - return HDF_FAILURE; + if (snd_ctl_pcm_next_device(handle, &pcmDev) < 0 || pcmDev < 0) { + AUDIO_FUNC_LOGE("No pcm device found"); + return HDF_FAILURE; } - - while(pcmDev >= 0) { + while (pcmDev >= 0) { snd_pcm_info_set_device(pcminfo, pcmDev); snd_pcm_info_set_subdevice(pcminfo, 0); snd_pcm_info_set_stream(pcminfo, stream); ret = snd_ctl_pcm_info(handle, pcminfo); - if(ret < 0) { + if (ret < 0) { if (ret != -ENOENT) { - AUDIO_FUNC_LOGE("control digital audio info (%{public}d): %{public}s", pcmDev, snd_strerror(ret)); + AUDIO_FUNC_LOGE("control digital audio info (%{public}d)", pcmDev); } continue; } - struct AlsaDevInfo *devInfo = &g_alsaCardsDevList.alsaDevIns[g_alsaCardsDevList.num]; const char *cardId = snd_ctl_card_info_get_id(info); const char *pcmInfoId = snd_pcm_info_get_id(pcminfo); - CHECK_NULL_PTR_RETURN_DEFAULT(cardId); - CHECK_NULL_PTR_RETURN_DEFAULT(pcmInfoId); - AUDIO_FUNC_LOGE("card %{public}s: pcm: %{public}s", cardId, pcmInfoId); - devInfo->card = card; devInfo->device = pcmDev; - ret = strncpy_s(devInfo->cardId, MAX_CARD_NAME_LEN + 1, cardId, strlen(cardId)); - if (ret != 0) { + if (strncpy_s(devInfo->cardId, MAX_CARD_NAME_LEN + 1, cardId, strlen(cardId)) != 0) { AUDIO_FUNC_LOGE("strncpy_s failed!"); return HDF_FAILURE; } - ret = strncpy_s(devInfo->pcmInfoId, MAX_CARD_NAME_LEN + 1, pcmInfoId, strlen(pcmInfoId)); - if (ret != 0) { + if (strncpy_s(devInfo->pcmInfoId, MAX_CARD_NAME_LEN + 1, pcmInfoId, strlen(pcmInfoId)) != 0) { AUDIO_FUNC_LOGE("strncpy_s failed!"); return HDF_FAILURE; } g_alsaCardsDevList.num++; - - ret = snd_ctl_pcm_next_device(handle, &pcmDev); - if(ret < 0) { - AUDIO_FUNC_LOGE("snd_ctl_pcm_next_device error: %{public}s.", snd_strerror(ret)); - return HDF_FAILURE; + if(snd_ctl_pcm_next_device(handle, &pcmDev) < 0) { + AUDIO_FUNC_LOGE("snd_ctl_pcm_next_device error!"); + return HDF_FAILURE; } } - return HDF_SUCCESS; } @@ -414,7 +408,7 @@ static int32_t DevSaveDriverInfo(snd_pcm_stream_t stream) if(ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("save alsa sound cards %{public}s pcm info failed!",deviceName); } - + ret = snd_ctl_close(handle); if (ret < 0) { AUDIO_FUNC_LOGE("snd_ctl_close error: %{public}s.", snd_strerror(ret)); @@ -437,7 +431,7 @@ int32_t SndSaveCardListInfo(snd_pcm_stream_t stream) (void)memset_s(&g_alsaAdapterList, sizeof(struct AlsaAdapterList) * SND_CARD_MAX, 0, sizeof(struct AlsaAdapterList) * SND_CARD_MAX); - (void)memset_s(&g_alsaCardsDevList, sizeof(struct AlsaCardsList), + (void)memset_s(&g_alsaCardsDevList, sizeof(struct AlsaCardsList), 0, sizeof(struct AlsaCardsList)); /* Parse sound card from configuration file */ @@ -497,20 +491,21 @@ int32_t SndMatchSelAdapter(struct AlsaSoundCard *cardIns, const char *adapterNam return HDF_FAILURE; } - ret = snprintf_s(cardIns->devName, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "hw:%d,%d", devInfo->card, devInfo->device); + ret = snprintf_s(cardIns->devName, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, + "hw:%d,%d", devInfo->card, devInfo->device); if(ret < 0) { - AUDIO_FUNC_LOGE("%{public}s snprintf_s devName failed",cardIns->adapterName); - return HDF_FAILURE; + AUDIO_FUNC_LOGE("%{public}s snprintf_s devName failed", cardIns->adapterName); + return HDF_FAILURE; } ret = snprintf_s(cardIns->ctrlName, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "hw:%d", devInfo->card); if(ret < 0) { - AUDIO_FUNC_LOGE("%{public}s snprintf_s ctrlName failed",cardIns->adapterName); - return HDF_FAILURE; + AUDIO_FUNC_LOGE("%{public}s snprintf_s ctrlName failed", cardIns->adapterName); + return HDF_FAILURE; } ret = snprintf_s(cardIns->alsaCardId, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "%s", devInfo->cardId); if(ret < 0) { - AUDIO_FUNC_LOGE("%{public}s snprintf_s alsaCardId failed",cardIns->adapterName); - return HDF_FAILURE; + AUDIO_FUNC_LOGE("%{public}s snprintf_s alsaCardId failed", cardIns->adapterName); + return HDF_FAILURE; } return HDF_SUCCESS; @@ -698,8 +693,7 @@ static int32_t AudioInitPorts(struct AudioAdapterDescriptor *desc, enum SndCardT uint8_t portNum; CHECK_NULL_PTR_RETURN_DEFAULT(desc); - switch(type) - { + switch(type) { case SND_CARD_PRIMARY: portNum = PORT_OUT_IN; break; @@ -739,7 +733,7 @@ static int32_t AudioInitPorts(struct AudioAdapterDescriptor *desc, enum SndCardT AUDIO_FUNC_LOGE("adapter list not support sound card type %{public}d", type); return HDF_FAILURE; } - + return HDF_SUCCESS; } @@ -767,8 +761,8 @@ int32_t AudioGetAllCardInfo(struct AudioAdapterDescriptor **descs, int32_t *sndC *sndCardNum = adapterNum; idx = 0; - for(enum SndCardType type = SND_CARD_PRIMARY; type < SND_CARD_MAX; ++type) { - for(int32_t i = 0; i < g_alsaAdapterList[type].num; ++i) { + for (enum SndCardType type = SND_CARD_PRIMARY; type < SND_CARD_MAX; ++type) { + for (int32_t i = 0; i < g_alsaAdapterList[type].num; ++i) { (*descs)[idx].adapterName = strdup(g_alsaAdapterList[type].list[i].adapterName); AudioInitPorts(&(*descs)[idx], type); AUDIO_FUNC_LOGI("adapter name : %{public}s", (*descs)[idx].adapterName); @@ -821,6 +815,35 @@ void SndElementItemInit(struct AlsaMixerCtlElement *m) m->subdevice = -1; } +static snd_ctl_elem_iface_t ConvertIfaceType(enum SndIfaceType iface) +{ + snd_ctl_elem_iface_t snd_iface; + switch(iface) { + case IFACE_CARD: + snd_iface = SND_CTL_ELEM_IFACE_CARD; + break; + case IFACE_MIXER: + snd_iface = SND_CTL_ELEM_IFACE_MIXER; + break; + case IFACE_PCM: + snd_iface = SND_CTL_ELEM_IFACE_PCM; + break; + case IFACE_RAWMIDI: + snd_iface = SND_CTL_ELEM_IFACE_RAWMIDI; + break; + case IFACE_TIMER: + snd_iface = SND_CTL_ELEM_IFACE_TIMER; + break; + case IFACE_SEQUENCER: + snd_iface = SND_CTL_ELEM_IFACE_SEQUENCER; + break; + default: + snd_iface = SND_CTL_ELEM_IFACE_MIXER; + break; + } + return snd_iface; +} + static int32_t SetElementInfo(snd_ctl_t *alsaHandle, const struct AlsaMixerCtlElement *ctlElem, snd_ctl_elem_info_t *info, snd_ctl_elem_id_t *id) { @@ -834,39 +857,17 @@ static int32_t SetElementInfo(snd_ctl_t *alsaHandle, const struct AlsaMixerCtlEl if (ctlElem->numid >= 0) { snd_ctl_elem_id_set_numid(id, ctlElem->numid); } - if (ctlElem->index >= 0){ + if (ctlElem->index >= 0) { snd_ctl_elem_id_set_index(id, ctlElem->index); } - if (ctlElem->device >= 0){ + if (ctlElem->device >= 0) { snd_ctl_elem_id_set_index(id, ctlElem->device); } - if (ctlElem->subdevice >= 0){ + if (ctlElem->subdevice >= 0) { snd_ctl_elem_id_set_index(id, ctlElem->subdevice); } - switch(ctlElem->iface) { - case IFACE_CARD: - ifaceType = SND_CTL_ELEM_IFACE_CARD; - break; - case IFACE_MIXER: - ifaceType = SND_CTL_ELEM_IFACE_MIXER; - break; - case IFACE_PCM: - ifaceType = SND_CTL_ELEM_IFACE_PCM; - break; - case IFACE_RAWMIDI: - ifaceType = SND_CTL_ELEM_IFACE_RAWMIDI; - break; - case IFACE_TIMER: - ifaceType = SND_CTL_ELEM_IFACE_TIMER; - break; - case IFACE_SEQUENCER: - ifaceType = SND_CTL_ELEM_IFACE_SEQUENCER; - break; - default: - break; - } - + ifaceType = ConvertIfaceType(ctlElem->iface); snd_ctl_elem_id_set_interface(id, ifaceType); if (ctlElem->name) { snd_ctl_elem_id_set_name(id, ctlElem->name); @@ -882,8 +883,8 @@ static int32_t SetElementInfo(snd_ctl_t *alsaHandle, const struct AlsaMixerCtlEl return HDF_SUCCESS; } -int32_t SndElementReadInt - (struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, long *value) +int32_t SndElementReadInt(struct AlsaSoundCard *cardIns, + const struct AlsaMixerCtlElement *ctlElem, long *value) { int ret; snd_ctl_t *alsaHandle = NULL; @@ -934,8 +935,8 @@ int32_t SndElementReadInt return HDF_SUCCESS; } -int32_t SndElementReadEnum - (struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, unsigned int *item) +int32_t SndElementReadEnum( + struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, unsigned int *item) { int ret; snd_ctl_t *alsaHandle = NULL; @@ -984,8 +985,8 @@ int32_t SndElementReadEnum return HDF_SUCCESS; } -int32_t SndElementReadRange - (struct AlsaSoundCard * cardIns, const struct AlsaMixerCtlElement * ctlElem, long * mix, long * max) +int32_t SndElementReadRange( + struct AlsaSoundCard * cardIns, const struct AlsaMixerCtlElement * ctlElem, long * mix, long * max) { int ret; snd_ctl_t *alsaHandle = NULL; @@ -1024,7 +1025,7 @@ int32_t SndElementReadRange } type = snd_ctl_elem_info_get_type(elem_info); - if(type == SND_CTL_ELEM_TYPE_INTEGER) { + if (type == SND_CTL_ELEM_TYPE_INTEGER) { *mix = snd_ctl_elem_info_get_min(elem_info); *max = snd_ctl_elem_info_get_max(elem_info); } else if (type == SND_CTL_ELEM_TYPE_INTEGER64) { @@ -1038,8 +1039,8 @@ int32_t SndElementReadRange return HDF_SUCCESS; } -int32_t SndElementReadSwitch - (struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, bool *on) +int32_t SndElementReadSwitch( + struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, bool *on) { int ret; snd_ctl_t *alsaHandle = NULL; @@ -1089,8 +1090,8 @@ int32_t SndElementReadSwitch return HDF_SUCCESS; } -int32_t SndElementWriteInt - (struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, long value) +int32_t SndElementWriteInt( + struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, long value) { int ret; snd_ctl_t *alsaHandle = NULL; @@ -1142,8 +1143,8 @@ int32_t SndElementWriteInt return HDF_SUCCESS; } -int32_t SndElementWriteEnum - (struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, unsigned int item) +int32_t SndElementWriteEnum( + struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, unsigned int item) { int ret; snd_ctl_t *alsaHandle = NULL; @@ -1193,8 +1194,8 @@ int32_t SndElementWriteEnum return HDF_SUCCESS; } -int32_t SndElementWriteSwitch - (struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, bool on) +int32_t SndElementWriteSwitch( + struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, bool on) { int ret; int value; @@ -1212,7 +1213,7 @@ int32_t SndElementWriteSwitch AUDIO_FUNC_LOGE("snd_ctl_open error: %{public}s", snd_strerror(ret)); return HDF_FAILURE; } - + snd_ctl_elem_id_alloca(&elem_id); snd_ctl_elem_info_alloca(&elem_info); snd_ctl_elem_value_alloca(&elem_value); @@ -1246,8 +1247,8 @@ int32_t SndElementWriteSwitch return HDF_SUCCESS; } -int32_t SndElementWrite - (struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem) +int32_t SndElementWrite( + struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem) { int ret; snd_ctl_t *alsaHandle = NULL; @@ -1293,15 +1294,15 @@ int32_t SndElementWrite return HDF_SUCCESS; } -int32_t SndElementGroupWrite - (struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement* elemGroup, int32_t groupSize) +int32_t SndElementGroupWrite( + struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement* elemGroup, int32_t groupSize) { int err; CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); - for(int i = 0; i < groupSize; ++i){ + for (int i = 0; i < groupSize; ++i) { err = SndElementWrite(cardIns, &elemGroup[i]); - if(err < 0){ + if(err < 0) { AUDIO_FUNC_LOGE("Cant't set element %{public}s", elemGroup[i].name); } } -- Gitee From 7c065b2d0cecf829def3ee29266e028a77cc7d7e Mon Sep 17 00:00:00 2001 From: xiesicong Date: Tue, 26 Sep 2023 10:41:37 +0800 Subject: [PATCH 14/14] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E4=BB=A3=E7=A0=81?= =?UTF-8?q?=E6=A0=BC=E5=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xiesicong --- .../alsa_adapter/include/alsa_snd_render.h | 2 +- .../alsa_adapter/include/alsa_soundcard.h | 2 +- .../alsa_adapter/src/alsa_lib_capture.c | 4 +- .../alsa_adapter/src/alsa_lib_render.c | 3 +- .../alsa_adapter/src/alsa_snd_capture.c | 70 +++++---- .../alsa_adapter/src/alsa_snd_render.c | 8 +- .../alsa_adapter/src/alsa_soundcard.c | 143 +++++++++--------- 7 files changed, 114 insertions(+), 118 deletions(-) diff --git a/audio/supportlibs/alsa_adapter/include/alsa_snd_render.h b/audio/supportlibs/alsa_adapter/include/alsa_snd_render.h index 2a1664741a..b0ab1b9de0 100755 --- a/audio/supportlibs/alsa_adapter/include/alsa_snd_render.h +++ b/audio/supportlibs/alsa_adapter/include/alsa_snd_render.h @@ -25,7 +25,7 @@ extern "C" { typedef void* RenderPriData; typedef struct AlsaRender AlsaRender; -struct AlsaRender{ +struct AlsaRender { struct AlsaSoundCard soundCard; enum AudioPortPin descPins; bool muteState; diff --git a/audio/supportlibs/alsa_adapter/include/alsa_soundcard.h b/audio/supportlibs/alsa_adapter/include/alsa_soundcard.h index 14e3b39aa2..c681c2c944 100755 --- a/audio/supportlibs/alsa_adapter/include/alsa_soundcard.h +++ b/audio/supportlibs/alsa_adapter/include/alsa_soundcard.h @@ -77,7 +77,7 @@ struct AlsaMixerCtlElement { }; typedef struct AlsaSoundCard AlsaSoundCard; -struct AlsaSoundCard{ +struct AlsaSoundCard { /* save alsa soundcard base info and hardware params */ diff --git a/audio/supportlibs/alsa_adapter/src/alsa_lib_capture.c b/audio/supportlibs/alsa_adapter/src/alsa_lib_capture.c index 9597542389..ef41b3b013 100644 --- a/audio/supportlibs/alsa_adapter/src/alsa_lib_capture.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_lib_capture.c @@ -205,7 +205,7 @@ int32_t AudioCtlCaptureGetVolThreshold( int32_t ret; long volMax = MIN_VOLUME; long volMin = MIN_VOLUME; - struct AlsaCapture * captureIns = NULL; + struct AlsaCapture *captureIns = NULL; CHECK_NULL_PTR_RETURN_DEFAULT(handleData); captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName); @@ -299,7 +299,7 @@ int32_t AudioOutputCaptureOpen( const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData) { int32_t ret; - struct AlsaCapture * captureIns = NULL; + struct AlsaCapture *captureIns = NULL; CHECK_NULL_PTR_RETURN_DEFAULT(handleData); captureIns = CaptureCreateInstance(handleData->captureMode.hwInfo.adapterName); diff --git a/audio/supportlibs/alsa_adapter/src/alsa_lib_render.c b/audio/supportlibs/alsa_adapter/src/alsa_lib_render.c index 286ec253a0..2940d257c1 100644 --- a/audio/supportlibs/alsa_adapter/src/alsa_lib_render.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_lib_render.c @@ -334,7 +334,7 @@ int32_t AudioOutputRenderOpen( const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData) { int32_t ret; - struct AlsaRender * renderIns = NULL; + struct AlsaRender *renderIns = NULL; CHECK_NULL_PTR_RETURN_DEFAULT(handleData); renderIns = RenderCreateInstance(handleData->renderMode.hwInfo.adapterName); @@ -363,7 +363,6 @@ int32_t AudioOutputRenderWrite( struct AlsaRender *renderIns = NULL; CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName); CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); diff --git a/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c b/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c index c58b76023f..b76d33e94e 100755 --- a/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c @@ -255,14 +255,12 @@ static int32_t SetSWParams(struct AlsaSoundCard *cardIns) CHECK_NULL_PTR_RETURN_DEFAULT(handle); snd_pcm_sw_params_alloca(&swParams); - /* get the current swparams */ ret = snd_pcm_sw_params_current(handle, swParams); if (ret < 0) { AUDIO_FUNC_LOGE("Unable to determine current swparams for capture: %{public}s.", snd_strerror(ret)); return HDF_FAILURE; } - if (captureIns->periodSize == 0) { AUDIO_FUNC_LOGE("error: g_periodSize cannot be zero!"); return HDF_FAILURE; @@ -293,7 +291,6 @@ static int32_t SetSWParams(struct AlsaSoundCard *cardIns) return HDF_FAILURE; } } - /* write the parameters to the capture device */ ret = snd_pcm_sw_params(handle, swParams); if (ret < 0) { @@ -667,22 +664,10 @@ static int32_t CaptureCloseImpl(struct AlsaCapture *captureIns) return HDF_SUCCESS; } -static int32_t CaptureReadImpl(struct AlsaCapture *captureIns, struct AudioHwCaptureParam *handleData) +static int32_t CaptureCheckMmapMode(struct AlsaSoundCard *cardIns) { int32_t ret; - uint64_t frames = 0; - char *buffer = NULL; - snd_pcm_uframes_t bufferSize = 0; - snd_pcm_uframes_t periodSize = 0; - struct AlsaSoundCard *cardIns = (struct AlsaSoundCard *)captureIns; - CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); - CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - - ret = snd_pcm_get_params(cardIns->pcmHandle, &bufferSize, &periodSize); - if (ret < 0) { - AUDIO_FUNC_LOGE("Get capture params error: %{public}s.", snd_strerror(ret)); - return HDF_FAILURE; - } + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); if (!cardIns->mmapFlag) { ret = ResetCaptureParams(cardIns, SND_PCM_ACCESS_RW_INTERLEAVED); @@ -690,6 +675,7 @@ static int32_t CaptureReadImpl(struct AlsaCapture *captureIns, struct AudioHwCap AUDIO_FUNC_LOGE("AudioSetParamsMmap failed!"); return ret; } + ret = snd_pcm_start(cardIns->pcmHandle); if (ret < 0) { AUDIO_FUNC_LOGE("snd_pcm_start fail. %{public}s", snd_strerror(ret)); @@ -697,42 +683,56 @@ static int32_t CaptureReadImpl(struct AlsaCapture *captureIns, struct AudioHwCap } cardIns->mmapFlag = true; } + return HDF_SUCCESS; +} - buffer = OsalMemCalloc(ALSA_CAP_BUFFER_SIZE); - if (buffer == NULL) { - AUDIO_FUNC_LOGE("Failed to Calloc buffer"); +static int32_t CaptureReadImpl(struct AlsaCapture *captureIns, struct AudioHwCaptureParam *handleData) +{ + int32_t ret; + uint64_t frames = 0; + char *buffer = NULL; + snd_pcm_uframes_t bufferSize = 0; + snd_pcm_uframes_t periodSize = 0; + struct AlsaSoundCard *cardIns = (struct AlsaSoundCard *)captureIns; + CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); + CHECK_NULL_PTR_RETURN_DEFAULT(handleData); + + ret = snd_pcm_get_params(cardIns->pcmHandle, &bufferSize, &periodSize); + if (ret < 0) { + AUDIO_FUNC_LOGE("Get capture params error: %{public}s.", snd_strerror(ret)); + return HDF_FAILURE; + } + if(CaptureCheckMmapMode(cardIns) != HDF_SUCCESS) { return HDF_FAILURE; } - ret = CheckCapFrameBufferSize(handleData, &periodSize); - if (ret != HDF_SUCCESS) { + if (CheckCapFrameBufferSize(handleData, &periodSize) != HDF_SUCCESS) { AUDIO_FUNC_LOGE("CheckCapFrameBufferSize failed."); - AudioMemFree((void **)&buffer); - return ret; + return HDF_FAILURE; } - - ret = CheckPcmStatus(cardIns->pcmHandle); - if (ret != HDF_SUCCESS) { + if (CheckPcmStatus(cardIns->pcmHandle) != HDF_SUCCESS) { AUDIO_FUNC_LOGE("CheckPcmStatus failed."); - AudioMemFree((void **)&buffer); - return ret; + return HDF_FAILURE; + } + buffer = OsalMemCalloc(ALSA_CAP_BUFFER_SIZE); + if (buffer == NULL) { + AUDIO_FUNC_LOGE("Failed to Calloc buffer"); + return HDF_FAILURE; } - ret = CapturePcmReadi(cardIns->pcmHandle, &frames, buffer, periodSize); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("CapturePcmReadi is error!"); AudioMemFree((void **)&buffer); return ret; } - ret = CaptureDataCopy(handleData, buffer, frames); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("Failed to copy data. It may be paused. Check the status!"); AudioMemFree((void **)&buffer); return ret; } - AudioMemFree((void **)&buffer); + AudioMemFree((void **)&buffer); return HDF_SUCCESS; } @@ -743,7 +743,6 @@ static int32_t CaptureGetMmapPositionImpl(struct AlsaCapture *captureIns) static int32_t CaptureMmapReadImpl(struct AlsaCapture *captureIns, const struct AudioHwCaptureParam *handleData) { - int32_t ret; char *mmapAddr; uint32_t frameSize; snd_pcm_sframes_t xfer; @@ -752,10 +751,9 @@ static int32_t CaptureMmapReadImpl(struct AlsaCapture *captureIns, const struct CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); CHECK_NULL_PTR_RETURN_DEFAULT(handleData); - ret = UpdateSetParams(cardIns); - if (ret != HDF_SUCCESS) { + if (UpdateSetParams(cardIns) != HDF_SUCCESS) { AUDIO_FUNC_LOGE("Update set params failed!"); - return ret; + return HDF_FAILURE; } mmapAddr = (char *)handleData->frameCaptureMode.mmapBufDesc.memoryAddress; diff --git a/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c b/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c index 57f97ba402..755e67c214 100755 --- a/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c @@ -529,7 +529,7 @@ static int32_t RenderHwParamsChmaps(struct AlsaSoundCard *cardIns) int32_t RenderSetParams(struct AlsaRender *renderIns, const struct AudioHwRenderParam *handleData) { int32_t ret; - int bits_per_sample; + int bitsPerSample; snd_pcm_format_t fmt; struct AlsaSoundCard *cardIns = (struct AlsaSoundCard *)renderIns; CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); @@ -556,8 +556,8 @@ int32_t RenderSetParams(struct AlsaRender *renderIns, const struct AudioHwRender #endif SndConverAlsaPcmFormat(&cardIns->hwParams, &fmt); - bits_per_sample = snd_pcm_format_physical_width(fmt); - cardIns->hwParams.bitsPerFrame = bits_per_sample * cardIns->hwParams.channels; + bitsPerSample = snd_pcm_format_physical_width(fmt); + cardIns->hwParams.bitsPerFrame = bitsPerSample * cardIns->hwParams.channels; return HDF_SUCCESS; } @@ -567,7 +567,7 @@ static int32_t RenderWritei(snd_pcm_t *pcm, const struct AudioHwRenderParam *han { int32_t ret, offset; long frames; - char * dataBuf; + char *dataBuf; size_t sbufFrameSize; snd_pcm_state_t state; int32_t tryNum = AUDIO_ALSALIB_RETYR; diff --git a/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c b/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c index 5453ef7dda..165d3d3210 100755 --- a/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c @@ -108,7 +108,7 @@ static char *CfgReadAdapterFile(const char *fpath) static int32_t CfgGetAdapterCount() { int32_t num = 0; - for(enum SndCardType type = SND_CARD_PRIMARY; type < SND_CARD_MAX; ++type) { + for (enum SndCardType type = SND_CARD_PRIMARY; type < SND_CARD_MAX; ++type) { num += g_alsaAdapterList[type].num; } return num; @@ -116,15 +116,15 @@ static int32_t CfgGetAdapterCount() static enum SndCardType CfgGetAdapterCardType(const char* adapterName) { - if(adapterName == NULL) { + if (adapterName == NULL) { return SND_CARD_UNKNOWN; } struct AlsaAdapterCfgInfo *info; - for(enum SndCardType type = SND_CARD_PRIMARY; type < SND_CARD_MAX; ++type) { - for(int32_t i = 0; i < g_alsaAdapterList[type].num; ++i) { + for (enum SndCardType type = SND_CARD_PRIMARY; type < SND_CARD_MAX; ++type) { + for (int32_t i = 0; i < g_alsaAdapterList[type].num; ++i) { info = &g_alsaAdapterList[type].list[i]; - if(strcmp(adapterName, info->adapterName) == 0) { + if (strcmp(adapterName, info->adapterName) == 0) { return type; } } @@ -134,15 +134,15 @@ static enum SndCardType CfgGetAdapterCardType(const char* adapterName) static struct AlsaAdapterCfgInfo *CfgGetAdapterInfo(const char* adapterName) { - if(adapterName == NULL) { + if (adapterName == NULL) { return NULL; } struct AlsaAdapterCfgInfo *info; - for(enum SndCardType type = SND_CARD_PRIMARY; type < SND_CARD_MAX; ++type) { - for(int32_t i = 0; i < g_alsaAdapterList[type].num; ++i) { + for (enum SndCardType type = SND_CARD_PRIMARY; type < SND_CARD_MAX; ++type) { + for (int32_t i = 0; i < g_alsaAdapterList[type].num; ++i) { info = &g_alsaAdapterList[type].list[i]; - if(strcmp(adapterName, info->adapterName) == 0) { + if (strcmp(adapterName, info->adapterName) == 0) { return info; } } @@ -166,7 +166,7 @@ static int32_t CfgDumpAdapterInfo(struct AlsaAdapterCfgInfo *info) cardType = SND_CARD_BT; } - if(cardType == SND_CARD_UNKNOWN) { + if (cardType == SND_CARD_UNKNOWN) { AUDIO_FUNC_LOGE("Error: %{public}s is unspupported adapter name", info->adapterName); } @@ -227,7 +227,7 @@ static int32_t CfgSaveAdapterStruct(cJSON *adapter, struct AlsaAdapterCfgInfo *i static int32_t CfgParseAdapterItems(cJSON *adapterObj) { - int32_t ret, adapterNum; + int32_t ret, adapterNum; cJSON *adapterItems = NULL; adapterItems = cJSON_GetObjectItem(adapterObj, "adapters"); @@ -239,34 +239,33 @@ static int32_t CfgParseAdapterItems(cJSON *adapterObj) if (adapterNum <= 0) { AUDIO_FUNC_LOGE("Get adapter number failed!"); return HDF_FAILURE; - } - else if (adapterNum > MAX_CARD_NUM) { + } else if (adapterNum > MAX_CARD_NUM) { AUDIO_FUNC_LOGE("Read adapters number is %{public}d over max num %{public}d!", adapterNum, MAX_CARD_NUM); return HDF_FAILURE; } - for(int32_t i = 0; i < adapterNum; ++i) { + for (int32_t i = 0; i < adapterNum; ++i) { cJSON *adapter; struct AlsaAdapterCfgInfo info; adapter = cJSON_GetArrayItem(adapterItems, i); - if(adapter == NULL) { + if (adapter == NULL) { AUDIO_FUNC_LOGE("Get adapter item from array failed!"); } ret = CfgSaveAdapterStruct(adapter, &info); - if(ret != HDF_SUCCESS) { + if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("CfgSaveAdapterStruct failed!"); return HDF_FAILURE; } ret = CfgDumpAdapterInfo(&info); - if(ret != HDF_SUCCESS) { + if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("CfgDumpAdapterInfo failed!"); return HDF_FAILURE; } } - return HDF_SUCCESS; + return HDF_SUCCESS; } int32_t CfgSaveAdapterFromFile(void) @@ -289,23 +288,23 @@ int32_t CfgSaveAdapterFromFile(void) AudioMemFree((void **)&configBuf); ret = CfgParseAdapterItems(adapterObj); - if(ret != HDF_SUCCESS) { + if (ret != HDF_SUCCESS) { cJSON_Delete(adapterObj); AUDIO_FUNC_LOGE("Parse adapter items failed!"); return HDF_FAILURE; } - cJSON_Delete(adapterObj); + cJSON_Delete(adapterObj); return HDF_SUCCESS; } static struct AlsaDevInfo *DevGetInfoByCardId(int32_t cardId) { - struct AlsaDevInfo * info = NULL; + struct AlsaDevInfo *info = NULL; int num = g_alsaCardsDevList.num; - for(int i = 0; i < num; ++i) { + for (int i = 0; i < num; ++i) { info = &g_alsaCardsDevList.alsaDevIns[i]; - if(info->card == cardId) { + if (info->card == cardId) { return info; } } @@ -316,9 +315,9 @@ static struct AlsaDevInfo *DevGetInfoByPcmInfoId(const char * name) { struct AlsaDevInfo *info = NULL; int num = g_alsaCardsDevList.num; - for(int i = 0; i < num; ++i) { + for (int i = 0; i < num; ++i) { info = &g_alsaCardsDevList.alsaDevIns[i]; - if(strcmp(name, info->pcmInfoId) == 0) { + if (strcmp(name, info->pcmInfoId) == 0) { return info; } } @@ -368,7 +367,7 @@ static int32_t DevSaveCardPcmInfo(snd_ctl_t *handle, snd_pcm_stream_t stream, in return HDF_FAILURE; } g_alsaCardsDevList.num++; - if(snd_ctl_pcm_next_device(handle, &pcmDev) < 0) { + if (snd_ctl_pcm_next_device(handle, &pcmDev) < 0) { AUDIO_FUNC_LOGE("snd_ctl_pcm_next_device error!"); return HDF_FAILURE; } @@ -399,14 +398,14 @@ static int32_t DevSaveDriverInfo(snd_pcm_stream_t stream) } ret = snd_ctl_open(&handle, deviceName, 0); - if(ret != 0) { + if (ret != 0) { AUDIO_FUNC_LOGE("snd_ctl_open failed."); return HDF_FAILURE; } ret = DevSaveCardPcmInfo(handle, stream, card, deviceName); - if(ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("save alsa sound cards %{public}s pcm info failed!",deviceName); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("save alsa sound cards %{public}s pcm info failed!", deviceName); } ret = snd_ctl_close(handle); @@ -450,7 +449,7 @@ int32_t SndSaveCardListInfo(snd_pcm_stream_t stream) /* if the alsa hardware include usb then add to adapter list */ struct AlsaDevInfo *devInfo = DevGetInfoByPcmInfoId(USB_AUDIO); - if(devInfo != NULL) { + if (devInfo != NULL) { g_alsaAdapterList[SND_CARD_USB].num = 1; ret = memcpy_s((void*)&g_alsaAdapterList[SND_CARD_USB].list[0].adapterName, MAX_CARD_NAME_LEN, USB_AUDIO, sizeof(USB_AUDIO)); @@ -468,42 +467,42 @@ int32_t SndMatchSelAdapter(struct AlsaSoundCard *cardIns, const char *adapterNam int32_t ret; enum SndCardType cardType; struct AlsaAdapterCfgInfo *info = NULL; - struct AlsaDevInfo * devInfo = NULL; + struct AlsaDevInfo *devInfo = NULL; CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); CHECK_NULL_PTR_RETURN_DEFAULT(adapterName); cardType = CfgGetAdapterCardType(adapterName); - if(cardType == SND_CARD_UNKNOWN) { + if (cardType == SND_CARD_UNKNOWN) { AUDIO_FUNC_LOGE("unknow card type error."); return HDF_FAILURE; } cardIns->cardType = cardType; info = CfgGetAdapterInfo(adapterName); - if(info == NULL) { + if (info == NULL) { AUDIO_FUNC_LOGE("adapter %{public}s is not exits.", cardIns->adapterName); return HDF_FAILURE; } devInfo = DevGetInfoByCardId(info->cardId); - if(devInfo == NULL) { + if (devInfo == NULL) { AUDIO_FUNC_LOGE("adapter %{public}s cant not find sound card device.", cardIns->adapterName); return HDF_FAILURE; } ret = snprintf_s(cardIns->devName, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "hw:%d,%d", devInfo->card, devInfo->device); - if(ret < 0) { + if (ret < 0) { AUDIO_FUNC_LOGE("%{public}s snprintf_s devName failed", cardIns->adapterName); return HDF_FAILURE; } ret = snprintf_s(cardIns->ctrlName, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "hw:%d", devInfo->card); - if(ret < 0) { + if (ret < 0) { AUDIO_FUNC_LOGE("%{public}s snprintf_s ctrlName failed", cardIns->adapterName); return HDF_FAILURE; } ret = snprintf_s(cardIns->alsaCardId, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "%s", devInfo->cardId); - if(ret < 0) { + if (ret < 0) { AUDIO_FUNC_LOGE("%{public}s snprintf_s alsaCardId failed", cardIns->adapterName); return HDF_FAILURE; } @@ -534,7 +533,7 @@ int32_t SndConverAlsaPcmFormat(const struct AudioPcmHwParams *hwParams, snd_pcm_ *alsaPcmFormat = SND_PCM_FORMAT_S32_LE; /** Signed 32 bit Little Endian */ break; default: - AUDIO_FUNC_LOGE("not support format %{public}d",audioFormat); + AUDIO_FUNC_LOGE("not support format %{public}d", audioFormat); return HDF_ERR_NOT_SUPPORT; } } else { /** Big Endian */ @@ -552,7 +551,7 @@ int32_t SndConverAlsaPcmFormat(const struct AudioPcmHwParams *hwParams, snd_pcm_ *alsaPcmFormat = SND_PCM_FORMAT_S32_BE; /** Signed 32 bit Big Endian */ break; default: - AUDIO_FUNC_LOGE("not support format %{public}d",audioFormat); + AUDIO_FUNC_LOGE("not support format %{public}d", audioFormat); return HDF_ERR_NOT_SUPPORT; } } @@ -583,7 +582,7 @@ int32_t SndPcmPause(struct AlsaSoundCard *cardIns, bool state) return HDF_FAILURE; } } else { - if(enable == AUDIO_ALSALIB_IOCTRL_PAUSE) { + if (enable == AUDIO_ALSALIB_IOCTRL_PAUSE) { snd_pcm_drop(cardIns->pcmHandle); } else { snd_pcm_prepare(cardIns->pcmHandle); @@ -693,7 +692,7 @@ static int32_t AudioInitPorts(struct AudioAdapterDescriptor *desc, enum SndCardT uint8_t portNum; CHECK_NULL_PTR_RETURN_DEFAULT(desc); - switch(type) { + switch (type) { case SND_CARD_PRIMARY: portNum = PORT_OUT_IN; break; @@ -720,7 +719,7 @@ static int32_t AudioInitPorts(struct AudioAdapterDescriptor *desc, enum SndCardT return HDF_ERR_MALLOC_FAIL; } - if(type == SND_CARD_PRIMARY) { + if (type == SND_CARD_PRIMARY) { AudioInitPortOut(&desc->ports[0]); AudioInitPortIn(&desc->ports[SUPPORT_CAPTURE_OR_RENDER]); AudioInitPortOutAndIn(&desc->ports[SUPPORT_CAPTURE_AND_RENDER]); @@ -818,7 +817,7 @@ void SndElementItemInit(struct AlsaMixerCtlElement *m) static snd_ctl_elem_iface_t ConvertIfaceType(enum SndIfaceType iface) { snd_ctl_elem_iface_t snd_iface; - switch(iface) { + switch (iface) { case IFACE_CARD: snd_iface = SND_CTL_ELEM_IFACE_CARD; break; @@ -844,7 +843,7 @@ static snd_ctl_elem_iface_t ConvertIfaceType(enum SndIfaceType iface) return snd_iface; } -static int32_t SetElementInfo(snd_ctl_t *alsaHandle, const struct AlsaMixerCtlElement *ctlElem, +static int32_t SetElementInfo(snd_ctl_t *alsaHandle, const struct AlsaMixerCtlElement *ctlElem, snd_ctl_elem_info_t *info, snd_ctl_elem_id_t *id) { int32_t ret; @@ -906,13 +905,13 @@ int32_t SndElementReadInt(struct AlsaSoundCard *cardIns, snd_ctl_elem_info_alloca(&elem_info); snd_ctl_elem_value_alloca(&elem_value); ret = SetElementInfo(alsaHandle, ctlElem, elem_info, elem_id); - if(ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("Set element %{public}s elem_info failed!\n",ctlElem->name); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Set element %{public}s elem_info failed!\n", ctlElem->name); return HDF_FAILURE; } snd_ctl_elem_value_set_id(elem_value, elem_id); - if(!snd_ctl_elem_info_is_readable(elem_info)) { + if (!snd_ctl_elem_info_is_readable(elem_info)) { AUDIO_FUNC_LOGE("Element read enable\n"); return HDF_FAILURE; } @@ -958,13 +957,13 @@ int32_t SndElementReadEnum( snd_ctl_elem_info_alloca(&elem_info); snd_ctl_elem_value_alloca(&elem_value); ret = SetElementInfo(alsaHandle, ctlElem, elem_info, elem_id); - if(ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("Set element %{public}s elem_info failed!\n",ctlElem->name); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Set element %{public}s elem_info failed!\n", ctlElem->name); return HDF_FAILURE; } snd_ctl_elem_value_set_id(elem_value, elem_id); - if(!snd_ctl_elem_info_is_readable(elem_info)) { + if (!snd_ctl_elem_info_is_readable(elem_info)) { AUDIO_FUNC_LOGE("Element read enable\n"); return HDF_FAILURE; } @@ -975,7 +974,7 @@ int32_t SndElementReadEnum( } type = snd_ctl_elem_info_get_type(elem_info); - if(type == SND_CTL_ELEM_TYPE_ENUMERATED) { + if (type == SND_CTL_ELEM_TYPE_ENUMERATED) { *item = snd_ctl_elem_value_get_enumerated(elem_value, 0); } else { AUDIO_FUNC_LOGE("Element type is not enumerated\n"); @@ -1008,13 +1007,13 @@ int32_t SndElementReadRange( snd_ctl_elem_info_alloca(&elem_info); snd_ctl_elem_value_alloca(&elem_value); ret = SetElementInfo(alsaHandle, ctlElem, elem_info, elem_id); - if(ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("Set element %{public}s elem_info failed!\n",ctlElem->name); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Set element %{public}s elem_info failed!\n", ctlElem->name); return HDF_FAILURE; } snd_ctl_elem_value_set_id(elem_value, elem_id); - if(!snd_ctl_elem_info_is_readable(elem_info)) { + if (!snd_ctl_elem_info_is_readable(elem_info)) { AUDIO_FUNC_LOGE("Element read enable\n"); return HDF_FAILURE; } @@ -1062,13 +1061,13 @@ int32_t SndElementReadSwitch( snd_ctl_elem_info_alloca(&elem_info); snd_ctl_elem_value_alloca(&elem_value); ret = SetElementInfo(alsaHandle, ctlElem, elem_info, elem_id); - if(ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("Set element %{public}s elem_info failed!\n",ctlElem->name); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Set element %{public}s elem_info failed!\n", ctlElem->name); return HDF_FAILURE; } snd_ctl_elem_value_set_id(elem_value, elem_id); - if(!snd_ctl_elem_info_is_readable(elem_info)) { + if (!snd_ctl_elem_info_is_readable(elem_info)) { AUDIO_FUNC_LOGE("Element read enable\n"); return HDF_FAILURE; } @@ -1079,7 +1078,7 @@ int32_t SndElementReadSwitch( } type = snd_ctl_elem_info_get_type(elem_info); - if(type == SND_CTL_ELEM_TYPE_BOOLEAN) { + if (type == SND_CTL_ELEM_TYPE_BOOLEAN) { ret = snd_ctl_elem_value_get_boolean(elem_value, 0); *on = (ret > 0) ? true : false; } else { @@ -1113,19 +1112,19 @@ int32_t SndElementWriteInt( snd_ctl_elem_info_alloca(&elem_info); snd_ctl_elem_value_alloca(&elem_value); ret = SetElementInfo(alsaHandle, ctlElem, elem_info, elem_id); - if(ret != HDF_SUCCESS) { + if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("Set element %{public}s elem_info failed!\n", ctlElem->name); return HDF_FAILURE; } - if(!snd_ctl_elem_info_is_writable(elem_info)) { + if (!snd_ctl_elem_info_is_writable(elem_info)) { AUDIO_FUNC_LOGE("Element write enable\n"); return HDF_FAILURE; } snd_ctl_elem_value_set_id(elem_value, elem_id); type = snd_ctl_elem_info_get_type(elem_info); - if(type == SND_CTL_ELEM_TYPE_INTEGER) { + if (type == SND_CTL_ELEM_TYPE_INTEGER) { snd_ctl_elem_value_set_integer(elem_value, 0, value); } else if (type == SND_CTL_ELEM_TYPE_INTEGER64) { snd_ctl_elem_value_set_integer64(elem_value, 0, (long long)value); @@ -1166,19 +1165,19 @@ int32_t SndElementWriteEnum( snd_ctl_elem_info_alloca(&elem_info); snd_ctl_elem_value_alloca(&elem_value); ret = SetElementInfo(alsaHandle, ctlElem, elem_info, elem_id); - if(ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("Set element %{public}s elem_info failed!\n",ctlElem->name); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Set element %{public}s elem_info failed!\n", ctlElem->name); return HDF_FAILURE; } - if(!snd_ctl_elem_info_is_writable(elem_info)) { + if (!snd_ctl_elem_info_is_writable(elem_info)) { AUDIO_FUNC_LOGE("Element write enable\n"); return HDF_FAILURE; } snd_ctl_elem_value_set_id(elem_value, elem_id); type = snd_ctl_elem_info_get_type(elem_info); - if(type == SND_CTL_ELEM_TYPE_ENUMERATED) { + if (type == SND_CTL_ELEM_TYPE_ENUMERATED) { snd_ctl_elem_value_set_enumerated(elem_value, 0, item); } else { AUDIO_FUNC_LOGE("Element value is not enum type!\n"); @@ -1218,19 +1217,19 @@ int32_t SndElementWriteSwitch( snd_ctl_elem_info_alloca(&elem_info); snd_ctl_elem_value_alloca(&elem_value); ret = SetElementInfo(alsaHandle, ctlElem, elem_info, elem_id); - if(ret != HDF_SUCCESS) { + if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("Set element %{public}s elem_info failed!\n", ctlElem->name); return HDF_FAILURE; } - if(!snd_ctl_elem_info_is_writable(elem_info)) { + if (!snd_ctl_elem_info_is_writable(elem_info)) { AUDIO_FUNC_LOGE("Element write enable\n"); return HDF_FAILURE; } snd_ctl_elem_value_set_id(elem_value, elem_id); type = snd_ctl_elem_info_get_type(elem_info); - if(type == SND_CTL_ELEM_TYPE_BOOLEAN) { + if (type == SND_CTL_ELEM_TYPE_BOOLEAN) { value = on ? 1 : 0; snd_ctl_elem_value_set_boolean(elem_value, 0, value); } else { @@ -1269,12 +1268,12 @@ int32_t SndElementWrite( snd_ctl_elem_info_alloca(&elem_info); snd_ctl_elem_value_alloca(&elem_value); ret = SetElementInfo(alsaHandle, ctlElem, elem_info, elem_id); - if(ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("Set element %{public}s elem_info failed!\n",ctlElem->name); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Set element %{public}s elem_info failed!\n", ctlElem->name); return HDF_FAILURE; } - if(!snd_ctl_elem_info_is_writable(elem_info)) { + if (!snd_ctl_elem_info_is_writable(elem_info)) { AUDIO_FUNC_LOGE("Element write enable\n"); return HDF_FAILURE; } @@ -1302,7 +1301,7 @@ int32_t SndElementGroupWrite( for (int i = 0; i < groupSize; ++i) { err = SndElementWrite(cardIns, &elemGroup[i]); - if(err < 0) { + if (err < 0) { AUDIO_FUNC_LOGE("Cant't set element %{public}s", elemGroup[i].name); } } -- Gitee