1 /*
2 * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include "osal_mem.h"
18
19 #include "v4_0/audio_types.h"
20 #include "v4_0/iaudio_manager.h"
21 #include "v4_0/iaudio_render.h"
22
23 using namespace std;
24 using namespace testing::ext;
25
26 namespace {
27 const int BUFFER_LENTH = 1024 * 16;
28 const int DEEP_BUFFER_RENDER_PERIOD_SIZE = 4 * 1024;
29 const int32_t AUDIO_RENDER_CHANNELCOUNT = 2;
30 const int32_t AUDIO_SAMPLE_RATE_48K = 48000;
31 const int32_t MAX_AUDIO_ADAPTER_DESC = 5;
32 const int32_t MMAP_SUGGEST_BUFFER_SIZE = 1920;
33
34 class AudioUtRenderMmapTest : public testing::Test {
35 public:
36 struct IAudioManager *manager_ = nullptr;
37 struct AudioAdapterDescriptor descs_[MAX_AUDIO_ADAPTER_DESC];
38 struct AudioAdapterDescriptor *desc_;
39 struct IAudioAdapter *adapter_ = nullptr;
40 struct IAudioRender *render_ = nullptr;
41 struct AudioDeviceDescriptor devDescRender_ = {};
42 struct AudioSampleAttributes attrsRender_ = {};
43 uint32_t renderId_ = 0;
44 uint32_t size_ = MAX_AUDIO_ADAPTER_DESC;
45 virtual void SetUp();
46 virtual void TearDown();
47 void InitRenderAttrs(struct AudioSampleAttributes &attrs);
48 void InitRenderDevDesc(struct AudioDeviceDescriptor &devDesc);
49 void FreeAdapterElements(struct AudioAdapterDescriptor *dataBlock, bool freeSelf);
50 void ReleaseAllAdapterDescs(struct AudioAdapterDescriptor *descs, uint32_t descsLen);
51 };
52
InitRenderAttrs(struct AudioSampleAttributes & attrs)53 void AudioUtRenderMmapTest::InitRenderAttrs(struct AudioSampleAttributes &attrs)
54 {
55 attrs.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
56 attrs.channelCount = AUDIO_RENDER_CHANNELCOUNT;
57 attrs.sampleRate = AUDIO_SAMPLE_RATE_48K;
58 attrs.interleaved = 0;
59 attrs.type = AUDIO_MMAP_NOIRQ;
60 attrs.period = DEEP_BUFFER_RENDER_PERIOD_SIZE;
61 attrs.frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * AUDIO_RENDER_CHANNELCOUNT;
62 attrs.isBigEndian = false;
63 attrs.isSignedData = true;
64 attrs.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (attrs.format * attrs.channelCount);
65 attrs.stopThreshold = INT_MAX;
66 attrs.silenceThreshold = BUFFER_LENTH;
67 }
68
InitRenderDevDesc(struct AudioDeviceDescriptor & devDesc)69 void AudioUtRenderMmapTest::InitRenderDevDesc(struct AudioDeviceDescriptor &devDesc)
70 {
71 devDesc.pins = PIN_OUT_SPEAKER;
72 devDesc.desc = strdup("cardname");
73
74 ASSERT_NE(desc_, nullptr);
75 ASSERT_NE(desc_->ports, nullptr);
76 for (uint32_t index = 0; index < desc_->portsLen; index++) {
77 if (desc_->ports[index].dir == PORT_OUT) {
78 devDesc.portId = desc_->ports[index].portId;
79 return;
80 }
81 }
82 free(devDesc.desc);
83 }
84
FreeAdapterElements(struct AudioAdapterDescriptor * dataBlock,bool freeSelf)85 void AudioUtRenderMmapTest::FreeAdapterElements(struct AudioAdapterDescriptor *dataBlock, bool freeSelf)
86 {
87 if (dataBlock == nullptr) {
88 return;
89 }
90
91 OsalMemFree(dataBlock->adapterName);
92
93 OsalMemFree(dataBlock->ports);
94
95 if (freeSelf) {
96 OsalMemFree(dataBlock);
97 }
98 }
99
ReleaseAllAdapterDescs(struct AudioAdapterDescriptor * descs,uint32_t descsLen)100 void AudioUtRenderMmapTest::ReleaseAllAdapterDescs(struct AudioAdapterDescriptor *descs, uint32_t descsLen)
101 {
102 if (descs == nullptr || descsLen == 0) {
103 return;
104 }
105
106 for (uint32_t i = 0; i < descsLen; i++) {
107 FreeAdapterElements(&descs[i], false);
108 }
109 }
110
SetUp()111 void AudioUtRenderMmapTest::SetUp()
112 {
113 manager_ = IAudioManagerGet(false);
114 ASSERT_NE(manager_, nullptr);
115
116 ASSERT_EQ(HDF_SUCCESS, manager_->GetAllAdapters(manager_, descs_, &size_));
117 ASSERT_NE(descs_, nullptr);
118 EXPECT_GE(MAX_AUDIO_ADAPTER_DESC, size_);
119 desc_ = &descs_[0];
120 ASSERT_EQ(HDF_SUCCESS, manager_->LoadAdapter(manager_, desc_, &adapter_));
121 ASSERT_NE(adapter_, nullptr);
122 InitRenderDevDesc(devDescRender_);
123 InitRenderAttrs(attrsRender_);
124
125 int32_t ret = adapter_->CreateRender(adapter_, &devDescRender_, &attrsRender_, &render_, &renderId_);
126 if (ret != HDF_SUCCESS) {
127 attrsRender_.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
128 ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devDescRender_, &attrsRender_, &render_, &renderId_));
129 }
130 ASSERT_NE(render_, nullptr);
131 }
132
TearDown()133 void AudioUtRenderMmapTest::TearDown()
134 {
135 if (adapter_ != nullptr) {
136 adapter_->DestroyRender(adapter_, renderId_);
137 render_ = nullptr;
138 }
139 if (manager_ != nullptr) {
140 manager_->UnloadAdapter(manager_, desc_->adapterName);
141 adapter_ = nullptr;
142 ReleaseAllAdapterDescs(descs_, size_);
143
144 IAudioManagerRelease(manager_, false);
145 }
146 }
147
148 HWTEST_F(AudioUtRenderMmapTest, SUB_Driver_Audio_RenderHdi_9200, TestSize.Level1)
149 {
150 int32_t reqSize = MMAP_SUGGEST_BUFFER_SIZE;
151 struct AudioMmapBufferDescriptor desc;
152
153 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->ReqMmapBuffer(nullptr, reqSize, &desc));
154 }
155
156 HWTEST_F(AudioUtRenderMmapTest, SUB_Driver_Audio_RenderHdi_9300, TestSize.Level1)
157 {
158 int32_t reqSize = MMAP_SUGGEST_BUFFER_SIZE;
159 struct AudioMmapBufferDescriptor desc;
160
161 int32_t ret = render_->ReqMmapBuffer(render_, reqSize, &desc);
162
163 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_INVALID_PARAM);
164 }
165
166 HWTEST_F(AudioUtRenderMmapTest, SUB_Driver_Audio_RenderHdi_9400, TestSize.Level1)
167 {
168 uint64_t frames = 0;
169 struct AudioTimeStamp time;
170 time.tvNSec = 0;
171 time.tvSec = 0;
172 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->GetMmapPosition(nullptr, &frames, &time));
173 }
174
175 HWTEST_F(AudioUtRenderMmapTest, SUB_Driver_Audio_RenderHdi_9500, TestSize.Level1)
176 {
177 uint64_t frames = 0;
178 struct AudioTimeStamp time;
179 time.tvNSec = 0;
180 time.tvSec = 0;
181 int32_t reqSize = MMAP_SUGGEST_BUFFER_SIZE;
182 struct AudioMmapBufferDescriptor desc;
183
184 int32_t ret = render_->ReqMmapBuffer(render_, reqSize, &desc);
185 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_INVALID_PARAM);
186
187 ret = render_->Start(render_);
188 EXPECT_TRUE(ret == HDF_SUCCESS || ret == HDF_FAILURE);
189
190 ret = render_->GetMmapPosition(render_, &frames, &time);
191 EXPECT_TRUE(ret == HDF_SUCCESS);
192 render_->Stop(render_);
193 }
194
195 } // end of namespace