openharmony/xts_hats
1
0
Fork 0
mirror of https://gitee.com/openharmony/xts_hats synced 2025-02-20 18:30:51 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Signed-off-by: hwx1255622 <hechunrui@huawei.com>

Browse Source 
Change-Id: If5fdc56e9bdf5946050c549bbcb8845cbe511d35
This commit is contained in:
hwx1255622 2024-06-15 16:34:11 +08:00
parent 5d69d4bc0a
commit 951b99dd17
4 changed files with 252 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
hdf/audio/idl/common/adapter/BUILD.gn
View File

@ -27,7 +27,10 @@ ohos_moduletest_suite("HatsHdfAudioIdlAdapterTest") {
configs = [ ":audio_idl_adapter" ]
if (drivers_peripheral_audio_feature_multichannel) {
sources += [ "src/audio_adapter_multchannel_test.cpp" ]
sources += [
"src/audio_adapter_direct_test.cpp",
"src/audio_adapter_multchannel_test.cpp",
]
}
deps = [ "//third_party/bounds_checking_function:libsec_shared" ]

237
hdf/audio/idl/common/adapter/src/audio_adapter_direct_test.cpp Normal file
View File

@ -0,0 +1,237 @@
/*
* 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 <climits>
#include <cstring>
#include <gtest/gtest.h>
#include "hdf_dlist.h"
#include "osal_mem.h"
#include "v3_0/audio_types.h"
#include "v3_0/iaudio_adapter.h"
#include "v3_0/iaudio_manager.h"
using namespace std;
using namespace testing::ext;
#define AUDIO_CHANNELCOUNT 2
#define AUDIO_SAMPLE_RATE_192K 192000
#define AUDIO_SAMPLE_RATE_48K 48000
#define AUDIO_SAMPLE_RATE_44_1K 44100
#define DEEP_BUFFER_RENDER_PERIOD_SIZE 4096
#define AUDIO_CHANNELLAYOUT 3
namespace {
static const uint32_t g_audioAdapterNumMax = 5;
class HdfAudioAdapterDirectTest : public testing::Test {
public:
struct IAudioManager *manager_ = nullptr;
struct IAudioAdapter *adapter_ = nullptr;
struct AudioAdapterDescriptor *adapterDescs_ = nullptr;
uint32_t renderId_ = 0;
uint32_t captureId_ = 0;
virtual void SetUp();
virtual void TearDown();
void InitDirectAttrs(struct AudioSampleAttributes &attrs);
void InitDevDesc(struct AudioDeviceDescriptor &devDesc);
void AudioAdapterDescriptorFree(struct AudioAdapterDescriptor *dataBlock, bool freeSelf);
void ReleaseAdapterDescs(struct AudioAdapterDescriptor **descs, uint32_t descsLen);
};
void HdfAudioAdapterDirectTest::AudioAdapterDescriptorFree(struct AudioAdapterDescriptor *dataBlock, bool freeSelf)
{
if (dataBlock == nullptr) {
return;
}
if (dataBlock->adapterName != nullptr) {
OsalMemFree(dataBlock->adapterName);
dataBlock->adapterName = nullptr;
}
if (dataBlock->ports != nullptr) {
OsalMemFree(dataBlock->ports);
}
if (freeSelf) {
OsalMemFree(dataBlock);
}
}
void HdfAudioAdapterDirectTest::ReleaseAdapterDescs(struct AudioAdapterDescriptor **descs, uint32_t descsLen)
{
if ((descsLen > 0) && (descs != nullptr) && ((*descs) != nullptr)) {
for (uint32_t i = 0; i < descsLen; i++) {
AudioAdapterDescriptorFree(&(*descs)[i], false);
}
OsalMemFree(*descs);
*descs = nullptr;
}
}
void HdfAudioAdapterDirectTest::InitDirectAttrs(struct AudioSampleAttributes &attrs)
{
attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
attrs.channelCount = AUDIO_CHANNELCOUNT;
attrs.channelLayout = AUDIO_CHANNELLAYOUT;
attrs.sampleRate = AUDIO_SAMPLE_RATE_192K;
attrs.interleaved = 1;
attrs.type = AUDIO_DIRECT;
attrs.period = DEEP_BUFFER_RENDER_PERIOD_SIZE;
attrs.frameSize = AUDIO_FORMAT_TYPE_PCM_32_BIT * AUDIO_CHANNELCOUNT;
attrs.isBigEndian = false;
attrs.isSignedData = true;
attrs.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (attrs.format * attrs.frameSize);
attrs.stopThreshold = INT_MAX;
attrs.silenceThreshold = 0;
}
void HdfAudioAdapterDirectTest::InitDevDesc(struct AudioDeviceDescriptor &devDesc)
{
ASSERT_NE(adapterDescs_, nullptr);
ASSERT_NE(adapterDescs_->ports, nullptr);
for (uint32_t index = 0; index < adapterDescs_->portsLen; index++) {
if (adapterDescs_->ports[index].dir == PORT_OUT) {
devDesc.portId = adapterDescs_->ports[index].portId;
return;
}
}
}
void HdfAudioAdapterDirectTest::SetUp()
{
uint32_t size = g_audioAdapterNumMax;
manager_ = IAudioManagerGet(false);
ASSERT_NE(manager_, nullptr);
adapterDescs_ = (struct AudioAdapterDescriptor *)OsalMemCalloc(
sizeof(struct AudioAdapterDescriptor) * (g_audioAdapterNumMax));
ASSERT_NE(adapterDescs_, nullptr);
ASSERT_EQ(HDF_SUCCESS, manager_->GetAllAdapters(manager_, adapterDescs_, &size));
if (size > g_audioAdapterNumMax) {
ReleaseAdapterDescs(&adapterDescs_, g_audioAdapterNumMax);
ASSERT_LT(size, g_audioAdapterNumMax);
}
if (manager_->LoadAdapter(manager_, &adapterDescs_[0], &adapter_) != HDF_SUCCESS) {
ReleaseAdapterDescs(&adapterDescs_, g_audioAdapterNumMax);
ASSERT_TRUE(false);
}
if (adapter_ == nullptr) {
ReleaseAdapterDescs(&adapterDescs_, g_audioAdapterNumMax);
ASSERT_TRUE(false);
}
}
void HdfAudioAdapterDirectTest::TearDown()
{
ASSERT_NE(manager_, nullptr);
ASSERT_NE(adapter_, nullptr);
manager_->UnloadAdapter(manager_, adapterDescs_[0].adapterName);
ReleaseAdapterDescs(&adapterDescs_, g_audioAdapterNumMax);
adapter_ = nullptr;
IAudioManagerRelease(manager_, false);
manager_ = nullptr;
}
/**
* @tc.number : SUB_Driver_Audio_Direct_0100
* @tc.name : HdfAudioAdapterDirectCreateRenderInvalid001
* @tc.desc : Verify function when the input parameter is invalid.
@tc.type: FUNC
*/
HWTEST_F(HdfAudioAdapterDirectTest, HdfAudioAdapterDirectCreateRenderInvalid001, TestSize.Level1)
{
struct IAudioRender *render = nullptr;
struct AudioDeviceDescriptor devicedesc = {};
struct AudioSampleAttributes attrs = {};
EXPECT_EQ(HDF_ERR_INVALID_OBJECT, adapter_->CreateRender(nullptr, &devicedesc, &attrs, &render, &renderId_));
EXPECT_EQ(HDF_ERR_INVALID_PARAM, adapter_->CreateRender(adapter_, nullptr, &attrs, &render, &renderId_));
EXPECT_EQ(HDF_ERR_INVALID_PARAM, adapter_->CreateRender(adapter_, &devicedesc, nullptr, &render, &renderId_));
EXPECT_EQ(HDF_ERR_INVALID_PARAM, adapter_->CreateRender(adapter_, &devicedesc, &attrs, nullptr, &renderId_));
EXPECT_EQ(HDF_ERR_INVALID_PARAM, adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, nullptr));
EXPECT_NE(HDF_SUCCESS, adapter_->DestroyRender(adapter_, renderId_));
}
/**
* @tc.number : SUB_Driver_Audio_Direct_0200
* @tc.name : HdfAudioAdapterDirectCreateRenderIsvalid001
* @tc.desc : Verify supported the direct when sampleRate is 192K.
@tc.type: FUNC
*/
HWTEST_F(HdfAudioAdapterDirectTest, HdfAudioAdapterDirectCreateRenderIsvalid001, TestSize.Level1)
{
struct IAudioRender *render = nullptr;
struct AudioDeviceDescriptor devicedesc = {};
struct AudioSampleAttributes attrs = {};
InitDevDesc(devicedesc);
devicedesc.desc = strdup("");
devicedesc.pins = PIN_OUT_HEADSET;
InitDirectAttrs(attrs);
attrs.streamId = 0;
int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
EXPECT_TRUE(ret == HDF_SUCCESS);
ret = adapter_->DestroyRender(adapter_, renderId_);
EXPECT_TRUE(ret == HDF_SUCCESS);
}
/**
* @tc.number : SUB_Driver_Audio_Direct_0300
* @tc.name : HdfAudioAdapterDirectCreateRenderIsvalid002
* @tc.desc : Verify supported the direct when sampleRate is 48K.
@tc.type: FUNC
*/
HWTEST_F(HdfAudioAdapterDirectTest, HdfAudioAdapterDirectCreateRenderIsvalid002, TestSize.Level1)
{
struct IAudioRender *render = nullptr;
struct AudioDeviceDescriptor devicedesc = {};
struct AudioSampleAttributes attrs = {};
InitDevDesc(devicedesc);
devicedesc.desc = strdup("");
devicedesc.pins = PIN_OUT_HEADSET;
InitDirectAttrs(attrs);
attrs.streamId = 0;
attrs.sampleRate = AUDIO_SAMPLE_RATE_48K;
int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
EXPECT_TRUE(ret == HDF_SUCCESS);
ret = adapter_->DestroyRender(adapter_, renderId_);
EXPECT_TRUE(ret == HDF_SUCCESS);
}
/**
* @tc.number : SUB_Driver_Audio_Direct_0400
* @tc.name : HdfAudioAdapterDirectCreateRenderIsvalid003
* @tc.desc : Verify supported the direct when sampleRate is 44.1K.
@tc.type: FUNC
*/
HWTEST_F(HdfAudioAdapterDirectTest, HdfAudioAdapterDirectCreateRenderIsvalid003, TestSize.Level1)
{
struct IAudioRender *render = nullptr;
struct AudioDeviceDescriptor devicedesc = {};
struct AudioSampleAttributes attrs = {};
InitDevDesc(devicedesc);
devicedesc.desc = strdup("");
devicedesc.pins = PIN_OUT_HEADSET;
InitDirectAttrs(attrs);
attrs.streamId = 0;
attrs.sampleRate = AUDIO_SAMPLE_RATE_44_1K;
int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
EXPECT_TRUE(ret == HDF_SUCCESS);
ret = adapter_->DestroyRender(adapter_, renderId_);
EXPECT_TRUE(ret == HDF_SUCCESS);
}
}

17
hdf/audio/idl/common/render_additional/src/AudioRenderCommonTest.cpp
View File

@ -26,7 +26,6 @@ using namespace testing::ext;
namespace {
const int BUFFER_LENTH = 1024 * 16;
const int DEEP_BUFFER_RENDER_PERIOD_SIZE = 4 * 1024;
const int MOVE_LEFT_NUM = 8;
const int32_t AUDIO_RENDER_CHANNELCOUNT = 2;
const int32_t AUDIO_SAMPLE_RATE_48K = 48000;
const int32_t MAX_AUDIO_ADAPTER_DESC = 5;
@ -84,16 +83,16 @@ uint64_t AudioUtRenderTestAdditional::GetRenderBufferSize()
void AudioUtRenderTestAdditional::InitRenderAttrs(struct AudioSampleAttributes &attrs)
{
attrsRender_.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
attrs.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
attrs.channelCount = AUDIO_RENDER_CHANNELCOUNT;
attrs.sampleRate = AUDIO_SAMPLE_RATE_48K;
attrs.interleaved = 0;
attrs.type = AUDIO_IN_MEDIA;
attrs.period = DEEP_BUFFER_RENDER_PERIOD_SIZE;
attrs.frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * AUDIO_RENDER_CHANNELCOUNT / MOVE_LEFT_NUM;
attrs.frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * AUDIO_RENDER_CHANNELCOUNT;
attrs.isBigEndian = false;
attrs.isSignedData = true;
attrs.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (attrs.format * attrs.channelCount / MOVE_LEFT_NUM);
attrs.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (attrs.format * attrs.channelCount);
attrs.stopThreshold = INT_MAX;
attrs.silenceThreshold = BUFFER_LENTH;
}
@ -187,8 +186,8 @@ HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetLatency001, Function |
int i, ret = 0;
for (i = 0; i < 1000; i++) {
ret |= render_->GetLatency(render_, &ms);
EXPECT_EQ(HDF_SUCCESS, ret);
}
EXPECT_EQ(HDF_SUCCESS, ret);
}
/**
@ -231,8 +230,8 @@ HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderRenderFrame002, Function |
EXPECT_NE(nullptr, frame);
for (i = 0; i < 1000; i++) {
ret |= render_->RenderFrame(render_, frame, frameLen, &requestBytes);
EXPECT_EQ(ret, HDF_SUCCESS);
}
EXPECT_EQ(ret, HDF_SUCCESS);
EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
}
@ -444,8 +443,8 @@ HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderDrainBufferk001, Function
int32_t ret = 0;
for (i = 0; i < 1000; i++) {
ret |= render_->DrainBuffer(render_, &type);
EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
}
EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
}
/**
@ -516,8 +515,8 @@ HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderCheckSceneCapability001, F
scene.desc = devDescRender_;
for (i = 0; i < 1000; i++) {
ret |= render_->CheckSceneCapability(render_, &scene, &supported);
EXPECT_EQ(HDF_SUCCESS, ret);
}
EXPECT_EQ(HDF_SUCCESS, ret);
}
/**
@ -629,8 +628,8 @@ HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene001, Function |
scene.desc.desc = strdup("mic");
for (i = 0; i < 1000; i++) {
ret |= render_->SelectScene(render_, &scene);
EXPECT_EQ(HDF_SUCCESS, ret);
}
EXPECT_EQ(HDF_SUCCESS, ret);
free(scene.desc.desc);
}

7
hdf/audio/idl/common/render_additional/src/AudioRenderMmapTest.cpp
View File

@ -26,7 +26,6 @@ using namespace testing::ext;
namespace {
const int BUFFER_LENTH = 1024 * 16;
const int DEEP_BUFFER_RENDER_PERIOD_SIZE = 4 * 1024;
const int MOVE_LEFT_NUM = 8;
const int32_t AUDIO_RENDER_CHANNELCOUNT = 2;
const int32_t AUDIO_SAMPLE_RATE_48K = 48000;
const int32_t MAX_AUDIO_ADAPTER_DESC = 5;
@ -52,15 +51,16 @@ public:
void AudioUtRenderMmapTestAdditional::InitRenderAttrs(struct AudioSampleAttributes &attrs)
{
attrs.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
attrs.channelCount = AUDIO_RENDER_CHANNELCOUNT;
attrs.sampleRate = AUDIO_SAMPLE_RATE_48K;
attrs.interleaved = 0;
attrs.type = AUDIO_MMAP_NOIRQ;
attrs.period = DEEP_BUFFER_RENDER_PERIOD_SIZE;
attrs.frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * AUDIO_RENDER_CHANNELCOUNT / MOVE_LEFT_NUM;
attrs.frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * AUDIO_RENDER_CHANNELCOUNT;
attrs.isBigEndian = false;
attrs.isSignedData = true;
attrs.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (attrs.format * attrs.channelCount / MOVE_LEFT_NUM);
attrs.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (attrs.format * attrs.channelCount);
attrs.stopThreshold = INT_MAX;
attrs.silenceThreshold = BUFFER_LENTH;
}
@ -121,7 +121,6 @@ void AudioUtRenderMmapTestAdditional::SetUp()
InitRenderDevDesc(devDescRender_);
InitRenderAttrs(attrsRender_);
attrsRender_.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
int32_t ret = adapter_->CreateRender(adapter_, &devDescRender_, &attrsRender_, &render_, &renderId_);
if (ret != HDF_SUCCESS) {
attrsRender_.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;