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 "osal_mem.h"
18
19 #include "v1_0/audio_types.h"
20 #include "v1_0/iaudio_manager.h"
21 #include "v1_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 int MOVE_LEFT_NUM = 8;
30 const int32_t AUDIO_RENDER_CHANNELCOUNT = 2;
31 const int32_t AUDIO_SAMPLE_RATE_48K = 48000;
32 const int32_t MAX_AUDIO_ADAPTER_DESC = 5;
33 const int32_t MMAP_SUGGEST_BUFFER_SIZE = 1920;
34
35 class AudioUtRenderMmapTest : public testing::Test {
36 public:
37 struct IAudioManager *manager_ = nullptr;
38 struct AudioAdapterDescriptor descs_[MAX_AUDIO_ADAPTER_DESC];
39 struct AudioAdapterDescriptor *desc_;
40 struct IAudioAdapter *adapter_ = nullptr;
41 struct IAudioRender *render_ = nullptr;
42 struct AudioDeviceDescriptor devDescRender_ = {};
43 struct AudioSampleAttributes attrsRender_ = {};
44 uint32_t renderId_ = 0;
45 uint32_t size_ = MAX_AUDIO_ADAPTER_DESC;
46 virtual void SetUp();
47 virtual void TearDown();
48 void InitRenderAttrs(struct AudioSampleAttributes &attrs);
49 void InitRenderDevDesc(struct AudioDeviceDescriptor &devDesc);
50 void FreeAdapterElements(struct AudioAdapterDescriptor *dataBlock, bool freeSelf);
51 void ReleaseAllAdapterDescs(struct AudioAdapterDescriptor *descs, uint32_t descsLen);
52 };
53
InitRenderAttrs(struct AudioSampleAttributes & attrs)54 void AudioUtRenderMmapTest::InitRenderAttrs(struct AudioSampleAttributes &attrs)
55 {
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 / MOVE_LEFT_NUM;
62 attrs.isBigEndian = false;
63 attrs.isSignedData = true;
64 attrs.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (attrs.format * attrs.channelCount / MOVE_LEFT_NUM);
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 attrsRender_.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
126 int32_t ret = adapter_->CreateRender(adapter_, &devDescRender_, &attrsRender_, &render_, &renderId_);
127 if (ret != HDF_SUCCESS) {
128 attrsRender_.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
129 ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devDescRender_, &attrsRender_, &render_, &renderId_));
130 }
131 ASSERT_NE(render_, nullptr);
132 }
133
TearDown()134 void AudioUtRenderMmapTest::TearDown()
135 {
136 if (adapter_ != nullptr) {
137 adapter_->DestroyRender(adapter_, renderId_);
138 render_ = nullptr;
139 }
140 if (manager_ != nullptr) {
141 manager_->UnloadAdapter(manager_, desc_->adapterName);
142 adapter_ = nullptr;
143 ReleaseAllAdapterDescs(descs_, size_);
144
145 IAudioManagerRelease(manager_, false);
146 }
147 }
148
149 HWTEST_F(AudioUtRenderMmapTest, RenderReqMmapBufferNull001, TestSize.Level1)
150 {
151 int32_t reqSize = MMAP_SUGGEST_BUFFER_SIZE;
152 struct AudioMmapBufferDescriptor desc;
153
154 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->ReqMmapBuffer(nullptr, reqSize, &desc));
155 }
156
157 HWTEST_F(AudioUtRenderMmapTest, RenderReqMmapBufferIsValid001, TestSize.Level1)
158 {
159 int32_t reqSize = MMAP_SUGGEST_BUFFER_SIZE;
160 struct AudioMmapBufferDescriptor desc;
161
162 int32_t ret = render_->ReqMmapBuffer(render_, reqSize, &desc);
163
164 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_INVALID_PARAM);
165 }
166
167 HWTEST_F(AudioUtRenderMmapTest, RenderGetMmapPositionNull001, TestSize.Level1)
168 {
169 uint64_t frames = 0;
170 struct AudioTimeStamp time;
171 time.tvNSec = 0;
172 time.tvSec = 0;
173 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->GetMmapPosition(nullptr, &frames, &time));
174 }
175
176 HWTEST_F(AudioUtRenderMmapTest, RenderGetMmapPositionIsValid001, TestSize.Level1)
177 {
178 uint64_t frames = 0;
179 struct AudioTimeStamp time;
180 time.tvNSec = 0;
181 time.tvSec = 0;
182 int32_t reqSize = MMAP_SUGGEST_BUFFER_SIZE;
183 struct AudioMmapBufferDescriptor desc;
184
185 int32_t ret = render_->ReqMmapBuffer(render_, reqSize, &desc);
186 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_INVALID_PARAM);
187
188 ASSERT_EQ(HDF_SUCCESS, render_->Start(render_));
189
190 ret = render_->GetMmapPosition(render_, &frames, &time);
191 ASSERT_TRUE(ret == HDF_SUCCESS);
192 }
193
194 } // end of namespace