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 <climits>
17 #include <cstring>
18 #include <gtest/gtest.h>
19 #include "hdf_dlist.h"
20 #include "osal_mem.h"
21 #include "v4_0/audio_types.h"
22 #include "v4_0/iaudio_adapter.h"
23 #include "v4_0/iaudio_manager.h"
24 
25 using namespace std;
26 using namespace testing::ext;
27 
28 #define AUDIO_CHANNELCOUNT              2
29 #define AUDIO_SAMPLE_RATE_192K          192000
30 #define AUDIO_SAMPLE_RATE_48K           48000
31 #define AUDIO_SAMPLE_RATE_44_1K         44100
32 #define DEEP_BUFFER_RENDER_PERIOD_SIZE  4096
33 #define AUDIO_CHANNELLAYOUT             3
34 namespace {
35 static const uint32_t g_audioAdapterNumMax = 5;
36 
37 class HdfAudioUtAdapterDirectTest : public testing::Test {
38 public:
39     struct IAudioManager *manager_ = nullptr;
40     struct IAudioAdapter *adapter_ = nullptr;
41     struct AudioAdapterDescriptor *adapterDescs_ = nullptr;
42     uint32_t renderId_ = 0;
43     uint32_t captureId_ = 0;
44     virtual void SetUp();
45     virtual void TearDown();
46     void InitDirectAttrs(struct AudioSampleAttributes &attrs);
47     void InitDevDesc(struct AudioDeviceDescriptor &devDesc);
48     void AudioAdapterDescriptorFree(struct AudioAdapterDescriptor *dataBlock, bool freeSelf);
49     void ReleaseAdapterDescs(struct AudioAdapterDescriptor **descs, uint32_t descsLen);
50 };
51 
AudioAdapterDescriptorFree(struct AudioAdapterDescriptor * dataBlock,bool freeSelf)52 void HdfAudioUtAdapterDirectTest::AudioAdapterDescriptorFree(struct AudioAdapterDescriptor *dataBlock, bool freeSelf)
53 {
54     if (dataBlock == nullptr) {
55         return;
56     }
57 
58     if (dataBlock->adapterName != nullptr) {
59         OsalMemFree(dataBlock->adapterName);
60         dataBlock->adapterName = nullptr;
61     }
62 
63     if (dataBlock->ports != nullptr) {
64         OsalMemFree(dataBlock->ports);
65     }
66 
67     if (freeSelf) {
68         OsalMemFree(dataBlock);
69     }
70 }
71 
ReleaseAdapterDescs(struct AudioAdapterDescriptor ** descs,uint32_t descsLen)72 void HdfAudioUtAdapterDirectTest::ReleaseAdapterDescs(struct AudioAdapterDescriptor **descs, uint32_t descsLen)
73 {
74     if ((descsLen > 0) && (descs != nullptr) && ((*descs) != nullptr)) {
75         for (uint32_t i = 0; i < descsLen; i++) {
76             AudioAdapterDescriptorFree(&(*descs)[i], false);
77         }
78         OsalMemFree(*descs);
79         *descs = nullptr;
80     }
81 }
82 
InitDirectAttrs(struct AudioSampleAttributes & attrs)83 void HdfAudioUtAdapterDirectTest::InitDirectAttrs(struct AudioSampleAttributes &attrs)
84 {
85     attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
86     attrs.channelCount = AUDIO_CHANNELCOUNT;
87     attrs.channelLayout = AUDIO_CHANNELLAYOUT;
88     attrs.sampleRate = AUDIO_SAMPLE_RATE_192K;
89     attrs.interleaved = 1;
90     attrs.type = AUDIO_DIRECT;
91     attrs.period = DEEP_BUFFER_RENDER_PERIOD_SIZE;
92     attrs.frameSize = AUDIO_FORMAT_TYPE_PCM_32_BIT * AUDIO_CHANNELCOUNT;
93     attrs.isBigEndian = false;
94     attrs.isSignedData = true;
95     attrs.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (attrs.format * attrs.frameSize);
96     attrs.stopThreshold = INT_MAX;
97     attrs.silenceThreshold = 0;
98 }
99 
InitDevDesc(struct AudioDeviceDescriptor & devDesc)100 void HdfAudioUtAdapterDirectTest::InitDevDesc(struct AudioDeviceDescriptor &devDesc)
101 {
102     ASSERT_NE(adapterDescs_, nullptr);
103     ASSERT_NE(adapterDescs_->ports, nullptr);
104     for (uint32_t index = 0; index < adapterDescs_->portsLen; index++) {
105         if (adapterDescs_->ports[index].dir == PORT_OUT) {
106             devDesc.portId = adapterDescs_->ports[index].portId;
107             return;
108         }
109     }
110 }
111 
SetUp()112 void HdfAudioUtAdapterDirectTest::SetUp()
113 {
114     uint32_t size = g_audioAdapterNumMax;
115     manager_ = IAudioManagerGet(false);
116     ASSERT_NE(manager_, nullptr);
117 
118     adapterDescs_ = (struct AudioAdapterDescriptor *)OsalMemCalloc(
119         sizeof(struct AudioAdapterDescriptor) * (g_audioAdapterNumMax));
120     ASSERT_NE(adapterDescs_, nullptr);
121 
122     ASSERT_EQ(HDF_SUCCESS, manager_->GetAllAdapters(manager_, adapterDescs_, &size));
123     if (size > g_audioAdapterNumMax) {
124         ReleaseAdapterDescs(&adapterDescs_, g_audioAdapterNumMax);
125         ASSERT_LT(size, g_audioAdapterNumMax);
126     }
127 
128     if (manager_->LoadAdapter(manager_, &adapterDescs_[0], &adapter_) != HDF_SUCCESS) {
129         ReleaseAdapterDescs(&adapterDescs_, g_audioAdapterNumMax);
130         ASSERT_TRUE(false);
131     }
132     if (adapter_ == nullptr) {
133         ReleaseAdapterDescs(&adapterDescs_, g_audioAdapterNumMax);
134         ASSERT_TRUE(false);
135     }
136 }
137 
TearDown()138 void HdfAudioUtAdapterDirectTest::TearDown()
139 {
140     ASSERT_NE(manager_, nullptr);
141     ASSERT_NE(adapter_, nullptr);
142 
143     manager_->UnloadAdapter(manager_, adapterDescs_[0].adapterName);
144     ReleaseAdapterDescs(&adapterDescs_, g_audioAdapterNumMax);
145     adapter_ = nullptr;
146     IAudioManagerRelease(manager_, false);
147     manager_ = nullptr;
148 }
149 
150 HWTEST_F(HdfAudioUtAdapterDirectTest, HdfAudioAdapterDirectCreateRenderIsvalid001, TestSize.Level1)
151 {
152     struct IAudioRender *render = nullptr;
153     struct AudioDeviceDescriptor devicedesc = {};
154     struct AudioSampleAttributes attrs = {};
155     InitDevDesc(devicedesc);
156     devicedesc.desc = strdup("");
157     devicedesc.pins = PIN_OUT_HEADSET;
158     InitDirectAttrs(attrs);
159     attrs.streamId = 0;
160     int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
161     EXPECT_TRUE(ret == HDF_SUCCESS);
162     ret = adapter_->DestroyRender(adapter_, renderId_);
163     EXPECT_TRUE(ret == HDF_SUCCESS);
164 }
165 
166 HWTEST_F(HdfAudioUtAdapterDirectTest, HdfAudioAdapterDirectCreateRenderIsvalid002, TestSize.Level1)
167 {
168     struct IAudioRender *render = nullptr;
169     struct AudioDeviceDescriptor devicedesc = {};
170     struct AudioSampleAttributes attrs = {};
171     InitDevDesc(devicedesc);
172     devicedesc.desc = strdup("");
173     devicedesc.pins = PIN_OUT_HEADSET;
174     InitDirectAttrs(attrs);
175     attrs.streamId = 0;
176     attrs.sampleRate = AUDIO_SAMPLE_RATE_48K;
177     int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
178     EXPECT_TRUE(ret == HDF_SUCCESS);
179     ret = adapter_->DestroyRender(adapter_, renderId_);
180     EXPECT_TRUE(ret == HDF_SUCCESS);
181 }
182 
183 HWTEST_F(HdfAudioUtAdapterDirectTest, HdfAudioAdapterDirectCreateRenderIsvalid003, TestSize.Level1)
184 {
185     struct IAudioRender *render = nullptr;
186     struct AudioDeviceDescriptor devicedesc = {};
187     struct AudioSampleAttributes attrs = {};
188     InitDevDesc(devicedesc);
189     devicedesc.desc = strdup("");
190     devicedesc.pins = PIN_OUT_HEADSET;
191     InitDirectAttrs(attrs);
192     attrs.streamId = 0;
193     attrs.sampleRate = AUDIO_SAMPLE_RATE_44_1K;
194     int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
195     EXPECT_TRUE(ret == HDF_SUCCESS);
196     ret = adapter_->DestroyRender(adapter_, renderId_);
197     EXPECT_TRUE(ret == HDF_SUCCESS);
198 }
199 
200 }