* Copyright (c) 2024 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 "fast_audio_render.h"
#include "audio_adapter_info_common.h"
#include "audio_bluetooth_manager.h"
#include "audio_internal.h"
#include "hdf_log.h"
#include <string>
namespace OHOS::HDI::Audio_Bluetooth {
#ifdef A2DP_HDI_SERVICE
const uint32_t MIN_TIME_INTERVAL = 30;
const uint32_t MAX_TIME_INTERVAL = 80;
const int32_t MAX_ASHMEM_LEN = 100000;
const int32_t MIN_ASHMEM_LEN = 10;
const int32_t RENDER_TIME_INTERVAL = 5;
const int32_t PER_MS_SECOND = 1000;
static int32_t CalculateSampleNum(uint32_t sampleRate, uint32_t timeMs)
{
return (sampleRate * timeMs) / PER_MS_SECOND;
}
#endif
int32_t FastRenderStart(AudioHandle handle)
{
HDF_LOGI("%{public}s enter", __func__);
#ifdef A2DP_HDI_SERVICE
AudioHwRender *hwRender = reinterpret_cast<struct AudioHwRender>(handle);
if (hwRender == nullptr) {
return AUDIO_HAL_ERR_INVALID_PARAM;
}
AudioSampleAttributes *attr = &hwRender->RenderParam.frameRenderMode.attrs;
uint32_t format = static_cast<uint32_t>(attrs->format);
return OHOS::Bluetooth::FastStartPlaying(attrs->sampleRate, attrs->channelCount, format);
#endif
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderStop(AudioHandle handle)
{
HDF_LOGI("%{public}s enter", __func__);
(void)handle;
#ifdef A2DP_HDI_SERVICE
return OHOS::Bluetooth::FastStopPlaying();
#endif
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderPause(AudioHandle handle)
{
HDF_LOGI("%{public}s enter", __func__);
(void)handle;
#ifdef A2DP_HDI_SERVICE
return OHOS::Bluetooth::FastSuspendPlaying();
#endif
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderResume(AudioHandle handle)
{
HDF_LOGI("%{public}s enter", __func__);
#ifdef A2DP_HDI_SERVICE
AudioHwRender *hwRender = reinterpret_cast<struct AudioHwRender>(handle);
if (hwRender == nullptr) {
return AUDIO_HAL_ERR_INVALID_PARAM;
}
AudioSampleAttributes *attr = &hwRender->RenderParam.frameRenderMode.attrs;
uint32_t format = static_cast<uint32_t>(attrs->format);
return OHOS::Bluetooth::FastStartPlaying(attrs->sampleRate, attrs->channelCount, format);
#endif
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderFlush(AudioHandle handle)
{
HDF_LOGI("%{public}s enter", __func__);
(void)handle;
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderGetFrameSize(AudioHandle handle, uint64_t *size)
{
HDF_LOGI("%{public}s enter", __func__);
(void)handle;
(void)size;
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderGetFrameCount(AudioHandle handle, uint64_t *count)
{
HDF_LOGI("%{public}s enter", __func__);
(void)handle;
(void)count;
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderSetSampleAttributes(AudioHandle handle, const struct AudioSampleAttributes *attrs)
{
HDF_LOGI("%{public}s enter", __func__);
(void)handle;
(void)attrs;
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderGetSampleAttributes(AudioHandle handle, struct AudioSampleAttributes *attrs)
{
HDF_LOGI("%{public}s enter", __func__);
(void)handle;
(void)attrs;
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderGetCurrentChannelId(AudioHandle handle, uint32_t *channelId)
{
HDF_LOGI("%{public}s enter", __func__);
(void)handle;
(void)channelId;
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderCheckSceneCapability(AudioHandle handle, const struct AudioSceneDescriptor *scene, bool *supported)
{
HDF_LOGI("%{public}s enter", __func__);
(void)handle;
(void)scene;
(void)supported;
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderSelectScene(AudioHandle handle, const struct AudioSceneDescriptor *scene)
{
HDF_LOGI("%{public}s enter", __func__);
(void)handle;
(void)scene;
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderSetMute(AudioHandle handle, bool mute)
{
HDF_LOGI("%{public}s enter", __func__);
(void)handle;
(void)mute;
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderGetMute(AudioHandle handle, bool *mute)
{
HDF_LOGI("%{public}s enter", __func__);
(void)handle;
(void)mute;
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderSetVolume(AudioHandle handle, float volume)
{
HDF_LOGI("%{public}s enter", __func__);
(void)handle;
(void)volume;
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderGetVolume(AudioHandle handle, float *volume)
{
HDF_LOGI("%{public}s enter", __func__);
(void)handle;
(void)volume;
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderGetGainThreshold(AudioHandle handle, float *min, float *max)
{
HDF_LOGI("%{public}s enter", __func__);
(void)handle;
(void)min;
(void)max;
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderGetGain(AudioHandle handle, float *gain)
{
HDF_LOGI("%{public}s enter", __func__);
(void)handle;
(void)gain;
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderSetGain(AudioHandle handle, float gain)
{
HDF_LOGI("%{public}s enter", __func__);
(void)handle;
(void)gain;
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderGetLatency(struct AudioRender *render, uint32_t *ms)
{
HDF_LOGI("%{public}s enter", __func__);
(void)render;
(void)ms;
#ifdef A2DP_HDI_SERVICE
uint32_t latency = 0;
OHOS::Bluetooth::FastGetLatency(latency);
*ms = latency;
return AUDIO_HAL_SUCCESS;
#endif
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderRenderFrame(
struct AudioRender *render, const void *frame, uint64_t requestBytes, uint64_t *replyBytes)
{
HDF_LOGI("%{public}s enter", __func__);
(void)render;
(void)frame;
(void)requestBytes;
(void)replyBytes;
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderGetRenderPosition(struct AudioRender *render, uint64_t *frames, struct AudioTimeStamp *time)
{
HDF_LOGI("%{public}s enter", __func__);
(void)render;
(void)frames;
(void)time;
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderSetRenderSpeed(struct AudioRender *render, float speed)
{
HDF_LOGI("%{public}s enter", __func__);
(void)render;
(void)speed;
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderGetRenderSpeed(struct AudioRender *render, float *speed)
{
HDF_LOGI("%{public}s enter", __func__);
(void)render;
(void)speed;
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderSetChannelMode(struct AudioRender *render, AudioChannelMode mode)
{
HDF_LOGI("%{public}s enter", __func__);
(void)render;
(void)mode;
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderGetChannelMode(struct AudioRender *render, AudioChannelMode *mode)
{
HDF_LOGI("%{public}s enter", __func__);
(void)render;
(void)mode;
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderSetExtraParams(AudioHandle handle, const char *keyValueList)
{
HDF_LOGI("%{public}s enter", __func__);
struct AudioHwRender *render = reinterpret_cast<struct AudioHwRender *>(handle);
if (render == nullptr || keyValueList == nullptr) {
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) {
#ifdef A2DP_HDI_SERVICE
if (mExtraParams.audioStreamCtl == 1) {
HDF_LOGI("SetValue, try to fastSuspendPlaying=1");
OHOS::Bluetooth::FastSuspendPlayingFromParam();
} else if (mExtraParams.audioStreamCtl == 0) {
HDF_LOGI("SetValue, try to fastSuspendPlaying=0");
OHOS::Bluetooth::UnBlockStart();
}
#endif
return AUDIO_HAL_SUCCESS;
} else {
return AUDIO_HAL_ERR_INTERNAL;
}
}
int32_t FastRenderGetExtraParams(AudioHandle handle, char *keyValueList, int32_t listLength)
{
HDF_LOGI("%{public}s enter", __func__);
(void)handle;
(void)keyValueList;
(void)listLength;
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderReqMmapBuffer(AudioHandle handle, int32_t reqSize, struct AudioMmapBufferDescriptor *desc)
{
HDF_LOGI("%{public}s enter", __func__);
#ifdef A2DP_HDI_SERVICE
AudioHwRender *render = reinterpret_cast<AudioHwRender *>(handle);
if (render == nullptr) {
return AUDIO_HAL_ERR_INVALID_PARAM;
}
AudioSampleAttributes attr = render->renderParam.frameRenderMode.attrs;
int32_t minSize = CalculateSampleNum(attr.sampleRate, MIN_TIME_INTERVAL);
int32_t maxSize = CalculateSampleNum(attr.sampleRate, MAX_TIME_INTERVAL);
int32_t realSize = reqSize;
if (reqSize < minSize) {
realSize = minSize;
} else if (reqSize > maxSize) {
realSize = maxSize;
}
int32_t ashmemLength = realSize * static_cast<int32_t>(attr.channelCount) * attr.format;
if (ashmemLength < MIN_ASHMEM_LEN || ashmemLength > MAX_ASHMEM_LEN) {
HDF_LOGE("reqMmapBuffer failed, length is illegal %{public}d", ashmemLength);
return AUDIO_HAL_ERR_INVALID_PARAM;
}
int32_t fd = OHOS::Bluetooth::FastReqMmapBuffer(ashmemLength);
if (fd < 0) {
HDF_LOGE("reqMmapBuffer failed");
return HDF_FAILURE;
}
desc->memoryFd = fd;
desc->transferFrameSize = static_cast<int32_t>(CalculateSampleNum(attr.sampleRate, RENDER_TIME_INTERVAL));
desc->totalBufferFrames = realSize;
desc->isShareable = false;
HDF_LOGI("%{public}s, fd=%{public}d, length=%{public}d, transferFrameSize=%{public}d, totalBufferFrames=%{public}d",
__func__, desc->memoryFd, desc->transferFrameSize, desc->totalBufferFrames);
#endif
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderGetMmapPosition(AudioHandle handle, uint64_t *frames, struct AudioTimeStamp *time)
{
HDF_LOGI("%{public}s enter", __func__);
(void)handle;
#ifdef A2DP_HDI_SERVICE
int64_t sec = 0;
int64_t nSec = 0;
uint64_t readFrames = 0;
OHOS::Bluetooth::FastReadMmapPosition(sec, nSec, readFrames);
*frames = readFrames;
time->tvSec = sec;
time->tvNSec = nSec;
return AUDIO_HAL_ERR_NOT_SUPPORT;
#endif
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderTurnStandbyMode(AudioHandle handle)
{
HDF_LOGI("%{public}s enter", __func__);
(void)handle;
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderAudioDevDump(AudioHandle handle, int32_t range, int32_t fd)
{
HDF_LOGI("%{public}s enter", __func__);
(void)handle;
(void)range;
(void)fd;
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderRegCallback(struct AudioRender *render, RenderCallback callback, void *cookie)
{
HDF_LOGI("%{public}s enter", __func__);
(void)render;
(void)callback;
(void)cookie;
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
int32_t FastRenderDrainBuffer(struct AudioRender *render, AudioDrainNotifyType *type)
{
HDF_LOGI("%{public}s enter", __func__);
(void)render;
(void)type;
return AUDIO_HAL_ERR_NOT_SUPPORT;
}
}
