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 "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     char *devDescriptorName_ = nullptr;
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.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
57     attrs.channelCount = AUDIO_RENDER_CHANNELCOUNT;
58     attrs.sampleRate = AUDIO_SAMPLE_RATE_48K;
59     attrs.interleaved = 0;
60     attrs.type = AUDIO_MMAP_NOIRQ;
61     attrs.period = DEEP_BUFFER_RENDER_PERIOD_SIZE;
62     attrs.frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * AUDIO_RENDER_CHANNELCOUNT;
63     attrs.isBigEndian = false;
64     attrs.isSignedData = true;
65     attrs.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (attrs.format * attrs.channelCount);
66     attrs.stopThreshold = INT_MAX;
67     attrs.silenceThreshold = BUFFER_LENTH;
68 }
69 
InitRenderDevDesc(struct AudioDeviceDescriptor & devDesc)70 void AudioUtRenderMmapTest::InitRenderDevDesc(struct AudioDeviceDescriptor &devDesc)
71 {
72     devDesc.pins = PIN_OUT_SPEAKER;
73     devDescriptorName_ = strdup("cardname");
74     devDesc.desc = devDescriptorName_;
75 
76     ASSERT_NE(desc_, nullptr);
77     ASSERT_NE(desc_->ports, nullptr);
78     for (uint32_t index = 0; index < desc_->portsLen; index++) {
79         if (desc_->ports[index].dir == PORT_OUT) {
80             devDesc.portId = desc_->ports[index].portId;
81             return;
82         }
83     }
84     free(devDesc.desc);
85 }
86 
FreeAdapterElements(struct AudioAdapterDescriptor * dataBlock,bool freeSelf)87 void AudioUtRenderMmapTest::FreeAdapterElements(struct AudioAdapterDescriptor *dataBlock, bool freeSelf)
88 {
89     if (dataBlock == nullptr) {
90         return;
91     }
92 
93     OsalMemFree(dataBlock->adapterName);
94 
95     OsalMemFree(dataBlock->ports);
96 
97     if (freeSelf) {
98         OsalMemFree(dataBlock);
99     }
100 }
101 
ReleaseAllAdapterDescs(struct AudioAdapterDescriptor * descs,uint32_t descsLen)102 void AudioUtRenderMmapTest::ReleaseAllAdapterDescs(struct AudioAdapterDescriptor *descs, uint32_t descsLen)
103 {
104     if (descs == nullptr || descsLen == 0) {
105         return;
106     }
107 
108     for (uint32_t i = 0; i < descsLen; i++) {
109         FreeAdapterElements(&descs[i], false);
110     }
111 }
112 
SetUp()113 void AudioUtRenderMmapTest::SetUp()
114 {
115     manager_ = IAudioManagerGet(false);
116     ASSERT_NE(manager_, nullptr);
117 
118     ASSERT_EQ(HDF_SUCCESS, manager_->GetAllAdapters(manager_, descs_, &size_));
119     ASSERT_NE(descs_, nullptr);
120     EXPECT_GE(MAX_AUDIO_ADAPTER_DESC, size_);
121     desc_ = &descs_[0];
122     ASSERT_EQ(HDF_SUCCESS, manager_->LoadAdapter(manager_, desc_, &adapter_));
123     ASSERT_NE(adapter_, nullptr);
124     InitRenderDevDesc(devDescRender_);
125     InitRenderAttrs(attrsRender_);
126 
127     int32_t ret = adapter_->CreateRender(adapter_, &devDescRender_, &attrsRender_, &render_, &renderId_);
128     if (ret != HDF_SUCCESS) {
129         attrsRender_.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
130         ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devDescRender_, &attrsRender_, &render_, &renderId_));
131     }
132     ASSERT_NE(render_, nullptr);
133 }
134 
TearDown()135 void AudioUtRenderMmapTest::TearDown()
136 {
137     ASSERT_NE(devDescriptorName_, nullptr);
138     free(devDescriptorName_);
139 
140     if (adapter_ != nullptr) {
141         adapter_->DestroyRender(adapter_, renderId_);
142         render_ = nullptr;
143     }
144     if (manager_ != nullptr) {
145         manager_->UnloadAdapter(manager_, desc_->adapterName);
146         adapter_ = nullptr;
147         ReleaseAllAdapterDescs(descs_, size_);
148 
149         IAudioManagerRelease(manager_, false);
150     }
151 }
152 
153 HWTEST_F(AudioUtRenderMmapTest, RenderReqMmapBufferNull001, TestSize.Level1)
154 {
155     int32_t reqSize = MMAP_SUGGEST_BUFFER_SIZE;
156     struct AudioMmapBufferDescriptor desc;
157 
158     EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->ReqMmapBuffer(nullptr, reqSize, &desc));
159 }
160 
161 HWTEST_F(AudioUtRenderMmapTest, RenderReqMmapBufferIsValid001, TestSize.Level1)
162 {
163     int32_t reqSize = MMAP_SUGGEST_BUFFER_SIZE;
164     struct AudioMmapBufferDescriptor desc;
165 
166     int32_t ret = render_->ReqMmapBuffer(render_, reqSize, &desc);
167 
168     ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_INVALID_PARAM);
169 }
170 
171 HWTEST_F(AudioUtRenderMmapTest, RenderReqMmapBufferInValid001, TestSize.Level1)
172 {
173     int32_t reqSize = MMAP_SUGGEST_BUFFER_SIZE;
174     struct AudioMmapBufferDescriptor desc;
175 
176     int32_t ret = render_->ReqMmapBuffer(render_, reqSize, &desc);
177     ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_INVALID_PARAM);
178     ret = render_->ReqMmapBuffer(render_, reqSize, &desc);
179     ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_INVALID_PARAM);
180 }
181 
182 HWTEST_F(AudioUtRenderMmapTest, RenderGetMmapPositionNull001, TestSize.Level1)
183 {
184     uint64_t frames = 0;
185     struct AudioTimeStamp time;
186     time.tvNSec = 0;
187     time.tvSec = 0;
188     EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->GetMmapPosition(nullptr, &frames, &time));
189 }
190 
191 HWTEST_F(AudioUtRenderMmapTest, RenderGetMmapPositionInValid001, TestSize.Level1)
192 {
193     uint64_t frames = 0;
194     struct AudioTimeStamp time;
195     time.tvNSec = 0;
196     time.tvSec = 0;
197 
198     int32_t ret = render_->GetMmapPosition(render_, &frames, &time);
199     ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_INVALID_PARAM);
200 }
201 
202 HWTEST_F(AudioUtRenderMmapTest, RenderGetMmapPositionIsValid001, TestSize.Level1)
203 {
204     uint64_t frames = 0;
205     struct AudioTimeStamp time;
206     time.tvNSec = 0;
207     time.tvSec = 0;
208     int32_t reqSize = MMAP_SUGGEST_BUFFER_SIZE;
209     struct AudioMmapBufferDescriptor desc;
210 
211     int32_t ret = render_->ReqMmapBuffer(render_, reqSize, &desc);
212     ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_INVALID_PARAM);
213 
214     ret = render_->Start(render_);
215     EXPECT_TRUE(ret == HDF_SUCCESS || ret == HDF_FAILURE);
216 
217     ret = render_->GetMmapPosition(render_, &frames, &time);
218     EXPECT_TRUE(ret == HDF_SUCCESS);
219     render_->Stop(render_);
220 }
221 
222 } // end of namespace