hdi_passthrough/src/audio_render.c

/*
 * Copyright (c) 2021 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#include "audio_render.h"
#include "osal_mem.h"
#include "audio_adapter_info_common.h"
#include "audio_interface_lib_render.h"
#include "audio_uhdf_log.h"

#define HDF_LOG_TAG HDF_AUDIO_HAL_IMPL

#define CONFIG_OUT_LATENCY_MS  100 // unit: ms

/* 1 buffer: 8000(8kHz sample rate) * 2(bytes, PCM_16_BIT) * 1(channel) */
/* 1 frame: 1024(sample) * 2(bytes, PCM_16_BIT) * 1(channel) */
#define CONFIG_FRAME_SIZE      (1024 * 2 * 1)
#define FRAME_SIZE              1024
#define CONFIG_FRAME_COUNT     ((8000 * 2 * 1 + (CONFIG_FRAME_SIZE - 1)) / CONFIG_FRAME_SIZE)

#define DEEP_BUFFER_PLATFORM_DELAY (29*1000LL)
#define LOW_LATENCY_PLATFORM_DELAY (13*1000LL)
#define BITS_TO_FROMAT              3
#define VOLUME_AVERAGE              2
#define INTEGER_TO_DEC              10
#define SEC_TO_MILLSEC              1000
#define DECIMAL_PART                5

int32_t PcmBytesToFrames(const struct AudioFrameRenderMode *frameRenderMode, uint64_t bytes, uint32_t *frameCount)
{
    if (frameRenderMode == NULL || frameCount == NULL) {
        AUDIO_FUNC_LOGE("param frameRenderMode or frameCount is null!");
        return HDF_FAILURE;
    }
    uint32_t formatBits = 0;
    int32_t ret = FormatToBits(frameRenderMode->attrs.format, &formatBits);
    if (ret != HDF_SUCCESS) {
        AUDIO_FUNC_LOGE("FormatToBits failed! ret = %{public}d", ret);
        return ret;
    }
    /* channelCount Not greater than 4 , formatBits Not greater than 64 */
    if (frameRenderMode->attrs.channelCount > 4 || formatBits > 64) {
        AUDIO_FUNC_LOGE("channelCount or formatBits check failed! channelCount = %{public}u, formatBits = %{public}u",
            frameRenderMode->attrs.channelCount, formatBits);
        return HDF_FAILURE;
    }
    uint32_t frameSize = frameRenderMode->attrs.channelCount * (formatBits >> 3); // Bit to byte >> 3
    if (frameSize == 0) {
        AUDIO_FUNC_LOGE("frameSize is zero! channelCount = %{public}u, formatBits = %{public}u",
            frameRenderMode->attrs.channelCount, formatBits);
        return HDF_FAILURE;
    }
    *frameCount = (uint32_t)bytes / frameSize;
    return HDF_SUCCESS;
}

int32_t AudioRenderStart(AudioHandle handle)
{
    int32_t ret = AudioCheckRenderAddr(handle);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid! ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
    if (hwRender == NULL) {
        AUDIO_FUNC_LOGE("The pointer is null");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender();
    if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) {
        AUDIO_FUNC_LOGE("pInterfaceLibModeRender Is NULL");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    if (!hwRender->renderParam.renderMode.ctlParam.stop) {
        AUDIO_FUNC_LOGE("AudioRender already start!");
        return AUDIO_HAL_ERR_AO_BUSY; // render is busy now
    }
    if (hwRender->devDataHandle == NULL) {
        return AUDIO_HAL_ERR_INTERNAL;
    }
    ret = (*pInterfaceLibModeRender)(hwRender->devDataHandle, &hwRender->renderParam,
                                     AUDIO_DRV_PCM_IOCTRL_START);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("AudioRenderStart SetParams FAIL");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    hwRender->renderParam.renderMode.ctlParam.stop = false;
    AudioLogRecord(INFO, "[%s]-[%s]-[%d] :> [%s]", __FILE__, __func__, __LINE__, "Audio Render Start");
    return AUDIO_HAL_SUCCESS;
}

int32_t AudioRenderStop(AudioHandle handle)
{
    AUDIO_FUNC_LOGI();
    int32_t ret = AudioCheckRenderAddr(handle);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid! ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
    if (hwRender == NULL) {
        AUDIO_FUNC_LOGE("hwRender is invalid");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    if (hwRender->renderParam.renderMode.ctlParam.stop) {
        AUDIO_FUNC_LOGE("Repeat invalid stop operation!");
        return AUDIO_HAL_ERR_NOT_SUPPORT;
    }
    hwRender->renderParam.renderMode.ctlParam.stop = true;
    if (hwRender->devDataHandle == NULL) {
        AUDIO_FUNC_LOGE("RenderStart Bind Fail!");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender();
    if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) {
        AUDIO_FUNC_LOGE("pInterfaceLibModeRender Is NULL");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    ret = (*pInterfaceLibModeRender)(hwRender->devDataHandle, &hwRender->renderParam,
                                     AUDIO_DRV_PCM_IOCTRL_STOP);
    hwRender->renderParam.renderMode.ctlParam.turnStandbyStatus = AUDIO_TURN_STANDBY_LATER;
    if (ret < 0) {
        AUDIO_FUNC_LOGE("AudioRenderStop SetParams FAIL");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    AudioLogRecord(INFO, "[%s]-[%s]-[%d] :> [%s]", __FILE__, __func__, __LINE__, "Audio Render Stop");
    return AUDIO_HAL_SUCCESS;
}

int32_t AudioRenderPause(AudioHandle handle)
{
    int32_t ret = AudioCheckRenderAddr(handle);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid! ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
    if (hwRender == NULL) {
        AUDIO_FUNC_LOGE("hwRender is null");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    if (hwRender->renderParam.renderMode.ctlParam.stop) {
        AUDIO_FUNC_LOGE("AudioRender already stop!");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    if (hwRender->renderParam.renderMode.ctlParam.pause) {
        AUDIO_FUNC_LOGE("Audio is already pause!");
        return AUDIO_HAL_ERR_NOT_SUPPORT;
    }
    if (hwRender->devDataHandle == NULL) {
        AUDIO_FUNC_LOGE("RenderPause Bind Fail!");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender();
    if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) {
        AUDIO_FUNC_LOGE("pInterfaceLibModeRender Is NULL");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    bool pauseStatus = hwRender->renderParam.renderMode.ctlParam.pause;
    hwRender->renderParam.renderMode.ctlParam.pause = true;
    ret = (*pInterfaceLibModeRender)(hwRender->devDataHandle, &hwRender->renderParam,
                                     AUDIODRV_CTL_IOCTL_PAUSE_WRITE);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("RenderPause FAIL!");
        hwRender->renderParam.renderMode.ctlParam.pause = pauseStatus;
        return AUDIO_HAL_ERR_INTERNAL;
    }
    AudioLogRecord(INFO, "[%s]-[%s]-[%d] :> [%s]", __FILE__, __func__, __LINE__, "Audio Render Pause");
    return AUDIO_HAL_SUCCESS;
}

int32_t AudioRenderResume(AudioHandle handle)
{
    AUDIO_FUNC_LOGI();
    int32_t ret = AudioCheckRenderAddr(handle);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid! ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
    if (hwRender == NULL) {
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    if (!hwRender->renderParam.renderMode.ctlParam.pause) {
        AUDIO_FUNC_LOGE("Audio is already Resume !");
        return AUDIO_HAL_ERR_NOT_SUPPORT;
    }
    if (hwRender->devDataHandle == NULL) {
        AUDIO_FUNC_LOGE("RenderResume Bind Fail!");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender();
    if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) {
        AUDIO_FUNC_LOGE("pInterfaceLibModeRender Is NULL");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    bool resumeStatus = hwRender->renderParam.renderMode.ctlParam.pause;
    hwRender->renderParam.renderMode.ctlParam.pause = false;
    ret = (*pInterfaceLibModeRender)(hwRender->devDataHandle, &hwRender->renderParam,
                                     AUDIODRV_CTL_IOCTL_PAUSE_WRITE);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("RenderResume FAIL!");
        hwRender->renderParam.renderMode.ctlParam.pause = resumeStatus;
        return AUDIO_HAL_ERR_INTERNAL;
    }
    AudioLogRecord(INFO, "[%s]-[%s]-[%d] :> [%s]", __FILE__, __func__, __LINE__, "Audio Render Resume");
    return AUDIO_HAL_SUCCESS;
}

int32_t AudioRenderFlush(AudioHandle handle)
{
    AUDIO_FUNC_LOGI();
    int32_t ret = AudioCheckRenderAddr(handle);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid");
        return ret;
    }
    struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
    if (hwRender == NULL) {
        AUDIO_FUNC_LOGE("hwRender is null!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    bool callBackStatus = hwRender->renderParam.renderMode.hwInfo.callBackEnable;
    if (callBackStatus) {
        return CallbackProcessing(hwRender, AUDIO_FLUSH_COMPLETED);
    }
    return AUDIO_HAL_ERR_NOT_SUPPORT;
}

int32_t AudioRenderGetFrameSize(AudioHandle handle, uint64_t *size)
{
    int32_t ret = AudioCheckRenderAddr(handle);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid! ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
    if (hwRender == NULL || size == NULL) {
        AUDIO_FUNC_LOGE("hwRender or size is null!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    uint32_t channelCount = hwRender->renderParam.frameRenderMode.attrs.channelCount;
    enum AudioFormat format = hwRender->renderParam.frameRenderMode.attrs.format;
    uint32_t formatBits = 0;
    ret = FormatToBits(format, &formatBits);
    if (ret != AUDIO_HAL_SUCCESS) {
        AUDIO_FUNC_LOGE("FormatToBits failed! ret = %{public}d", ret);
        return ret;
    }
    *size = FRAME_SIZE * channelCount * (formatBits >> BITS_TO_FROMAT);
    return AUDIO_HAL_SUCCESS;
}

int32_t AudioRenderGetFrameCount(AudioHandle handle, uint64_t *count)
{
    int32_t ret = AudioCheckRenderAddr(handle);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid! ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
    if (hwRender == NULL || count == NULL) {
        AUDIO_FUNC_LOGE("hwRender or count is null!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    *count = hwRender->renderParam.frameRenderMode.frames;
    return AUDIO_HAL_SUCCESS;
}

int32_t AudioRenderSetSampleAttributes(AudioHandle handle, const struct AudioSampleAttributes *attrs)
{
    int32_t ret = AudioCheckRenderAddr(handle);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid, ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
    if (hwRender == NULL || attrs == NULL || hwRender->devDataHandle == NULL) {
        AUDIO_FUNC_LOGE("hwRender or attrs or hwRender->devDataHandle is null!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    ret = AudioCheckParaAttr(attrs);
    if (ret != AUDIO_HAL_SUCCESS) {
        AUDIO_FUNC_LOGE("AudioCheckParaAttr failed! ret = %{public}d", ret);
        return ret;
    }
    /* attrs temp */
    struct AudioSampleAttributes tempAttrs = hwRender->renderParam.frameRenderMode.attrs;
    hwRender->renderParam.frameRenderMode.attrs.format = attrs->format;
    hwRender->renderParam.frameRenderMode.attrs.sampleRate = attrs->sampleRate;
    hwRender->renderParam.frameRenderMode.attrs.channelCount = attrs->channelCount;
    hwRender->renderParam.frameRenderMode.attrs.interleaved = attrs->interleaved;
    hwRender->renderParam.frameRenderMode.attrs.type = attrs->type;
    hwRender->renderParam.frameRenderMode.attrs.period = attrs->period;
    hwRender->renderParam.frameRenderMode.attrs.frameSize = attrs->frameSize;
    hwRender->renderParam.frameRenderMode.attrs.isBigEndian = attrs->isBigEndian;
    hwRender->renderParam.frameRenderMode.attrs.isSignedData = attrs->isSignedData;
    hwRender->renderParam.frameRenderMode.attrs.startThreshold = attrs->startThreshold;
    hwRender->renderParam.frameRenderMode.attrs.stopThreshold = attrs->stopThreshold;
    hwRender->renderParam.frameRenderMode.attrs.silenceThreshold = attrs->silenceThreshold;
    InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender();
    if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL || hwRender->devDataHandle == NULL) {
        hwRender->renderParam.frameRenderMode.attrs = tempAttrs;
        AUDIO_FUNC_LOGE("pInterfaceLibModeRender Is NULL");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    ret = (*pInterfaceLibModeRender)(hwRender->devDataHandle,
                                             &hwRender->renderParam,
                                             AUDIO_DRV_PCM_IOCTL_HW_PARAMS);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("SetSampleAttributes FAIL");
        hwRender->renderParam.frameRenderMode.attrs = tempAttrs;
        return AUDIO_HAL_ERR_INTERNAL;
    }
    return AUDIO_HAL_SUCCESS;
}

int32_t AudioRenderGetSampleAttributes(AudioHandle handle, struct AudioSampleAttributes *attrs)
{
    int32_t ret = AudioCheckRenderAddr(handle);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid");
        return ret;
    }
    struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
    if (hwRender == NULL || attrs == NULL) {
        AUDIO_FUNC_LOGE("hwRender or attrs is null!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    attrs->format = hwRender->renderParam.frameRenderMode.attrs.format;
    attrs->sampleRate = hwRender->renderParam.frameRenderMode.attrs.sampleRate;
    attrs->channelCount = hwRender->renderParam.frameRenderMode.attrs.channelCount;
    attrs->type = hwRender->renderParam.frameRenderMode.attrs.type;
    attrs->interleaved = hwRender->renderParam.frameRenderMode.attrs.interleaved;
    attrs->period = hwRender->renderParam.frameRenderMode.attrs.period;
    attrs->frameSize = hwRender->renderParam.frameRenderMode.attrs.frameSize;
    attrs->isBigEndian = hwRender->renderParam.frameRenderMode.attrs.isBigEndian;
    attrs->isSignedData = hwRender->renderParam.frameRenderMode.attrs.isSignedData;
    attrs->startThreshold = hwRender->renderParam.frameRenderMode.attrs.startThreshold;
    attrs->stopThreshold = hwRender->renderParam.frameRenderMode.attrs.stopThreshold;
    attrs->silenceThreshold = hwRender->renderParam.frameRenderMode.attrs.silenceThreshold;
    return AUDIO_HAL_SUCCESS;
}

int32_t AudioRenderGetCurrentChannelId(AudioHandle handle, uint32_t *channelId)
{
    AUDIO_FUNC_LOGI();
    int32_t ret = AudioCheckRenderAddr(handle);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid! ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
    if (hwRender == NULL || channelId == NULL) {
        AUDIO_FUNC_LOGE("hwRender or channelId is null!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    *channelId = hwRender->renderParam.frameRenderMode.attrs.channelCount;
    return AUDIO_HAL_SUCCESS;
}

int32_t AudioRenderCheckSceneCapability(AudioHandle handle, const struct AudioSceneDescriptor *scene,
                                        bool *supported)
{
    AUDIO_FUNC_LOGI();
    int32_t ret = AudioCheckRenderAddr(handle);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid! ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
    if (hwRender == NULL || scene == NULL || supported == NULL) {
        AUDIO_FUNC_LOGE("hwRender or scene or supported is null!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
#ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT
    *supported = false;
    /* Temporary storage does not save the structure */
    struct AudioHwRenderParam renderParam = hwRender->renderParam;
    renderParam.frameRenderMode.attrs.type = (enum AudioCategory)scene->scene.id;
    renderParam.renderMode.hwInfo.deviceDescript.pins = scene->desc.pins;
    PathSelAnalysisJson *pPathSelAnalysisJson = AudioSoGetPathSelAnalysisJson();
    if (pPathSelAnalysisJson == NULL) {
        AUDIO_FUNC_LOGE("pPathSelAnalysisJson Is NULL!");
        return AUDIO_HAL_ERR_NOT_SUPPORT;
    }
    ret = (*pPathSelAnalysisJson)((void *)&renderParam, CHECKSCENE_PATH_SELECT);
    if (ret < 0) {
        if (ret == AUDIO_HAL_ERR_NOT_SUPPORT) {
            AUDIO_FUNC_LOGE("AudioRenderCheckSceneCapability not Support!");
            return AUDIO_HAL_ERR_NOT_SUPPORT;
        } else {
            AUDIO_FUNC_LOGE("AudioRenderCheckSceneCapability fail!");
            return AUDIO_HAL_ERR_INTERNAL;
        }
    }
    *supported = true;
    return AUDIO_HAL_SUCCESS;
#else
    return AUDIO_HAL_ERR_NOT_SUPPORT;
#endif
}

int32_t AudioRenderSelectScene(AudioHandle handle, const struct AudioSceneDescriptor *scene)
{
    int32_t ret = AudioCheckRenderAddr(handle);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid! ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
    if (hwRender == NULL || scene == NULL) {
        AUDIO_FUNC_LOGE("hwRender or scene is null!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    if (hwRender->devCtlHandle == NULL) {
        AUDIO_FUNC_LOGE("RenderSelectScene Bind Fail!");
        return AUDIO_HAL_ERR_INTERNAL;
    }
#ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT
    PathSelAnalysisJson *pPathSelAnalysisJson = AudioSoGetPathSelAnalysisJson();
    if (pPathSelAnalysisJson == NULL) {
        AUDIO_FUNC_LOGE("pPathSelAnalysisJson Is NULL!");
        return AUDIO_HAL_ERR_NOT_SUPPORT;
    }
    enum AudioCategory sceneId = hwRender->renderParam.frameRenderMode.attrs.type;
    enum AudioPortPin descPins = hwRender->renderParam.renderMode.hwInfo.deviceDescript.pins;
    hwRender->renderParam.frameRenderMode.attrs.type = (enum AudioCategory)(scene->scene.id);
    hwRender->renderParam.renderMode.hwInfo.deviceDescript.pins = scene->desc.pins;
    if ((*pPathSelAnalysisJson)((void *)&hwRender->renderParam, RENDER_PATH_SELECT) < 0) {
        AUDIO_FUNC_LOGE("AudioRenderSelectScene Fail!");
        hwRender->renderParam.frameRenderMode.attrs.type = sceneId;
        hwRender->renderParam.renderMode.hwInfo.deviceDescript.pins = descPins;
        return AUDIO_HAL_ERR_INTERNAL;
    }
    InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender();
    if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) {
        AUDIO_FUNC_LOGE("pInterfaceLibModeRender Is NULL");
        hwRender->renderParam.frameRenderMode.attrs.type = sceneId;
        hwRender->renderParam.renderMode.hwInfo.deviceDescript.pins = descPins;
        return AUDIO_HAL_ERR_INTERNAL;
    }
    ret = (*pInterfaceLibModeRender)(hwRender->devCtlHandle, &hwRender->renderParam,
                                     AUDIODRV_CTL_IOCTL_SCENESELECT_WRITE);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("SetParams FAIL!");
        hwRender->renderParam.frameRenderMode.attrs.type = sceneId;
        hwRender->renderParam.renderMode.hwInfo.deviceDescript.pins = descPins;
        return AUDIO_HAL_ERR_INTERNAL;
    }
    return AUDIO_HAL_SUCCESS;
#else
    return AUDIO_HAL_ERR_NOT_SUPPORT;
#endif
}

int32_t AudioRenderSetMute(AudioHandle handle, bool mute)
{
    int32_t ret = AudioCheckRenderAddr(handle);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid! ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *impl = (struct AudioHwRender *)handle;
    if (impl == NULL) {
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    if (impl->devCtlHandle == NULL) {
        AUDIO_FUNC_LOGE("RenderSetMute Bind Fail!");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender();
    if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) {
        AUDIO_FUNC_LOGE("pInterfaceLibModeRender Is NULL");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    bool muteStatus = impl->renderParam.renderMode.ctlParam.mute;
    impl->renderParam.renderMode.ctlParam.mute = mute;
    ret = (*pInterfaceLibModeRender)(impl->devCtlHandle, &impl->renderParam, AUDIODRV_CTL_IOCTL_MUTE_WRITE);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("SetMute SetParams FAIL");
        impl->renderParam.renderMode.ctlParam.mute = muteStatus;
        return AUDIO_HAL_ERR_INTERNAL;
    }
    AudioLogRecord(INFO, "[%s]-[%s]-[%d] :> [Setmute = %d]", __FILE__, __func__, __LINE__, mute);
    return AUDIO_HAL_SUCCESS;
}

int32_t AudioRenderGetMute(AudioHandle handle, bool *mute)
{
    int32_t ret = AudioCheckRenderAddr(handle);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid! ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *impl = (struct AudioHwRender *)handle;
    if (impl == NULL || mute == NULL) {
        AUDIO_FUNC_LOGE("impl or mute is null!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }

    if (impl->devCtlHandle == NULL) {
        AUDIO_FUNC_LOGE("RenderGetMute Bind Fail!");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender();
    if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) {
        AUDIO_FUNC_LOGE("pInterfaceLibModeRender Is NULL");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    ret = (*pInterfaceLibModeRender)(impl->devCtlHandle, &impl->renderParam, AUDIODRV_CTL_IOCTL_MUTE_READ);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("Get Mute FAIL!");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    *mute = impl->renderParam.renderMode.ctlParam.mute;
    AUDIO_FUNC_LOGI("GetMute SUCCESS!");
    return AUDIO_HAL_SUCCESS;
}

int32_t AudioRenderSetVolume(AudioHandle handle, float volume)
{
    int32_t ret = AudioCheckRenderAddr(handle);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid! ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
    if (hwRender == NULL) {
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    float volumeTemp = hwRender->renderParam.renderMode.ctlParam.volume;
    float volMax = (float)hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax;
    float volMin = (float)hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin;
    if (volume < 0 || volume > 1) {
        AUDIO_FUNC_LOGE("volume param Is error!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    if (hwRender->devCtlHandle == NULL) {
        AUDIO_FUNC_LOGE("RenderSetVolume Bind Fail!");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender();
    if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) {
        AUDIO_FUNC_LOGE("pInterfaceLibModeRender Is NULL");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    volume = (volume == 0) ? 1 : (volume * VOLUME_CHANGE);
    /* change volume to db */
    float volTemp = ((volMax - volMin) / 2) * log10(volume) + volMin;
    if (volTemp < volMin || volTemp > volMax) {
        AUDIO_FUNC_LOGE("volTemp fail");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    hwRender->renderParam.renderMode.ctlParam.volume = volTemp;
    ret = (*pInterfaceLibModeRender)(hwRender->devCtlHandle, &hwRender->renderParam,
                                     AUDIODRV_CTL_IOCTL_ELEM_WRITE);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("RenderSetVolume FAIL!");
        hwRender->renderParam.renderMode.ctlParam.volume = volumeTemp;
        return AUDIO_HAL_ERR_INTERNAL;
    }
    return AUDIO_HAL_SUCCESS;
}

int32_t AudioRenderGetVolume(AudioHandle handle, float *volume)
{
    int32_t ret = AudioCheckRenderAddr(handle);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid! ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
    if (hwRender == NULL || volume == NULL) {
        AUDIO_FUNC_LOGE("hwRender or volume is null!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    if (hwRender->devCtlHandle == NULL) {
        AUDIO_FUNC_LOGE("RenderGetVolume Bind Fail!");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender();
    if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) {
        AUDIO_FUNC_LOGE("pInterfaceLibModeRender Is NULL");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    ret = (*pInterfaceLibModeRender)(hwRender->devCtlHandle, &hwRender->renderParam, AUDIODRV_CTL_IOCTL_ELEM_READ);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("RenderGetVolume FAIL!");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    float volumeTemp = hwRender->renderParam.renderMode.ctlParam.volume;
    float volMax = (float)hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax;
    float volMin = (float)hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin;
    if ((volMax - volMin) == 0) {
        AUDIO_FUNC_LOGE("Divisor cannot be zero!");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    volumeTemp = (volumeTemp - volMin) / ((volMax - volMin) / VOLUME_AVERAGE);
    int volumeT = (int)((pow(INTEGER_TO_DEC, volumeTemp) + DECIMAL_PART) / INTEGER_TO_DEC); // delete 0.X num
    *volume = (float)volumeT / INTEGER_TO_DEC;                                               // get volume (0-1)
    return AUDIO_HAL_SUCCESS;
}

int32_t AudioRenderGetGainThreshold(AudioHandle handle, float *min, float *max)
{
    AUDIO_FUNC_LOGI();
    int32_t ret = AudioCheckRenderAddr(handle);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid! ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
    if (hwRender == NULL || min == NULL || max == NULL) {
        AUDIO_FUNC_LOGE("hwRender or min or max is null!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    if (hwRender->devCtlHandle == NULL) {
        AUDIO_FUNC_LOGE("RenderGetGainThreshold Bind Fail!");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender();
    if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) {
        AUDIO_FUNC_LOGE("pInterfaceLibModeRender Is NULL");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    ret = (*pInterfaceLibModeRender)(hwRender->devCtlHandle, &hwRender->renderParam,
                                     AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("GetGainThreshold FAIL!");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    *max = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMax;
    *min = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMin;
    return AUDIO_HAL_SUCCESS;
}

int32_t AudioRenderGetGain(AudioHandle handle, float *gain)
{
    AUDIO_FUNC_LOGI();
    int32_t ret = AudioCheckRenderAddr(handle);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid! ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *impl = (struct AudioHwRender *)handle;
    if (impl == NULL || gain == NULL) {
        AUDIO_FUNC_LOGE("impl or gain is null!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    if (impl->devCtlHandle == NULL) {
        AUDIO_FUNC_LOGE("RenderGetGain Bind Fail!");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender();
    if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) {
        AUDIO_FUNC_LOGE("pInterfaceLibModeRender Is NULL");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    ret = (*pInterfaceLibModeRender)(impl->devCtlHandle, &impl->renderParam, AUDIODRV_CTL_IOCTL_GAIN_READ);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("RenderGetGain FAIL");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    *gain = impl->renderParam.renderMode.ctlParam.audioGain.gain;
    AUDIO_FUNC_LOGI("RenderGetGain SUCCESS!");
    return AUDIO_HAL_SUCCESS;
}

int32_t AudioRenderSetGain(AudioHandle handle, float gain)
{
    AUDIO_FUNC_LOGI();
    int32_t ret = AudioCheckRenderAddr(handle);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid! ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *impl = (struct AudioHwRender *)handle;
    if (impl == NULL || gain < 0) {
        AUDIO_FUNC_LOGE("ipml is null or gain < 0");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    float gainTemp = impl->renderParam.renderMode.ctlParam.audioGain.gain;
    impl->renderParam.renderMode.ctlParam.audioGain.gain = gain;
    if (impl->devCtlHandle == NULL) {
        AUDIO_FUNC_LOGE("RenderSetGain Bind Fail!");
        impl->renderParam.renderMode.ctlParam.audioGain.gain = gainTemp;
        return AUDIO_HAL_ERR_INTERNAL;
    }
    InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender();
    if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) {
        AUDIO_FUNC_LOGE("pInterfaceLibModeRender Is NULL");
        impl->renderParam.renderMode.ctlParam.audioGain.gain = gainTemp;
        return AUDIO_HAL_ERR_INTERNAL;
    }
    ret = (*pInterfaceLibModeRender)(impl->devCtlHandle, &impl->renderParam, AUDIODRV_CTL_IOCTL_GAIN_WRITE);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("RenderSetGain FAIL");
        impl->renderParam.renderMode.ctlParam.audioGain.gain = gainTemp;
        return AUDIO_HAL_ERR_INTERNAL;
    }
    AUDIO_FUNC_LOGI("RenderSetGain SUCCESS!");
    return AUDIO_HAL_SUCCESS;
}

int32_t AudioRenderGetLatency(struct AudioRender *render, uint32_t *ms)
{
    int32_t ret = AudioCheckRenderAddr((AudioHandle)render);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid! ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *impl = (struct AudioHwRender *)render;
    if (impl == NULL || ms == NULL) {
        AUDIO_FUNC_LOGE("ipml or ms is null!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    uint32_t byteRate = impl->renderParam.frameRenderMode.byteRate;
    uint32_t periodSize = impl->renderParam.frameRenderMode.periodSize;
    uint32_t periodCount = impl->renderParam.frameRenderMode.periodCount;
    if (byteRate == 0) {
        AUDIO_FUNC_LOGE("divisor byteRate is zero!");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    uint32_t periodMs = (periodCount * periodSize * SEC_TO_MILLSEC) / byteRate;
    *ms = periodMs;
    return AUDIO_HAL_SUCCESS;
}

static int32_t LogErrorGetRensonAndTime(struct AudioHwRender *hwRender, int errorReason)
{
    if (hwRender == NULL) {
        AUDIO_FUNC_LOGE("param hwRender is null!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    if (hwRender->errorLog.iter >= ERROR_LOG_MAX_NUM) {
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    if (hwRender->errorLog.errorDump[hwRender->errorLog.iter].reason == NULL) {
        hwRender->errorLog.errorDump[hwRender->errorLog.iter].reason
            = (char *)OsalMemCalloc(ERROR_REASON_DESC_LEN);
        if (hwRender->errorLog.errorDump[hwRender->errorLog.iter].reason == NULL) {
            AUDIO_FUNC_LOGE("alloc reasonDesc Fail!");
            return AUDIO_HAL_ERR_MALLOC_FAIL;
        }
    }
    if (hwRender->errorLog.errorDump[hwRender->errorLog.iter].currentTime == NULL) {
        hwRender->errorLog.errorDump[hwRender->errorLog.iter].currentTime
            = (char *)OsalMemCalloc(ERROR_REASON_DESC_LEN);
        if (hwRender->errorLog.errorDump[hwRender->errorLog.iter].currentTime == NULL) {
            AUDIO_FUNC_LOGE("alloc time Fail!");
            return AUDIO_HAL_ERR_MALLOC_FAIL;
        }
    }
    (void)memset_s(hwRender->errorLog.errorDump[hwRender->errorLog.iter].reason,
        ERROR_REASON_DESC_LEN, 0, ERROR_REASON_DESC_LEN);
    (void)memset_s(hwRender->errorLog.errorDump[hwRender->errorLog.iter].currentTime,
        ERROR_REASON_DESC_LEN, 0, ERROR_REASON_DESC_LEN);
    int32_t ret = GetErrorReason(errorReason, hwRender->errorLog.errorDump[hwRender->errorLog.iter].reason);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("GetErrorReason failed!");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    ret = GetCurrentTime(hwRender->errorLog.errorDump[hwRender->errorLog.iter].currentTime);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("GetCurrentTime Fail");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    return AUDIO_HAL_SUCCESS;
}

static void LogError(AudioHandle handle, int32_t errorCode, int reason)
{
    struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
    if (hwRender == NULL) {
        return;
    }
    hwRender->errorLog.totalErrors++;
    if (hwRender->errorLog.iter >= ERROR_LOG_MAX_NUM) {
        hwRender->errorLog.iter = 0;
    }
    int32_t ret = LogErrorGetRensonAndTime(hwRender, reason);
    if (ret < 0) {
        return;
    }
    if (errorCode == WRITE_FRAME_ERROR_CODE) {
        hwRender->errorLog.errorDump[hwRender->errorLog.iter].errorCode = errorCode;
        hwRender->errorLog.errorDump[hwRender->errorLog.iter].count = (int32_t)hwRender->errorLog.iter;
        hwRender->errorLog.errorDump[hwRender->errorLog.iter].frames = hwRender->renderParam.frameRenderMode.frames;
        hwRender->errorLog.iter++;
    }
}

static int32_t AudioRenderRenderFramSplit(struct AudioHwRender *hwRender)
{
    int32_t ret;
    if (hwRender == NULL) {
        AUDIO_FUNC_LOGE("param hwRender is null!");
        return HDF_FAILURE;
    }
    InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender();
    if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) {
        AUDIO_FUNC_LOGE("pInterfaceLibModeRender Is NULL");
        return HDF_FAILURE;
    }
    if (hwRender->devDataHandle == NULL) {
        AUDIO_FUNC_LOGE("hwRender->devDataHandle is null!");
        return HDF_FAILURE;
    }
    ret = (*pInterfaceLibModeRender)(hwRender->devDataHandle, &hwRender->renderParam,
                                             AUDIO_DRV_PCM_IOCTL_WRITE);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("Render Frame FAIL!");
        LogError((AudioHandle)hwRender, WRITE_FRAME_ERROR_CODE, ret);
        return AUDIO_HAL_ERR_INTERNAL;
    }
    return HDF_SUCCESS;
}

int32_t AudioRenderRenderFrame(struct AudioRender *render, const void *frame,
                               uint64_t requestBytes, uint64_t *replyBytes)
{
    int32_t ret = AudioCheckRenderAddr((AudioHandle)render);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid! ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
    if (hwRender == NULL || frame == NULL || replyBytes == NULL ||
        hwRender->renderParam.frameRenderMode.buffer == NULL) {
        AUDIO_FUNC_LOGE("Render Frame Paras is NULL!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    if (hwRender->renderParam.renderMode.ctlParam.stop) {
        AUDIO_FUNC_LOGE("Render not started!");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    if (requestBytes > FRAME_DATA) {
        AUDIO_FUNC_LOGE("Out of FRAME_DATA size!");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    ret = memcpy_s(hwRender->renderParam.frameRenderMode.buffer, FRAME_DATA, frame, (uint32_t)requestBytes);
    if (ret != EOK) {
        AUDIO_FUNC_LOGE("memcpy_s fail");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    hwRender->renderParam.frameRenderMode.bufferSize = requestBytes;
    uint32_t frameCount = 0;
    ret = PcmBytesToFrames(&hwRender->renderParam.frameRenderMode, requestBytes, &frameCount);
    if (ret != AUDIO_HAL_SUCCESS) {
        return ret;
    }
    hwRender->renderParam.frameRenderMode.bufferFrameSize = (uint64_t)frameCount;
    if (AudioRenderRenderFramSplit(hwRender) < 0) {
        return AUDIO_HAL_ERR_INTERNAL;
    }
    *replyBytes = requestBytes;
    hwRender->renderParam.frameRenderMode.frames += hwRender->renderParam.frameRenderMode.bufferFrameSize;
    if (hwRender->renderParam.frameRenderMode.attrs.sampleRate == 0) {
        AUDIO_FUNC_LOGE("Divisor cannot be zero!");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    if (TimeToAudioTimeStamp(hwRender->renderParam.frameRenderMode.bufferFrameSize,
        &hwRender->renderParam.frameRenderMode.time,
        hwRender->renderParam.frameRenderMode.attrs.sampleRate) == HDF_FAILURE) {
        AUDIO_FUNC_LOGE("Frame is NULL");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    return AUDIO_HAL_SUCCESS;
}

int32_t AudioRenderGetRenderPosition(struct AudioRender *render, uint64_t *frames, struct AudioTimeStamp *time)
{
    int32_t ret = AudioCheckRenderAddr((AudioHandle)render);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid! ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *impl = (struct AudioHwRender *)render;
    if (impl == NULL || frames == NULL || time == NULL) {
        AUDIO_FUNC_LOGE("impl or frames or time is null!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    *frames = impl->renderParam.frameRenderMode.frames;
    *time = impl->renderParam.frameRenderMode.time;
    return AUDIO_HAL_SUCCESS;
}

int32_t AudioRenderSetRenderSpeed(struct AudioRender *render, float speed)
{
    (void)speed;
    AUDIO_FUNC_LOGI();

    struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
    if (hwRender == NULL) {
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    return AUDIO_HAL_ERR_NOT_SUPPORT;
}

int32_t AudioRenderGetRenderSpeed(struct AudioRender *render, float *speed)
{
    AUDIO_FUNC_LOGI();
    struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
    if (hwRender == NULL || speed == NULL) {
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    return AUDIO_HAL_ERR_NOT_SUPPORT;
}

int32_t AudioRenderSetChannelMode(struct AudioRender *render, enum AudioChannelMode mode)
{
    AUDIO_FUNC_LOGI();
    int32_t ret = AudioCheckRenderAddr((AudioHandle)render);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid, ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *impl = (struct AudioHwRender *)render;
    if (impl == NULL) {
        AUDIO_FUNC_LOGE("impl is null!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    if (impl->devCtlHandle == NULL) {
        AUDIO_FUNC_LOGE("Bind Fail!");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    enum AudioChannelMode tempMode = impl->renderParam.frameRenderMode.mode;
    impl->renderParam.frameRenderMode.mode = mode;
    InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender();
    if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) {
        AUDIO_FUNC_LOGE("pInterfaceLibModeRender Is NULL");
        impl->renderParam.frameRenderMode.mode = tempMode;
        return AUDIO_HAL_ERR_INTERNAL;
    }
    ret = (*pInterfaceLibModeRender)(impl->devCtlHandle, &impl->renderParam,
                                     AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("Set ChannelMode FAIL!");
        impl->renderParam.frameRenderMode.mode = tempMode;
        return AUDIO_HAL_ERR_INTERNAL;
    }
    return AUDIO_HAL_SUCCESS;
}

int32_t AudioRenderGetChannelMode(struct AudioRender *render, enum AudioChannelMode *mode)
{
    AUDIO_FUNC_LOGI();
    int32_t ret = AudioCheckRenderAddr((AudioHandle)render);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid! ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *impl = (struct AudioHwRender *)render;
    if (impl == NULL || mode == NULL || impl->devCtlHandle == NULL) {
        AUDIO_FUNC_LOGE("impl or mode or impl->devCtlHandle is null!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender();
    if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) {
        AUDIO_FUNC_LOGE("pInterfaceLibModeRender Is NULL");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    ret = (*pInterfaceLibModeRender)(impl->devCtlHandle, &impl->renderParam, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("Get ChannelMode FAIL!");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    *mode = impl->renderParam.frameRenderMode.mode;
    return AUDIO_HAL_SUCCESS;
}

static int32_t SetValue(struct ExtraParams mExtraParams, struct AudioHwRender *render)
{
    if (render == NULL) {
        AUDIO_FUNC_LOGE("param render is null!");
        return HDF_FAILURE;
    }
    if (mExtraParams.route != -1) {
        render->renderParam.renderMode.hwInfo.pathroute = mExtraParams.route;
    }
    if (mExtraParams.format != -1) {
        render->renderParam.frameRenderMode.attrs.format = mExtraParams.format;
    }
    if (mExtraParams.channels != 0) {
        render->renderParam.frameRenderMode.attrs.channelCount = mExtraParams.channels;
    }
    if (mExtraParams.flag) {
        render->renderParam.frameRenderMode.frames = mExtraParams.frames;
    }
    if (mExtraParams.sampleRate != 0) {
        render->renderParam.frameRenderMode.attrs.sampleRate = mExtraParams.sampleRate;
    }
    return HDF_SUCCESS;
}

int32_t AudioRenderSetExtraParams(AudioHandle handle, const char *keyValueList)
{
    int32_t ret = AudioCheckRenderAddr(handle);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid! ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *render = (struct AudioHwRender *)handle;
    if (render == NULL || keyValueList == NULL) {
        AUDIO_FUNC_LOGE("render or keyValueList is null!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    int32_t count = 0;
    int32_t sumOk = 0;
    struct ExtraParams mExtraParams;
    if (AudioSetExtraParams(keyValueList, &count, &mExtraParams, &sumOk) < 0) {
        return AUDIO_HAL_ERR_INTERNAL;
    }
    if (count != 0 && sumOk == count) {
        SetValue(mExtraParams, render);
        return AUDIO_HAL_SUCCESS;
    } else {
        return AUDIO_HAL_ERR_INTERNAL;
    }
}

int32_t AudioRenderGetExtraParams(AudioHandle handle, char *keyValueList, int32_t listLenth)
{
    int32_t ret = AudioCheckRenderAddr(handle);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid! ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *render = (struct AudioHwRender *)handle;
    if (render == NULL || keyValueList == NULL || listLenth <= 0) {
        AUDIO_FUNC_LOGE("render or keyValueList or listLenth is null!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    int32_t bufferSize = strlen(ROUTE_SAMPLE) + strlen(FORMAT_SAMPLE) + strlen(CHANNELS_SAMPLE)
                    + strlen(FRAME_COUNT_SAMPLE) + strlen(SAMPLING_RATE_SAMPLE) + 1;
    if (listLenth < bufferSize) {
        return AUDIO_HAL_ERR_INTERNAL;
    }
    ret = AddElementToList(keyValueList, listLenth, AUDIO_ATTR_PARAM_ROUTE,
                           &render->renderParam.renderMode.hwInfo.pathroute);
    if (ret < 0) {
        return AUDIO_HAL_ERR_INTERNAL;
    }
    ret = AddElementToList(keyValueList, listLenth, AUDIO_ATTR_PARAM_FORMAT,
        &render->renderParam.frameRenderMode.attrs.format);
    if (ret < 0) {
        return AUDIO_HAL_ERR_INTERNAL;
    }
    ret = AddElementToList(keyValueList, listLenth, AUDIO_ATTR_PARAM_CHANNELS,
        &render->renderParam.frameRenderMode.attrs.channelCount);
    if (ret < 0) {
        return AUDIO_HAL_ERR_INTERNAL;
    }
    ret = AddElementToList(keyValueList, listLenth, AUDIO_ATTR_PARAM_FRAME_COUNT,
        &render->renderParam.frameRenderMode.frames);
    if (ret < 0) {
        return AUDIO_HAL_ERR_INTERNAL;
    }
    ret = AddElementToList(keyValueList, listLenth, AUDIO_ATTR_PARAM_SAMPLING_RATE,
        &render->renderParam.frameRenderMode.attrs.sampleRate);
    if (ret < 0) {
        return AUDIO_HAL_ERR_INTERNAL;
    }
    return AUDIO_HAL_SUCCESS;
}

static int32_t AudioRenderReqMmapBufferInit(struct AudioHwRender *render,
    int32_t reqSize, struct AudioMmapBufferDescripter *desc)
{
    if (render == NULL || render->devDataHandle == NULL || desc == NULL) {
        AUDIO_FUNC_LOGE("render or render->devDataHandle or desc is null!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    uint32_t formatBits = 0;
    int32_t ret = FormatToBits(render->renderParam.frameRenderMode.attrs.format, &formatBits);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("FormatToBits failed! ret = %{public}d", ret);
        return ret;
    }
    int32_t flags;
    if (desc->isShareable) {
        flags = MAP_SHARED;
    } else {
        flags = MAP_PRIVATE;
    }
    int64_t filesize = lseek(desc->memoryFd, 0, SEEK_END);
    if ((int64_t)reqSize > filesize) {
        AUDIO_FUNC_LOGE("reqSize is out of file Size!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    desc->memoryAddress = mmap(NULL, reqSize, PROT_READ | PROT_WRITE, flags, desc->memoryFd, 0);
    if (desc->memoryAddress == NULL || desc->memoryAddress == (void *)(-1)) {
        AUDIO_FUNC_LOGE("AudioRenderReqMmapBuffer mmap FAIL and errno is:%{public}d !", errno);
        return AUDIO_HAL_ERR_INTERNAL;
    }
    desc->totalBufferFrames = reqSize / (int32_t)(render->renderParam.frameRenderMode.attrs
        .channelCount * (formatBits >> BITS_TO_FROMAT));
    InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender();
    if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) {
        AUDIO_FUNC_LOGE("pInterfaceLibModeRender Is NULL");
        munmap(desc->memoryAddress, reqSize);
        return AUDIO_HAL_ERR_INTERNAL;
    }
    render->renderParam.frameRenderMode.mmapBufDesc.memoryAddress = desc->memoryAddress;
    render->renderParam.frameRenderMode.mmapBufDesc.memoryFd = desc->memoryFd;
    render->renderParam.frameRenderMode.mmapBufDesc.totalBufferFrames = desc->totalBufferFrames;
    render->renderParam.frameRenderMode.mmapBufDesc.transferFrameSize = desc->transferFrameSize;
    render->renderParam.frameRenderMode.mmapBufDesc.isShareable = desc->isShareable;
    render->renderParam.frameRenderMode.mmapBufDesc.offset = desc->offset;
    ret = (*pInterfaceLibModeRender)(render->devDataHandle, &render->renderParam, AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("AudioRenderReqMmapBuffer FAIL!");
        munmap(desc->memoryAddress, reqSize);
        return AUDIO_HAL_ERR_INTERNAL;
    }
    return AUDIO_HAL_SUCCESS;
}

int32_t AudioRenderReqMmapBuffer(AudioHandle handle, int32_t reqSize, struct AudioMmapBufferDescripter *desc)
{
    int32_t ret = AudioCheckRenderAddr(handle);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid! ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *render = (struct AudioHwRender *)handle;
    if (render == NULL || render->devDataHandle == NULL || desc == NULL) {
        AUDIO_FUNC_LOGE("render or render->devDataHandle or desc is null!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    ret = AudioRenderReqMmapBufferInit(render, reqSize, desc);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("AudioRenderReqMmapBufferInit failed! ret = %{public}d", ret);
        return ret;
    }
    AUDIO_FUNC_LOGI("AudioRenderReqMmapBuffer Success!");
    return AUDIO_HAL_SUCCESS;
}

int32_t AudioRenderGetMmapPosition(AudioHandle handle, uint64_t *frames, struct AudioTimeStamp *time)
{
    int32_t ret = AudioCheckRenderAddr(handle);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid! ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *render = (struct AudioHwRender *)handle;
    if (render == NULL || frames == NULL || time == NULL) {
        AUDIO_FUNC_LOGE("render or frames or time is null!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    InterfaceLibModeRenderSo *pInterfaceLibModeRender = AudioSoGetInterfaceLibModeRender();
    if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) {
        AUDIO_FUNC_LOGE("pInterfaceLibModeRender Is NULL");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    if (render->devDataHandle == NULL) {
        AUDIO_FUNC_LOGE("render->devDataHandle Is NULL");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    ret = (*pInterfaceLibModeRender)(render->devDataHandle,
                                     &render->renderParam, AUDIO_DRV_PCM_IOCTL_MMAP_POSITION);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("Get Position FAIL!");
        return AUDIO_HAL_ERR_INTERNAL;
    }
    *frames = render->renderParam.frameRenderMode.frames;
    render->renderParam.frameRenderMode.time.tvSec = (int64_t)(render->renderParam.frameRenderMode.frames /
        render->renderParam.frameRenderMode.attrs.sampleRate);
    uint64_t lastBufFrames = render->renderParam.frameRenderMode.frames %
                        render->renderParam.frameRenderMode.attrs.sampleRate;
    render->renderParam.frameRenderMode.time.tvNSec =
        (int64_t)((lastBufFrames * SEC_TO_NSEC) / render->renderParam.frameRenderMode.attrs.sampleRate);
    *time = render->renderParam.frameRenderMode.time;
    return AUDIO_HAL_SUCCESS;
}

int32_t AudioRenderAddEffect(AudioHandle handle, uint64_t effectid)
{
    (void)handle;
    (void)effectid;
    AUDIO_FUNC_LOGI("add render effect success");
    return AUDIO_HAL_SUCCESS;
}

int32_t AudioRenderRemoveEffect(AudioHandle handle, uint64_t effectid)
{
    (void)handle;
    (void)effectid;
    AUDIO_FUNC_LOGI("remove render effect success");
    return AUDIO_HAL_SUCCESS;
}

int32_t AudioRenderTurnStandbyMode(AudioHandle handle)
{
    struct AudioHwRender *render = (struct AudioHwRender *)handle;
    if (render == NULL) {
        AUDIO_FUNC_LOGE("render is null!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    render->renderParam.renderMode.ctlParam.turnStandbyStatus = AUDIO_TURN_STANDBY_NOW;
    int32_t ret = AudioRenderStop((AudioHandle)render);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("AudioRenderStop failed [ ret = %{public}d ]!", ret);
        return AUDIO_HAL_ERR_INTERNAL;
    }
    return AUDIO_HAL_SUCCESS;
}

int32_t AudioRenderAudioDevDump(AudioHandle handle, int32_t range, int32_t fd)
{
    uint32_t i;
    int32_t ret = AudioCheckRenderAddr(handle);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid! ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *render = (struct AudioHwRender *)handle;
    if (render == NULL) {
        AUDIO_FUNC_LOGE("render is null!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    dprintf(fd, "%s%d\n", "Number of errors: ", render->errorLog.totalErrors);
    if (range < RANGE_MIN - 1 || range > RANGE_MAX) {
        dprintf(fd, "%s\n", "Out of range, invalid output");
        return AUDIO_HAL_SUCCESS;
    }
    uint32_t mSize = render->errorLog.iter;
    if (range < RANGE_MIN) {
        dprintf(fd, "%-5s  %-10s  %s\n", "count", "errorCode", "Time");
        for (i = 0; i < mSize; i++) {
            dprintf(fd, FORMAT_TWO, render->errorLog.errorDump[i].count + 1,
                    render->errorLog.errorDump[i].errorCode,
                    render->errorLog.errorDump[i].currentTime);
        }
    } else {
        dprintf(fd, "%-5s  %-10s  %-20s  %-15s  %s\n", "count", "errorCode", "frames", "fail reason", "Time");
        for (i = 0; i < mSize; i++) {
            dprintf(fd, FORMAT_ONE, render->errorLog.errorDump[i].count + 1,
                    render->errorLog.errorDump[i].errorCode,
                    render->errorLog.errorDump[i].frames,
                    render->errorLog.errorDump[i].reason,
                    render->errorLog.errorDump[i].currentTime);
        }
    }
    return AUDIO_HAL_SUCCESS;
}
int32_t CallbackProcessing(AudioHandle handle, enum AudioCallbackType callBackType)
{
    struct AudioHwRender *render = (struct AudioHwRender *)handle;
    if (render == NULL) {
        AUDIO_FUNC_LOGI("Unregistered callback.\n");
        return HDF_FAILURE;
    }
    if (render->renderParam.frameRenderMode.callback == NULL) {
        return HDF_FAILURE;
    }
    bool isCallBack = true;
    switch (callBackType) {
        case AUDIO_NONBLOCK_WRITE_COMPELETED:
        case AUDIO_DRAIN_COMPELETED:
        case AUDIO_FLUSH_COMPLETED:
        case AUDIO_RENDER_FULL:
        case AUDIO_ERROR_OCCUR:
            isCallBack = true;
            break;
        default:
            isCallBack = false;
            break;
    }
    if (!isCallBack) {
        AUDIO_FUNC_LOGI("No callback processing is required.\n");
        return HDF_ERR_NOT_SUPPORT;
    }
    render->renderParam.frameRenderMode.callback(callBackType, NULL, render->renderParam.frameRenderMode.cookie);
    return HDF_SUCCESS;
}

int32_t AudioRenderRegCallback(struct AudioRender *render, RenderCallback callback, void *cookie)
{
    int32_t ret = AudioCheckRenderAddr((AudioHandle)render);
    if (ret < 0) {
        AUDIO_FUNC_LOGE("The render address passed in is invalid! ret = %{public}d", ret);
        return ret;
    }
    struct AudioHwRender *pRender = (struct AudioHwRender *)render;
    if (pRender == NULL) {
        AUDIO_FUNC_LOGE("pRender is null!");
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    pRender->renderParam.frameRenderMode.callback = callback;
    pRender->renderParam.frameRenderMode.cookie = cookie;
    pRender->renderParam.renderMode.hwInfo.callBackEnable = true;
    return AUDIO_HAL_SUCCESS;
}

int32_t AudioRenderDrainBuffer(struct AudioRender *render, enum AudioDrainNotifyType *type)
{
    struct AudioHwRender *pRender = (struct AudioHwRender *)render;
    if (pRender == NULL || type == NULL) {
        return AUDIO_HAL_ERR_INVALID_PARAM;
    }
    return AUDIO_HAL_ERR_NOT_SUPPORT;
}