1 /*
2 * Copyright (c) 2023 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 <climits>
18 #include "osal_mem.h"
19 #include "v2_0/iaudio_capture.h"
20 #include "v2_0/iaudio_manager.h"
21
22 using namespace std;
23 using namespace testing::ext;
24 namespace {
25 static const uint32_t MAX_AUDIO_ADAPTER_NUM = 5;
26 const int32_t BUFFER_LENTH = 1024 * 16;
27 const int32_t DEEP_BUFFER_CAPTURE_PERIOD_SIZE = 4 * 1024;
28 const int32_t MMAP_SUGGUEST_REQ_SIZE = 1920;
29 const int32_t MMAP_INVALID_FD = 0;
30 const int32_t MOVE_LEFT_NUM = 8;
31 const int32_t TEST_SAMPLE_RATE_MASK_48000 = 48000;
32 const int32_t TEST_CHANNEL_COUNT_STERO = 2;
33
34 class AudioUtCaptureMmapTest : public testing::Test {
35 public:
36 struct IAudioManager *manager_ = nullptr;;
37 struct IAudioAdapter *adapter_ = nullptr;
38 struct IAudioCapture *mmapCapture_ = nullptr;
39 uint32_t captureId_ = 0;
40 char *devDescriptorName_ = nullptr;
41 struct AudioAdapterDescriptor adapterDescs_[MAX_AUDIO_ADAPTER_NUM];
42 uint32_t adapterSize_ = 0;
43 virtual void SetUp();
44 virtual void TearDown();
45 void InitCaptureDevDesc(struct AudioDeviceDescriptor &devDesc);
46 void InitCaptureAttrs(struct AudioSampleAttributes &attrs);
47 void FreeAdapterElements(struct AudioAdapterDescriptor *dataBlock, bool freeSelf);
48 void ReleaseAllAdapterDescs(struct AudioAdapterDescriptor *descs, uint32_t descsLen);
49 };
50
InitCaptureDevDesc(struct AudioDeviceDescriptor & devDesc)51 void AudioUtCaptureMmapTest::InitCaptureDevDesc(struct AudioDeviceDescriptor &devDesc)
52 {
53 ASSERT_NE(adapterDescs_, nullptr);
54 ASSERT_NE(adapterDescs_->ports, nullptr);
55
56 devDesc.pins = (enum AudioPortPin)PIN_IN_MIC;
57 devDescriptorName_ = strdup("cardname");
58 devDesc.desc = devDescriptorName_;
59
60 for (uint32_t index = 0; index < adapterDescs_->portsLen; index++) {
61 if (adapterDescs_->ports[index].dir == PORT_IN) {
62 devDesc.portId = adapterDescs_->ports[index].portId;
63 return;
64 }
65 }
66 }
67
InitCaptureAttrs(struct AudioSampleAttributes & attrs)68 void AudioUtCaptureMmapTest::InitCaptureAttrs(struct AudioSampleAttributes &attrs)
69 {
70 attrs.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
71 attrs.channelCount = TEST_CHANNEL_COUNT_STERO;
72 attrs.sampleRate = TEST_SAMPLE_RATE_MASK_48000;
73 attrs.interleaved = 1;
74 attrs.type = AUDIO_MMAP_NOIRQ;
75 attrs.period = DEEP_BUFFER_CAPTURE_PERIOD_SIZE;
76 attrs.frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * TEST_CHANNEL_COUNT_STERO / MOVE_LEFT_NUM;
77 attrs.isBigEndian = false;
78 attrs.isSignedData = true;
79 attrs.startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (attrs.format * attrs.channelCount / MOVE_LEFT_NUM);
80 attrs.stopThreshold = INT_MAX;
81 attrs.silenceThreshold = BUFFER_LENTH;
82 }
83
FreeAdapterElements(struct AudioAdapterDescriptor * dataBlock,bool freeSelf)84 void AudioUtCaptureMmapTest::FreeAdapterElements(struct AudioAdapterDescriptor *dataBlock, bool freeSelf)
85 {
86 if (dataBlock == nullptr) {
87 return;
88 }
89
90 if (dataBlock->adapterName != nullptr) {
91 OsalMemFree(dataBlock->adapterName);
92 dataBlock->adapterName = nullptr;
93 }
94
95 if (dataBlock->ports != nullptr) {
96 OsalMemFree(dataBlock->ports);
97 }
98 }
99
ReleaseAllAdapterDescs(struct AudioAdapterDescriptor * descs,uint32_t descsLen)100 void AudioUtCaptureMmapTest::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 AudioUtCaptureMmapTest::SetUp()
112 {
113 adapterSize_ = MAX_AUDIO_ADAPTER_NUM;
114 manager_ = IAudioManagerGet(false);
115 ASSERT_NE(manager_, nullptr);
116
117 EXPECT_EQ(HDF_SUCCESS, manager_->GetAllAdapters(manager_, adapterDescs_, &adapterSize_));
118 if (adapterSize_ > MAX_AUDIO_ADAPTER_NUM) {
119 ReleaseAllAdapterDescs(adapterDescs_, adapterSize_);
120 ASSERT_LT(adapterSize_, MAX_AUDIO_ADAPTER_NUM);
121 }
122
123 EXPECT_EQ(HDF_SUCCESS, manager_->LoadAdapter(manager_, &adapterDescs_[0], &adapter_));
124 if (adapter_ == nullptr) {
125 ReleaseAllAdapterDescs(adapterDescs_, adapterSize_);
126 EXPECT_NE(adapter_, nullptr);
127 }
128
129 struct AudioDeviceDescriptor devDesc = {};
130 struct AudioSampleAttributes attrs = {};
131 InitCaptureDevDesc(devDesc);
132 InitCaptureAttrs(attrs);
133 EXPECT_EQ(HDF_SUCCESS, adapter_->CreateCapture(adapter_, &devDesc, &attrs, &mmapCapture_, &captureId_));
134 if (mmapCapture_ == nullptr) {
135 (void)manager_->UnloadAdapter(manager_, adapterDescs_[0].adapterName);
136 ReleaseAllAdapterDescs(adapterDescs_, adapterSize_);
137 }
138 ASSERT_NE(mmapCapture_, nullptr);
139 }
140
TearDown()141 void AudioUtCaptureMmapTest::TearDown()
142 {
143 ASSERT_NE(devDescriptorName_, nullptr);
144 free(devDescriptorName_);
145 devDescriptorName_ = nullptr;
146
147 ASSERT_NE(mmapCapture_, nullptr);
148 EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyCapture(adapter_, captureId_));
149
150 ASSERT_NE(manager_, nullptr);
151 EXPECT_EQ(HDF_SUCCESS, manager_->UnloadAdapter(manager_, adapterDescs_[0].adapterName));
152 ReleaseAllAdapterDescs(adapterDescs_, adapterSize_);
153
154 IAudioManagerRelease(manager_, false);
155 }
156
157 HWTEST_F(AudioUtCaptureMmapTest, HdfAudioCaptureReqMmapBuffer001, TestSize.Level1)
158 {
159 struct AudioMmapBufferDescriptor desc = {0};
160
161 int32_t ret = mmapCapture_->ReqMmapBuffer(mmapCapture_, MMAP_SUGGUEST_REQ_SIZE, &desc);
162 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || HDF_ERR_INVALID_PARAM);
163 if (ret == HDF_SUCCESS) {
164 ASSERT_NE(desc.memoryFd, MMAP_INVALID_FD);
165 }
166 }
167
168 HWTEST_F(AudioUtCaptureMmapTest, HdfAudioCaptureReqMmapBufferException001, TestSize.Level1)
169 {
170 struct AudioMmapBufferDescriptor desc = {0};
171
172 int32_t ret = mmapCapture_->ReqMmapBuffer(nullptr, MMAP_SUGGUEST_REQ_SIZE, &desc);
173 ASSERT_NE(ret, HDF_SUCCESS);
174
175 ret = mmapCapture_->ReqMmapBuffer(mmapCapture_, MMAP_SUGGUEST_REQ_SIZE, nullptr);
176 ASSERT_NE(ret, HDF_SUCCESS);
177 }
178
179 HWTEST_F(AudioUtCaptureMmapTest, HdfAudioCaptureControl001, TestSize.Level1)
180 {
181 struct AudioMmapBufferDescriptor desc = {0};
182
183 int32_t ret = mmapCapture_->ReqMmapBuffer(mmapCapture_, MMAP_SUGGUEST_REQ_SIZE, &desc);
184 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || HDF_ERR_INVALID_PARAM);
185 if (ret == HDF_SUCCESS) {
186 ASSERT_NE(desc.memoryFd, MMAP_INVALID_FD);
187 }
188
189 ret = mmapCapture_->Start(mmapCapture_);
190 EXPECT_EQ(ret, HDF_SUCCESS);
191
192 ret = mmapCapture_->Stop(mmapCapture_);
193 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
194 }
195
196 HWTEST_F(AudioUtCaptureMmapTest, HdfAudioCaptureControlException001, TestSize.Level1)
197 {
198 struct AudioMmapBufferDescriptor desc = {0};
199
200 int32_t ret = mmapCapture_->ReqMmapBuffer(mmapCapture_, MMAP_SUGGUEST_REQ_SIZE, &desc);
201 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || HDF_ERR_INVALID_PARAM);
202 if (ret == HDF_SUCCESS) {
203 ASSERT_NE(desc.memoryFd, MMAP_INVALID_FD);
204 }
205
206 ret = mmapCapture_->Start(mmapCapture_);
207 EXPECT_EQ(ret, HDF_SUCCESS);
208
209 ret = mmapCapture_->Start(mmapCapture_); // restart can be return two state
210 EXPECT_TRUE(ret == HDF_SUCCESS || ret == HDF_FAILURE);
211
212 ret = mmapCapture_->Stop(mmapCapture_);
213 EXPECT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
214
215 ret = mmapCapture_->Stop(mmapCapture_); // restop can be return two state
216 EXPECT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
217 }
218
219 HWTEST_F(AudioUtCaptureMmapTest, HdfAudioCaptureGetMmapPosition001, TestSize.Level1)
220 {
221 struct AudioMmapBufferDescriptor desc = {0};
222 uint64_t frames = 0;
223 struct AudioTimeStamp time = {0};
224
225 int32_t ret = mmapCapture_->ReqMmapBuffer(mmapCapture_, MMAP_SUGGUEST_REQ_SIZE, &desc);
226 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || HDF_ERR_INVALID_PARAM);
227 if (ret == HDF_SUCCESS) {
228 ASSERT_NE(desc.memoryFd, MMAP_INVALID_FD);
229 }
230
231 ret = mmapCapture_->Start(mmapCapture_);
232 EXPECT_EQ(ret, HDF_SUCCESS);
233
234 ret = mmapCapture_->GetMmapPosition(mmapCapture_, &frames, &time);
235 EXPECT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_INVALID_PARAM);
236
237 ret = mmapCapture_->Stop(mmapCapture_);
238 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
239 }
240
241 HWTEST_F(AudioUtCaptureMmapTest, HdfAudioCaptureGetMmapPositionException001, TestSize.Level1)
242 {
243 struct AudioMmapBufferDescriptor desc = {0};
244 uint64_t frames = 0;
245 struct AudioTimeStamp time = {0};
246
247 int32_t ret = mmapCapture_->ReqMmapBuffer(mmapCapture_, MMAP_SUGGUEST_REQ_SIZE, &desc);
248 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || HDF_ERR_INVALID_PARAM);
249 if (ret == HDF_SUCCESS) {
250 ASSERT_NE(desc.memoryFd, MMAP_INVALID_FD);
251 }
252
253 ret = mmapCapture_->Start(mmapCapture_);
254 EXPECT_EQ(ret, HDF_SUCCESS);
255
256 ret = mmapCapture_->GetMmapPosition(nullptr, &frames, &time);
257 EXPECT_NE(ret, HDF_SUCCESS);
258
259 ret = mmapCapture_->GetMmapPosition(mmapCapture_, nullptr, &time);
260 EXPECT_NE(ret, HDF_SUCCESS);
261
262 ret = mmapCapture_->Stop(mmapCapture_);
263 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
264 }
265
266 HWTEST_F(AudioUtCaptureMmapTest, HdfAudioCaptureGetMmapPositionInValid001, TestSize.Level1)
267 {
268 uint64_t frames = 0;
269 struct AudioTimeStamp time = {0};
270
271 int32_t ret = mmapCapture_->GetMmapPosition(mmapCapture_, &frames, &time);
272 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_INVALID_PARAM);
273 }
274
275 } // end of namespace