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 "v4_0/iaudio_capture.h"
20 #include "v4_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
146 ASSERT_NE(mmapCapture_, nullptr);
147 EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyCapture(adapter_, captureId_));
148
149 ASSERT_NE(manager_, nullptr);
150 EXPECT_EQ(HDF_SUCCESS, manager_->UnloadAdapter(manager_, adapterDescs_[0].adapterName));
151 ReleaseAllAdapterDescs(adapterDescs_, adapterSize_);
152
153 IAudioManagerRelease(manager_, false);
154 }
155
156 HWTEST_F(AudioUtCaptureMmapTest, HdfAudioCaptureReqMmapBuffer001, TestSize.Level1)
157 {
158 struct AudioMmapBufferDescriptor desc = {0};
159
160 int32_t ret = mmapCapture_->ReqMmapBuffer(mmapCapture_, MMAP_SUGGUEST_REQ_SIZE, &desc);
161 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_INVALID_PARAM);
162 if (ret == HDF_SUCCESS) {
163 ASSERT_NE(desc.memoryFd, MMAP_INVALID_FD);
164 }
165 }
166
167 HWTEST_F(AudioUtCaptureMmapTest, HdfAudioCaptureReqMmapBufferException001, TestSize.Level1)
168 {
169 struct AudioMmapBufferDescriptor desc = {0};
170
171 int32_t ret = mmapCapture_->ReqMmapBuffer(nullptr, MMAP_SUGGUEST_REQ_SIZE, &desc);
172 ASSERT_NE(ret, HDF_SUCCESS);
173
174 ret = mmapCapture_->ReqMmapBuffer(mmapCapture_, MMAP_SUGGUEST_REQ_SIZE, nullptr);
175 ASSERT_NE(ret, HDF_SUCCESS);
176 }
177
178 HWTEST_F(AudioUtCaptureMmapTest, HdfAudioCaptureControl001, TestSize.Level1)
179 {
180 struct AudioMmapBufferDescriptor desc = {0};
181
182 int32_t ret = mmapCapture_->ReqMmapBuffer(mmapCapture_, MMAP_SUGGUEST_REQ_SIZE, &desc);
183 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_INVALID_PARAM);
184 if (ret == HDF_SUCCESS) {
185 ASSERT_NE(desc.memoryFd, MMAP_INVALID_FD);
186 }
187
188 ret = mmapCapture_->Start(mmapCapture_);
189 EXPECT_EQ(ret, HDF_SUCCESS);
190
191 ret = mmapCapture_->Stop(mmapCapture_);
192 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
193 }
194
195 HWTEST_F(AudioUtCaptureMmapTest, HdfAudioCaptureControlException001, TestSize.Level1)
196 {
197 struct AudioMmapBufferDescriptor desc = {0};
198
199 int32_t ret = mmapCapture_->ReqMmapBuffer(mmapCapture_, MMAP_SUGGUEST_REQ_SIZE, &desc);
200 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_INVALID_PARAM);
201 if (ret == HDF_SUCCESS) {
202 ASSERT_NE(desc.memoryFd, MMAP_INVALID_FD);
203 }
204
205 ret = mmapCapture_->Start(mmapCapture_);
206 EXPECT_EQ(ret, HDF_SUCCESS);
207
208 ret = mmapCapture_->Start(mmapCapture_); // restart can be return two state
209 EXPECT_TRUE(ret == HDF_SUCCESS || ret == HDF_FAILURE);
210
211 ret = mmapCapture_->Stop(mmapCapture_);
212 EXPECT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
213
214 ret = mmapCapture_->Stop(mmapCapture_); // restop can be return two state
215 EXPECT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
216 }
217
218 HWTEST_F(AudioUtCaptureMmapTest, HdfAudioCaptureGetMmapPosition001, TestSize.Level1)
219 {
220 struct AudioMmapBufferDescriptor desc = {0};
221 uint64_t frames = 0;
222 struct AudioTimeStamp time = {0};
223
224 int32_t ret = mmapCapture_->ReqMmapBuffer(mmapCapture_, MMAP_SUGGUEST_REQ_SIZE, &desc);
225 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_INVALID_PARAM);
226 if (ret == HDF_SUCCESS) {
227 ASSERT_NE(desc.memoryFd, MMAP_INVALID_FD);
228 }
229
230 ret = mmapCapture_->Start(mmapCapture_);
231 EXPECT_EQ(ret, HDF_SUCCESS);
232
233 ret = mmapCapture_->GetMmapPosition(mmapCapture_, &frames, &time);
234 EXPECT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_INVALID_PARAM);
235
236 ret = mmapCapture_->Stop(mmapCapture_);
237 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
238 }
239
240 HWTEST_F(AudioUtCaptureMmapTest, HdfAudioCaptureGetMmapPositionException001, TestSize.Level1)
241 {
242 struct AudioMmapBufferDescriptor desc = {0};
243 uint64_t frames = 0;
244 struct AudioTimeStamp time = {0};
245
246 int32_t ret = mmapCapture_->ReqMmapBuffer(mmapCapture_, MMAP_SUGGUEST_REQ_SIZE, &desc);
247 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_INVALID_PARAM);
248 if (ret == HDF_SUCCESS) {
249 ASSERT_NE(desc.memoryFd, MMAP_INVALID_FD);
250 }
251
252 ret = mmapCapture_->Start(mmapCapture_);
253 EXPECT_EQ(ret, HDF_SUCCESS);
254
255 ret = mmapCapture_->GetMmapPosition(nullptr, &frames, &time);
256 EXPECT_NE(ret, HDF_SUCCESS);
257
258 ret = mmapCapture_->GetMmapPosition(mmapCapture_, nullptr, &time);
259 EXPECT_NE(ret, HDF_SUCCESS);
260
261 ret = mmapCapture_->Stop(mmapCapture_);
262 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
263 }
264
265 HWTEST_F(AudioUtCaptureMmapTest, HdfAudioCaptureGetMmapPositionInValid001, TestSize.Level1)
266 {
267 uint64_t frames = 0;
268 struct AudioTimeStamp time = {0};
269
270 int32_t ret = mmapCapture_->GetMmapPosition(mmapCapture_, &frames, &time);
271 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_INVALID_PARAM);
272 }
273
274 } // end of namespace