1 /*
2 * Copyright (c) 2025 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 "hpae_capture_effect_node.h"
18 #include "hpae_source_input_cluster.h"
19 #include "test_case_common.h"
20 #include "hpae_format_convert.h"
21
22 using namespace testing::ext;
23 using namespace testing;
24
25 namespace OHOS {
26 namespace AudioStandard {
27 namespace HPAE {
28
29 const uint32_t DEFAULT_FRAME_LENGTH = 960;
30 const uint32_t DEFAULT_NODE_ID = 1243;
31 const uint32_t DEFAULT_FORMAT = 16;
32 static std::string g_rootCapturerPath = "/data/source_file_io_48000_2_s16le.pcm";
33
34 class HpaeCaptureEffectNodeTest : public testing::Test {
35 public:
36 void SetUp() override;
37 void TearDown() override;
38 };
39
SetUp()40 void HpaeCaptureEffectNodeTest::SetUp()
41 {}
42
TearDown()43 void HpaeCaptureEffectNodeTest::TearDown()
44 {}
45
GetTestNodeInfo(HpaeNodeInfo & nodeInfo)46 static void GetTestNodeInfo(HpaeNodeInfo &nodeInfo)
47 {
48 nodeInfo.nodeId = DEFAULT_NODE_ID;
49 nodeInfo.frameLen = DEFAULT_FRAME_LENGTH;
50 nodeInfo.samplingRate = SAMPLE_RATE_48000;
51 nodeInfo.channels = STEREO;
52 nodeInfo.format = SAMPLE_S16LE;
53 nodeInfo.sceneType = HPAE_SCENE_RECORD;
54 nodeInfo.sourceBufferType = HPAE_SOURCE_BUFFER_TYPE_MIC;
55 }
56
GetTestAudioSourceAttr(IAudioSourceAttr & attr)57 static void GetTestAudioSourceAttr(IAudioSourceAttr &attr)
58 {
59 attr.adapterName = "";
60 attr.openMicSpeaker = 0;
61 attr.format = AudioSampleFormat::INVALID_WIDTH;
62 attr.sampleRate = SAMPLE_RATE_48000;
63 attr.channel = STEREO;
64 attr.volume = 0.0f;
65 attr.bufferSize = 0;
66 attr.isBigEndian = false;
67 attr.filePath = g_rootCapturerPath;
68 attr.deviceNetworkId = "";
69 attr.deviceType = 0;
70 attr.sourceType = 0;
71 attr.channelLayout = 0;
72 attr.audioStreamFlag = 0;
73 }
74
ConverFormat(uint32_t format)75 static AudioSampleFormat ConverFormat(uint32_t format)
76 {
77 return static_cast<AudioSampleFormat>(format / BITLENGTH - 1);
78 }
79
80 /*
81 * tc.name : Test HpaeCaptureEffectNode API
82 * tc.type : FUNC
83 * tc.number : HpaeCaptureEffectNodeTest_001
84 * tc.desc : Test HpaeCaptureEffectNodeTest_001
85 */
86 HWTEST_F(HpaeCaptureEffectNodeTest, HpaeCaptureEffectNodeTest_001, TestSize.Level0)
87 {
88 HpaeNodeInfo nodeInfo;
89 GetTestNodeInfo(nodeInfo);
90 std::shared_ptr<HpaeCaptureEffectNode> hpaeCaptureEffectNode = std::make_shared<HpaeCaptureEffectNode>(nodeInfo);
91 EXPECT_EQ(hpaeCaptureEffectNode->GetSampleRate(), nodeInfo.samplingRate);
92 EXPECT_EQ(hpaeCaptureEffectNode->GetFrameLen(), nodeInfo.frameLen);
93 EXPECT_EQ(hpaeCaptureEffectNode->GetChannelCount(), nodeInfo.channels);
94 EXPECT_EQ(hpaeCaptureEffectNode->GetBitWidth(), nodeInfo.format);
95 EXPECT_EQ(hpaeCaptureEffectNode->GetCapturerEffectConfig(nodeInfo), false);
96 AudioBufferConfig audioBufferConfig1 = {
97 .samplingRate = SAMPLE_RATE_48000,
98 .channels = CHANNEL_4,
99 .format = DEFAULT_FORMAT,
100 };
101 AudioBufferConfig audioBufferConfig2 = {
102 .samplingRate = SAMPLE_RATE_16000,
103 .channels = STEREO,
104 .format = DEFAULT_FORMAT,
105 };
106 AudioBufferConfig audioBufferConfig3 = {
107 .samplingRate = SAMPLE_RATE_44100,
108 .channels = CHANNEL_4,
109 .format = DEFAULT_FORMAT,
110 };
111 hpaeCaptureEffectNode->SetCapturerEffectConfig(audioBufferConfig1, audioBufferConfig2, audioBufferConfig3);
112 HpaeNodeInfo nodeInfo1;
113 EXPECT_EQ(hpaeCaptureEffectNode->GetCapturerEffectConfig(nodeInfo1), true);
114 EXPECT_EQ(nodeInfo1.samplingRate, audioBufferConfig1.samplingRate);
115 EXPECT_EQ(nodeInfo1.channels, audioBufferConfig1.channels);
116 EXPECT_EQ(nodeInfo1.format, ConverFormat(audioBufferConfig1.format));
117 HpaeNodeInfo nodeInfo2;
118 EXPECT_EQ(hpaeCaptureEffectNode->GetCapturerEffectConfig(nodeInfo2, HPAE_SOURCE_BUFFER_TYPE_EC), true);
119 EXPECT_EQ(nodeInfo2.samplingRate, audioBufferConfig2.samplingRate);
120 EXPECT_EQ(nodeInfo2.channels, audioBufferConfig2.channels);
121 EXPECT_EQ(nodeInfo2.format, ConverFormat(audioBufferConfig2.format));
122 HpaeNodeInfo nodeInfo3;
123 EXPECT_EQ(hpaeCaptureEffectNode->GetCapturerEffectConfig(nodeInfo3, HPAE_SOURCE_BUFFER_TYPE_MICREF), true);
124 EXPECT_EQ(nodeInfo3.samplingRate, audioBufferConfig3.samplingRate);
125 EXPECT_EQ(nodeInfo3.channels, audioBufferConfig3.channels);
126 EXPECT_EQ(nodeInfo3.format, ConverFormat(audioBufferConfig3.format));
127
128 EXPECT_EQ(hpaeCaptureEffectNode->Reset(), true);
129 }
130
131 /*
132 * tc.name : Test HpaeCaptureEffectNode API
133 * tc.type : FUNC
134 * tc.number : HpaeCaptureEffectNodeTest_002
135 * tc.desc : Test HpaeCaptureEffectNodeTest_002
136 */
137 HWTEST_F(HpaeCaptureEffectNodeTest, HpaeCaptureEffectNodeTest_002, TestSize.Level0)
138 {
139 HpaeNodeInfo nodeInfo;
140 GetTestNodeInfo(nodeInfo);
141 std::shared_ptr<NodeStatusCallback> testStatuscallback = std::make_shared<NodeStatusCallback>();
142 nodeInfo.statusCallback = testStatuscallback;
143 std::shared_ptr<HpaeCaptureEffectNode> hpaeCaptureEffectNode = std::make_shared<HpaeCaptureEffectNode>(nodeInfo);
144 PcmBufferInfo pcmBufferInfo(nodeInfo.channels, nodeInfo.frameLen, nodeInfo.samplingRate);
145 hpaeCaptureEffectNode->outPcmBuffer_ = std::make_unique<HpaePcmBuffer>(pcmBufferInfo);
146 EXPECT_EQ(hpaeCaptureEffectNode->GetSampleRate(), nodeInfo.samplingRate);
147 EXPECT_EQ(hpaeCaptureEffectNode->GetFrameLen(), nodeInfo.frameLen);
148 EXPECT_EQ(hpaeCaptureEffectNode->GetChannelCount(), nodeInfo.channels);
149 EXPECT_EQ(hpaeCaptureEffectNode->GetBitWidth(), nodeInfo.format);
150
151 std::shared_ptr<HpaeSourceInputCluster> hpaeSourceInputCluster = std::make_shared<HpaeSourceInputCluster>(nodeInfo);
152 hpaeCaptureEffectNode->ConnectWithInfo(hpaeSourceInputCluster, nodeInfo);
153 EXPECT_EQ(hpaeSourceInputCluster->GetSourceInputNodeUseCount(), 1 + 1);
154
155 std::string deviceClass = "file_io";
156 std::string deviceNetId = "LocalDevice";
157 SourceType sourceType = SOURCE_TYPE_MIC;
158 std::string sourceName = "mic";
159 EXPECT_EQ(hpaeSourceInputCluster->GetCapturerSourceInstance(deviceClass, deviceNetId, sourceType, sourceName), 0);
160 IAudioSourceAttr attr;
161 GetTestAudioSourceAttr(attr);
162 hpaeSourceInputCluster->CapturerSourceInit(attr);
163 hpaeSourceInputCluster->CapturerSourceStart();
164
165 hpaeCaptureEffectNode->DoProcess();
166
167 hpaeCaptureEffectNode->DisConnectWithInfo(hpaeSourceInputCluster, nodeInfo);
168 EXPECT_EQ(hpaeSourceInputCluster->GetSourceInputNodeUseCount(), 1);
169 hpaeSourceInputCluster->CapturerSourceStop();
170 hpaeSourceInputCluster->CapturerSourceDeInit();
171 }
172
173 /*
174 * tc.name : Test HpaeCaptureEffectNode API
175 * tc.type : FUNC
176 * tc.number : HpaeCaptureEffectNodeTest_003
177 * tc.desc : Test HpaeCaptureEffectNodeTest_003
178 */
179 HWTEST_F(HpaeCaptureEffectNodeTest, HpaeCaptureEffectNodeTest_003, TestSize.Level0)
180 {
181 HpaeNodeInfo nodeInfo;
182 GetTestNodeInfo(nodeInfo);
183 std::shared_ptr<NodeStatusCallback> testStatuscallback = std::make_shared<NodeStatusCallback>();
184 nodeInfo.statusCallback = testStatuscallback;
185 std::shared_ptr<HpaeCaptureEffectNode> hpaeCaptureEffectNode = std::make_shared<HpaeCaptureEffectNode>(nodeInfo);
186 EXPECT_EQ(hpaeCaptureEffectNode->GetSampleRate(), nodeInfo.samplingRate);
187 EXPECT_EQ(hpaeCaptureEffectNode->GetFrameLen(), nodeInfo.frameLen);
188 EXPECT_EQ(hpaeCaptureEffectNode->GetChannelCount(), nodeInfo.channels);
189 EXPECT_EQ(hpaeCaptureEffectNode->GetBitWidth(), nodeInfo.format);
190 CaptureEffectAttr attr = {
191 .micChannels = STEREO,
192 .ecChannels = STEREO,
193 .micRefChannels = STEREO,
194 };
195 EXPECT_NE(hpaeCaptureEffectNode->CaptureEffectCreate(0, attr), 0);
196 EXPECT_EQ(hpaeCaptureEffectNode->CaptureEffectRelease(0), 0);
197 }
198
199 /*
200 * tc.name : Test HpaeCaptureEffectNode API
201 * tc.type : FUNC
202 * tc.number : HpaeCaptureEffectNodeTest_004
203 * tc.desc : Test HpaeCaptureEffectNodeTest_004
204 */
205 HWTEST_F(HpaeCaptureEffectNodeTest, HpaeCaptureEffectNodeTest_004, TestSize.Level0)
206 {
207 HpaeNodeInfo nodeInfo;
208 GetTestNodeInfo(nodeInfo);
209 std::shared_ptr<NodeStatusCallback> testStatuscallback = std::make_shared<NodeStatusCallback>();
210 nodeInfo.statusCallback = testStatuscallback;
211 nodeInfo.effectInfo.enhanceScene = SCENE_NONE;
212 std::shared_ptr<HpaeCaptureEffectNode> hpaeCaptureEffectNode = std::make_shared<HpaeCaptureEffectNode>(nodeInfo);
213 EXPECT_EQ(hpaeCaptureEffectNode->Reset(), true);
214 }
215
216 /*
217 * tc.name : Test HpaeCaptureEffectNode API
218 * tc.type : FUNC
219 * tc.number : HpaeCaptureEffectNodeTest_005
220 * tc.desc : Test HpaeCaptureEffectNodeTest_005
221 */
222 HWTEST_F(HpaeCaptureEffectNodeTest, HpaeCaptureEffectNodeTest_005, TestSize.Level0)
223 {
224 HpaeNodeInfo nodeInfo;
225 GetTestNodeInfo(nodeInfo);
226 std::shared_ptr<NodeStatusCallback> testStatuscallback = std::make_shared<NodeStatusCallback>();
227 nodeInfo.statusCallback = testStatuscallback;
228 std::shared_ptr<HpaeCaptureEffectNode> hpaeCaptureEffectNode = std::make_shared<HpaeCaptureEffectNode>(nodeInfo);
229 EXPECT_EQ(hpaeCaptureEffectNode->Reset(), true);
230
231 std::vector<HpaePcmBuffer *> inputs = {};
232 EXPECT_EQ(hpaeCaptureEffectNode->SignalProcess(inputs), nullptr);
233 }
234
235 /*
236 * tc.name : Test HpaeCaptureEffectNode API
237 * tc.type : FUNC
238 * tc.number : HpaeCaptureEffectNodeTest_006
239 * tc.desc : Test HpaeCaptureEffectNodeTest_006
240 */
241 HWTEST_F(HpaeCaptureEffectNodeTest, HpaeCaptureEffectNodeTest_006, TestSize.Level0)
242 {
243 HpaeNodeInfo nodeInfo;
244 GetTestNodeInfo(nodeInfo);
245 std::shared_ptr<NodeStatusCallback> testStatuscallback = std::make_shared<NodeStatusCallback>();
246 nodeInfo.statusCallback = testStatuscallback;
247 std::shared_ptr<HpaeCaptureEffectNode> hpaeCaptureEffectNode = std::make_shared<HpaeCaptureEffectNode>(nodeInfo);
248 PcmBufferInfo pcmBufferInfo(nodeInfo.channels, nodeInfo.frameLen, nodeInfo.samplingRate);
249 hpaeCaptureEffectNode->outPcmBuffer_ = std::make_unique<HpaePcmBuffer>(pcmBufferInfo);
250 EXPECT_EQ(hpaeCaptureEffectNode->Reset(), true);
251
252 std::vector<HpaePcmBuffer *> inputs;
253 HpaePcmBuffer hpaePcmBuffer(pcmBufferInfo);
254 hpaePcmBuffer.SetSourceBufferType(HPAE_SOURCE_BUFFER_TYPE_EC);
255 inputs.emplace_back(&hpaePcmBuffer);
256 EXPECT_EQ(hpaeCaptureEffectNode->SignalProcess(inputs), hpaeCaptureEffectNode->outPcmBuffer_.get());
257 }
258
259 /*
260 * tc.name : Test HpaeCaptureEffectNode API
261 * tc.type : FUNC
262 * tc.number : HpaeCaptureEffectNodeTest_007
263 * tc.desc : Test HpaeCaptureEffectNodeTest_007
264 */
265 HWTEST_F(HpaeCaptureEffectNodeTest, HpaeCaptureEffectNodeTest_007, TestSize.Level0)
266 {
267 HpaeNodeInfo nodeInfo;
268 GetTestNodeInfo(nodeInfo);
269 std::shared_ptr<NodeStatusCallback> testStatuscallback = std::make_shared<NodeStatusCallback>();
270 nodeInfo.statusCallback = testStatuscallback;
271 std::shared_ptr<HpaeCaptureEffectNode> hpaeCaptureEffectNode = std::make_shared<HpaeCaptureEffectNode>(nodeInfo);
272 PcmBufferInfo pcmBufferInfo(nodeInfo.channels, nodeInfo.frameLen, nodeInfo.samplingRate);
273 hpaeCaptureEffectNode->outPcmBuffer_ = std::make_unique<HpaePcmBuffer>(pcmBufferInfo);
274 EXPECT_EQ(hpaeCaptureEffectNode->Reset(), true);
275
276 std::vector<HpaePcmBuffer *> inputs = {};
277 HpaePcmBuffer hpaePcmBuffer(pcmBufferInfo);
278 hpaePcmBuffer.SetSourceBufferType(HPAE_SOURCE_BUFFER_TYPE_MICREF);
279 inputs.emplace_back(&hpaePcmBuffer);
280 EXPECT_EQ(hpaeCaptureEffectNode->SignalProcess(inputs), hpaeCaptureEffectNode->outPcmBuffer_.get());
281 }
282 } // namespace HPAE
283 } // namespace AudioStandard
284 } // namespace OHOS
285