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 #include <gtest/gtest.h>
16 #include <cmath>
17 #include <memory>
18 #include <cstdio>
19 #include "hpae_sink_input_node.h"
20 #include "hpae_resample_node.h"
21 #include "hpae_sink_output_node.h"
22 #include "hpae_source_input_node.h"
23 #include <fstream>
24 #include <streambuf>
25 #include <string>
26 #include "test_case_common.h"
27 #include "audio_errors.h"
28
29 using namespace OHOS;
30 using namespace AudioStandard;
31 using namespace HPAE;
32 using namespace testing::ext;
33 using namespace testing;
34
35 static constexpr uint32_t TEST_ID = 1243;
36 static constexpr uint32_t TEST_ID2 = 1246;
37 static constexpr uint32_t TEST_FRAMELEN1 = 960;
38 static constexpr uint32_t TEST_FRAMELEN2 = 640;
39 namespace {
40 class HpaeResampleNodeTest : public testing::Test {
41 public:
42 void SetUp();
43 void TearDown();
44 };
45
SetUp()46 void HpaeResampleNodeTest::SetUp()
47 {}
48
TearDown()49 void HpaeResampleNodeTest::TearDown()
50 {}
51
52 HWTEST_F(HpaeResampleNodeTest, constructHpaeResampleNode, TestSize.Level0)
53 {
54 HpaeNodeInfo nodeInfo;
55 nodeInfo.nodeId = TEST_ID;
56 nodeInfo.frameLen = TEST_FRAMELEN1;
57 nodeInfo.samplingRate = SAMPLE_RATE_48000;
58 nodeInfo.channels = STEREO;
59 nodeInfo.format = SAMPLE_F32LE;
60 HpaeNodeInfo dstNodeInfo;
61 dstNodeInfo.nodeId = TEST_ID2;
62 dstNodeInfo.frameLen = TEST_FRAMELEN1;
63 dstNodeInfo.samplingRate = SAMPLE_RATE_44100;
64 dstNodeInfo.channels = CHANNEL_4;
65 dstNodeInfo.format = SAMPLE_F32LE;
66 std::shared_ptr<HpaeResampleNode> hpaeResampleNode = std::make_shared<HpaeResampleNode>(nodeInfo, dstNodeInfo);
67 EXPECT_EQ(hpaeResampleNode->GetSampleRate(), dstNodeInfo.samplingRate);
68 EXPECT_EQ(hpaeResampleNode->GetFrameLen(), dstNodeInfo.frameLen);
69 EXPECT_EQ(hpaeResampleNode->GetChannelCount(), dstNodeInfo.channels);
70 EXPECT_EQ(hpaeResampleNode->GetBitWidth(), dstNodeInfo.format);
71 HpaeNodeInfo &retNi = hpaeResampleNode->GetNodeInfo();
72 EXPECT_EQ(retNi.samplingRate, dstNodeInfo.samplingRate);
73 EXPECT_EQ(retNi.frameLen, dstNodeInfo.frameLen);
74 EXPECT_EQ(retNi.channels, dstNodeInfo.channels);
75 EXPECT_EQ(retNi.format, dstNodeInfo.format);
76 }
77
78 HWTEST_F(HpaeResampleNodeTest, testReset, TestSize.Level0)
79 {
80 HpaeNodeInfo nodeInfo;
81 nodeInfo.nodeId = TEST_ID;
82 nodeInfo.frameLen = TEST_FRAMELEN1;
83 nodeInfo.samplingRate = SAMPLE_RATE_48000;
84 nodeInfo.channels = STEREO;
85 nodeInfo.format = SAMPLE_F32LE;
86 HpaeNodeInfo dstNodeInfo;
87 dstNodeInfo.nodeId = TEST_ID2;
88 dstNodeInfo.frameLen = TEST_FRAMELEN1;
89 dstNodeInfo.samplingRate = SAMPLE_RATE_44100;
90 dstNodeInfo.channels = CHANNEL_4;
91 dstNodeInfo.format = SAMPLE_F32LE;
92 std::shared_ptr<HpaeResampleNode> hpaeResampleNode =
93 std::make_shared<HpaeResampleNode>(nodeInfo, dstNodeInfo, ResamplerType::PRORESAMPLER);
94 std::shared_ptr<HpaeResampleNode> hpaeResampleNode2 =
95 std::make_shared<HpaeResampleNode>(nodeInfo, dstNodeInfo, (ResamplerType)0xff);
96 EXPECT_EQ(hpaeResampleNode->GetSampleRate(), dstNodeInfo.samplingRate);
97 EXPECT_EQ(hpaeResampleNode->GetFrameLen(), dstNodeInfo.frameLen);
98 EXPECT_EQ(hpaeResampleNode->GetChannelCount(), dstNodeInfo.channels);
99 EXPECT_EQ(hpaeResampleNode->GetBitWidth(), dstNodeInfo.format);
100 HpaeNodeInfo &retNi = hpaeResampleNode->GetNodeInfo();
101 EXPECT_EQ(retNi.samplingRate, dstNodeInfo.samplingRate);
102 EXPECT_EQ(retNi.frameLen, dstNodeInfo.frameLen);
103 EXPECT_EQ(retNi.channels, dstNodeInfo.channels);
104 EXPECT_EQ(retNi.format, dstNodeInfo.format);
105 EXPECT_EQ(hpaeResampleNode->Reset(), true);
106 EXPECT_EQ(hpaeResampleNode2->Reset(), false);
107 }
108
109 HWTEST_F(HpaeResampleNodeTest, testHpaeReampleNodeProcess, TestSize.Level0)
110 {
111 HpaeNodeInfo srcNodeInfo;
112 srcNodeInfo.nodeId = TEST_ID;
113 srcNodeInfo.frameLen = TEST_FRAMELEN1;
114 srcNodeInfo.samplingRate = SAMPLE_RATE_48000;
115 srcNodeInfo.channels = STEREO;
116 srcNodeInfo.format = SAMPLE_S32LE;
117 std::shared_ptr<HpaeSinkInputNode> hpaeSinkInputNode = std::make_shared<HpaeSinkInputNode>(srcNodeInfo);
118 HpaeNodeInfo dstNodeInfo;
119 dstNodeInfo.nodeId = TEST_ID;
120 dstNodeInfo.frameLen = TEST_FRAMELEN2;
121 dstNodeInfo.samplingRate = SAMPLE_RATE_32000;
122 dstNodeInfo.channels = CHANNEL_4;
123 dstNodeInfo.format = SAMPLE_F32LE;
124 std::shared_ptr<HpaeResampleNode> hpaeResampleNode = std::make_shared<HpaeResampleNode>(srcNodeInfo, dstNodeInfo);
125 }
126
127 HWTEST_F(HpaeResampleNodeTest, testSignalProcess_001, TestSize.Level0)
128 {
129 HpaeNodeInfo nodeInfo;
130 nodeInfo.nodeId = TEST_ID;
131 nodeInfo.frameLen = TEST_FRAMELEN1;
132 nodeInfo.samplingRate = SAMPLE_RATE_48000;
133 nodeInfo.channels = STEREO;
134 nodeInfo.format = SAMPLE_F32LE;
135 HpaeNodeInfo dstNodeInfo;
136 dstNodeInfo.nodeId = TEST_ID2;
137 dstNodeInfo.frameLen = TEST_FRAMELEN1;
138 dstNodeInfo.samplingRate = SAMPLE_RATE_44100;
139 dstNodeInfo.channels = MONO;
140 dstNodeInfo.format = SAMPLE_F32LE;
141 std::shared_ptr<HpaeResampleNode> hpaeResampleNode = std::make_shared<HpaeResampleNode>(nodeInfo, dstNodeInfo);
142
143 std::vector<HpaePcmBuffer *> inputs;
144 EXPECT_EQ(hpaeResampleNode->SignalProcess(inputs), nullptr);
145 PcmBufferInfo pcmBufferInfo(MONO, TEST_FRAMELEN1, SAMPLE_RATE_44100);
146 HpaePcmBuffer hpaePcmBuffer(pcmBufferInfo);
147 inputs.emplace_back(&hpaePcmBuffer);
148 EXPECT_NE(hpaeResampleNode->SignalProcess(inputs), nullptr);
149 inputs.emplace_back(&hpaePcmBuffer);
150 EXPECT_NE(hpaeResampleNode->SignalProcess(inputs), nullptr);
151 }
152
153 HWTEST_F(HpaeResampleNodeTest, testSignalProcess_002, TestSize.Level0)
154 {
155 HpaeNodeInfo nodeInfo;
156 nodeInfo.nodeId = TEST_ID;
157 nodeInfo.frameLen = TEST_FRAMELEN1;
158 nodeInfo.samplingRate = SAMPLE_RATE_48000;
159 nodeInfo.channels = MONO;
160 nodeInfo.format = SAMPLE_F32LE;
161 HpaeNodeInfo dstNodeInfo;
162 dstNodeInfo.nodeId = TEST_ID2;
163 dstNodeInfo.frameLen = TEST_FRAMELEN1;
164 dstNodeInfo.samplingRate = SAMPLE_RATE_44100;
165 dstNodeInfo.channels = MONO;
166 dstNodeInfo.format = SAMPLE_F32LE;
167 std::shared_ptr<HpaeResampleNode> hpaeResampleNode =
168 std::make_shared<HpaeResampleNode>(nodeInfo, dstNodeInfo, (ResamplerType)0xff);
169
170 std::vector<HpaePcmBuffer *> inputs;
171 PcmBufferInfo pcmBufferInfo(MONO, TEST_FRAMELEN1, SAMPLE_RATE_44100);
172 HpaePcmBuffer hpaePcmBuffer(pcmBufferInfo);
173 inputs.emplace_back(&hpaePcmBuffer);
174 EXPECT_NE(hpaeResampleNode->SignalProcess(inputs), nullptr);
175
176 std::shared_ptr<HpaeResampleNode> hpaeResampleNode2 =
177 std::make_shared<HpaeResampleNode>(nodeInfo, dstNodeInfo);
178 EXPECT_NE(hpaeResampleNode2->SignalProcess(inputs), nullptr);
179 }
180
181 HWTEST_F(HpaeResampleNodeTest, testConnectWithInfo, TestSize.Level0)
182 {
183 HpaeNodeInfo srcNodeInfo;
184 srcNodeInfo.nodeId = TEST_ID;
185 srcNodeInfo.frameLen = TEST_FRAMELEN1;
186 srcNodeInfo.samplingRate = SAMPLE_RATE_48000;
187 srcNodeInfo.channels = STEREO;
188 srcNodeInfo.format = SAMPLE_S32LE;
189 std::shared_ptr<HpaeSourceInputNode> hpaeInputNode = std::make_shared<HpaeSourceInputNode>(srcNodeInfo);
190 HpaeNodeInfo dstNodeInfo;
191 dstNodeInfo.nodeId = TEST_ID;
192 dstNodeInfo.frameLen = TEST_FRAMELEN2;
193 dstNodeInfo.samplingRate = SAMPLE_RATE_32000;
194 dstNodeInfo.channels = CHANNEL_4;
195 dstNodeInfo.format = SAMPLE_F32LE;
196 std::shared_ptr<HpaeResampleNode> hpaeResampleNode = std::make_shared<HpaeResampleNode>(srcNodeInfo, dstNodeInfo);
197 EXPECT_EQ(hpaeResampleNode->GetSampleRate(), dstNodeInfo.samplingRate);
198 EXPECT_EQ(hpaeResampleNode->GetFrameLen(), dstNodeInfo.frameLen);
199 EXPECT_EQ(hpaeResampleNode->GetChannelCount(), dstNodeInfo.channels);
200 EXPECT_EQ(hpaeResampleNode->GetBitWidth(), dstNodeInfo.format);
201
202 hpaeResampleNode->ConnectWithInfo(hpaeInputNode, srcNodeInfo);
203 hpaeResampleNode->DisConnectWithInfo(hpaeInputNode, srcNodeInfo);
204 }
205 } // namespace
206