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 <cmath>
18 #include <memory>
19 #include "hpae_sink_input_node.h"
20 #include "hpae_sink_output_node.h"
21 #include "test_case_common.h"
22 #include "audio_errors.h"
23
24 using namespace OHOS;
25 using namespace AudioStandard;
26 using namespace HPAE;
27 using namespace testing::ext;
28 using namespace testing;
29
30 class HpaeSinkInputNodeTest : public testing::Test {
31 public:
32 void SetUp();
33 void TearDown();
34 };
35
SetUp()36 void HpaeSinkInputNodeTest::SetUp()
37 {}
38
TearDown()39 void HpaeSinkInputNodeTest::TearDown()
40 {}
41
42 namespace {
43 constexpr int32_t NORMAL_FRAME_LEN = 960;
44 constexpr int32_t NORMAL_ID = 1243;
45 constexpr float LOUDNESS_GAIN = 1.0f;
46 HWTEST_F(HpaeSinkInputNodeTest, constructHpaeSinkInputNode, TestSize.Level0)
47 {
48 HpaeNodeInfo nodeInfo;
49 nodeInfo.nodeId = NORMAL_ID;
50 nodeInfo.frameLen = NORMAL_FRAME_LEN;
51 nodeInfo.samplingRate = SAMPLE_RATE_48000;
52 nodeInfo.channels = STEREO;
53 nodeInfo.format = SAMPLE_F32LE;
54 std::unique_ptr<HpaeSinkInputNode> hpaeSinkInputNode = std::make_unique<HpaeSinkInputNode>(nodeInfo);
55 EXPECT_EQ(hpaeSinkInputNode->GetSampleRate(), nodeInfo.samplingRate);
56 EXPECT_EQ(hpaeSinkInputNode->GetFrameLen(), nodeInfo.frameLen);
57 EXPECT_EQ(hpaeSinkInputNode->GetChannelCount(), nodeInfo.channels);
58 EXPECT_EQ(hpaeSinkInputNode->GetBitWidth(), nodeInfo.format);
59 HpaeNodeInfo &retNi = hpaeSinkInputNode->GetNodeInfo();
60 EXPECT_EQ(retNi.samplingRate, nodeInfo.samplingRate);
61 EXPECT_EQ(retNi.frameLen, nodeInfo.frameLen);
62 EXPECT_EQ(retNi.channels, nodeInfo.channels);
63 EXPECT_EQ(retNi.format, nodeInfo.format);
64 }
65
66 HWTEST_F(HpaeSinkInputNodeTest, testSinkInputOutputCase, TestSize.Level0)
67 {
68 HpaeNodeInfo nodeInfo;
69 nodeInfo.nodeId = NORMAL_ID;
70 nodeInfo.frameLen = NORMAL_FRAME_LEN;
71 nodeInfo.samplingRate = SAMPLE_RATE_48000;
72 nodeInfo.channels = STEREO;
73 nodeInfo.format = SAMPLE_F32LE;
74 std::shared_ptr<HpaeSinkInputNode> hpaeSinkInputNode = std::make_shared<HpaeSinkInputNode>(nodeInfo);
75 EXPECT_EQ(hpaeSinkInputNode.use_count(), 1);
76 {
77 std::shared_ptr<OutputNode<HpaePcmBuffer *>> outputNode = hpaeSinkInputNode;
78 EXPECT_EQ(hpaeSinkInputNode.use_count(), 1 + 1); // add 1 count because outputNode
79 std::shared_ptr<HpaeNode> hpaeNode = outputNode->GetSharedInstance();
80 EXPECT_EQ(hpaeSinkInputNode.use_count(), 1 + 1 + 1); // add 1 count because hpaeNode
81 EXPECT_EQ(hpaeNode->GetSampleRate(), nodeInfo.samplingRate);
82 EXPECT_EQ(hpaeNode->GetFrameLen(), nodeInfo.frameLen);
83 EXPECT_EQ(hpaeNode->GetChannelCount(), nodeInfo.channels);
84 EXPECT_EQ(hpaeNode->GetBitWidth(), nodeInfo.format);
85 }
86 EXPECT_EQ(hpaeSinkInputNode.use_count(), 1);
87 std::shared_ptr<HpaeSinkOutputNode> hpaeSinkOutputNode = std::make_shared<HpaeSinkOutputNode>(nodeInfo);
88 EXPECT_EQ(hpaeSinkOutputNode.use_count(), 1);
89 hpaeSinkOutputNode->Connect(hpaeSinkInputNode);
90 EXPECT_EQ(hpaeSinkOutputNode.use_count(), 1);
91 EXPECT_EQ(hpaeSinkInputNode.use_count(), 1 + 1);
92 OutputPort<HpaePcmBuffer *> *outputPort = hpaeSinkInputNode->GetOutputPort();
93 EXPECT_EQ(outputPort->GetInputNum(), 1);
94 hpaeSinkOutputNode->DisConnect(hpaeSinkInputNode);
95 EXPECT_EQ(hpaeSinkInputNode.use_count(), 1);
96 outputPort = hpaeSinkInputNode->GetOutputPort();
97 EXPECT_EQ(outputPort->GetInputNum(), 0);
98 }
99
100 HWTEST_F(HpaeSinkInputNodeTest, testWriteDataToSinkInputDataCase, TestSize.Level0)
101 {
102 HpaeNodeInfo nodeInfo;
103 nodeInfo.nodeId = NORMAL_ID;
104 nodeInfo.frameLen = NORMAL_FRAME_LEN;
105 nodeInfo.samplingRate = SAMPLE_RATE_48000;
106 nodeInfo.channels = STEREO;
107 nodeInfo.format = SAMPLE_F32LE;
108 int32_t testNum = 10;
109 std::shared_ptr<HpaeSinkInputNode> hpaeSinkInputNode = std::make_shared<HpaeSinkInputNode>(nodeInfo);
110 std::shared_ptr<WriteFixedDataCb> writeFixedDataCb = std::make_shared<WriteFixedDataCb>(SAMPLE_F32LE);
111 hpaeSinkInputNode->RegisterWriteCallback(writeFixedDataCb);
112 for (int32_t i = 0; i < testNum; i++) {
113 OutputPort<HpaePcmBuffer *> *outputPort = hpaeSinkInputNode->GetOutputPort();
114 HpaePcmBuffer* outPcmBuffer = outputPort->PullOutputData();
115 float* outputPcmData = outPcmBuffer->GetPcmDataBuffer();
116 for (int32_t j = 0; j < nodeInfo.frameLen; j++) {
117 for (int32_t k = 0; k < nodeInfo.channels; k++) {
118 float diff = outputPcmData[j * nodeInfo.channels + k] - i;
119 EXPECT_EQ(fabs(diff) < TEST_VALUE_PRESION, true);
120 }
121 }
122 }
123 }
124
125 HWTEST_F(HpaeSinkInputNodeTest, testWriteDataToSinkInputAndSinkOutputDataCase, TestSize.Level0)
126 {
127 HpaeNodeInfo nodeInfo;
128 nodeInfo.nodeId = NORMAL_ID;
129 nodeInfo.frameLen = NORMAL_FRAME_LEN;
130 nodeInfo.samplingRate = SAMPLE_RATE_48000;
131 nodeInfo.channels = STEREO;
132 nodeInfo.format = SAMPLE_F32LE;
133 int32_t testNum = 10;
134 std::shared_ptr<HpaeSinkInputNode> hpaeSinkInputNode = std::make_shared<HpaeSinkInputNode>(nodeInfo);
135 std::shared_ptr<HpaeSinkOutputNode> hpaeSinkOutputNode = std::make_shared<HpaeSinkOutputNode>(nodeInfo);
136 std::shared_ptr<WriteFixedDataCb> writeFixedDataCb = std::make_shared<WriteFixedDataCb>(SAMPLE_F32LE);
137 hpaeSinkInputNode->RegisterWriteCallback(writeFixedDataCb);
138 hpaeSinkOutputNode->Connect(hpaeSinkInputNode);
139 EXPECT_EQ(hpaeSinkInputNode.use_count(), 1 + 1);
140 for (int32_t i = 0; i < testNum; i++) {
141 OutputPort<HpaePcmBuffer *> *outputPort = hpaeSinkInputNode->GetOutputPort();
142 HpaePcmBuffer* outPcmBuffer = outputPort->PullOutputData();
143 float* outputPcmData = outPcmBuffer->GetPcmDataBuffer();
144 for (int32_t j = 0; j < nodeInfo.frameLen; j++) {
145 for (int32_t k = 0; k < nodeInfo.channels; k++) {
146 float diff = outputPcmData[j * nodeInfo.channels + k] - i;
147 EXPECT_EQ(fabs(diff) < TEST_VALUE_PRESION, true);
148 }
149 }
150 }
151
152 hpaeSinkOutputNode->DisConnect(hpaeSinkInputNode);
153 EXPECT_EQ(hpaeSinkInputNode.use_count(), 1);
154 }
155
156 HWTEST_F(HpaeSinkInputNodeTest, testLoudnessGain, TestSize.Level0)
157 {
158 HpaeNodeInfo nodeInfo;
159 nodeInfo.nodeId = NORMAL_ID;
160 nodeInfo.frameLen = NORMAL_FRAME_LEN;
161 nodeInfo.samplingRate = SAMPLE_RATE_48000;
162 nodeInfo.channels = STEREO;
163 nodeInfo.format = SAMPLE_F32LE;
164
165 auto sinkInputNode = std::make_shared<HpaeSinkInputNode>(nodeInfo);
166 sinkInputNode->SetLoudnessGain(LOUDNESS_GAIN);
167
168 EXPECT_FLOAT_EQ(sinkInputNode->GetLoudnessGain(), LOUDNESS_GAIN);
169 }
170
171 HWTEST_F(HpaeSinkInputNodeTest, testReadToAudioBuffer, TestSize.Level0)
172 {
173 HpaeNodeInfo nodeInfo;
174 nodeInfo.nodeId = NORMAL_ID;
175 nodeInfo.frameLen = NORMAL_FRAME_LEN;
176 nodeInfo.samplingRate = SAMPLE_RATE_48000;
177 nodeInfo.channels = STEREO;
178 nodeInfo.format = SAMPLE_F32LE;
179
180 nodeInfo.deviceClass = "offload";
181 auto sinkInputNode = std::make_shared<HpaeSinkInputNode>(nodeInfo);
182 sinkInputNode->offloadEnable_ = true;
183 int32_t ret = 0;
184 bool funcRet = sinkInputNode->ReadToAudioBuffer(ret);
185 EXPECT_EQ(funcRet, true);
186
187 sinkInputNode->offloadEnable_ = false;
188 funcRet = sinkInputNode->ReadToAudioBuffer(ret);
189 EXPECT_EQ(funcRet, true);
190
191 nodeInfo.deviceClass = "remote_offload";
192 sinkInputNode = std::make_shared<HpaeSinkInputNode>(nodeInfo);
193 sinkInputNode->offloadEnable_ = true;
194 funcRet = sinkInputNode->ReadToAudioBuffer(ret);
195 EXPECT_EQ(funcRet, true);
196
197 sinkInputNode->offloadEnable_ = false;
198 funcRet = sinkInputNode->ReadToAudioBuffer(ret);
199 EXPECT_EQ(funcRet, true);
200 }
201 }