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 <gmock/gmock.h>
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 testing::ext;
25 using namespace testing;
26
27 namespace OHOS {
28 namespace AudioStandard {
29 namespace HPAE {
30 const char *ROOT_PATH = "/data/source_file_io_48000_2_s16le.pcm";
31 class HpaeSinkOutputNodeTest : public testing::Test {
32 public:
33 void SetUp();
34 void TearDown();
35 };
36
SetUp()37 void HpaeSinkOutputNodeTest::SetUp()
38 {}
39
TearDown()40 void HpaeSinkOutputNodeTest::TearDown()
41 {}
42
43 class MockAudioRenderSink : public IAudioRenderSink {
44 public:
45 MOCK_METHOD(int32_t, Init, (const IAudioSinkAttr &attr), (override));
46 MOCK_METHOD(void, DeInit, (), (override));
47 MOCK_METHOD(bool, IsInited, (), (override));
48
49 MOCK_METHOD(int32_t, Start, (), (override));
50 MOCK_METHOD(int32_t, Stop, (), (override));
51 MOCK_METHOD(int32_t, Resume, (), (override));
52 MOCK_METHOD(int32_t, Pause, (), (override));
53 MOCK_METHOD(int32_t, Flush, (), (override));
54 MOCK_METHOD(int32_t, Reset, (), (override));
55 MOCK_METHOD(int32_t, RenderFrame, (char &data, uint64_t len, uint64_t &writeLen), (override));
56 MOCK_METHOD(int64_t, GetVolumeDataCount, (), (override));
57
58 MOCK_METHOD(int32_t, SuspendRenderSink, (), (override));
59 MOCK_METHOD(int32_t, RestoreRenderSink, (), (override));
60
61 MOCK_METHOD(void, SetAudioParameter,
62 (const AudioParamKey key, const std::string &condition, const std::string &value), (override));
63 MOCK_METHOD(std::string, GetAudioParameter,
64 (const AudioParamKey key, const std::string &condition), (override));
65
66 MOCK_METHOD(int32_t, SetVolume, (float left, float right), (override));
67 MOCK_METHOD(int32_t, GetVolume, (float &left, float &right), (override));
68
69 MOCK_METHOD(int32_t, GetLatency, (uint32_t &latency), (override));
70 MOCK_METHOD(int32_t, GetTransactionId, (uint64_t &transactionId), (override));
71 MOCK_METHOD(int32_t, GetPresentationPosition,
72 (uint64_t &frames, int64_t &timeSec, int64_t &timeNanoSec), (override));
73 MOCK_METHOD(float, GetMaxAmplitude, (), (override));
74 MOCK_METHOD(void, SetAudioMonoState, (bool audioMono), (override));
75 MOCK_METHOD(void, SetAudioBalanceValue, (float audioBalance), (override));
76
SetSinkMuteForSwitchDevice(bool)77 int32_t SetSinkMuteForSwitchDevice(bool /* mute */) override { return 0; }
SetDeviceConnectedFlag(bool)78 int32_t SetDeviceConnectedFlag(bool /* flag */) override { return -1; }
SetSpeed(float)79 void SetSpeed(float /* speed */) override {}
80
81 MOCK_METHOD(int32_t, SetAudioScene, (AudioScene audioScene, bool scoExcludeFlag), (override));
82 MOCK_METHOD(int32_t, GetAudioScene, (), (override));
83
84 MOCK_METHOD(int32_t, UpdateActiveDevice, (std::vector<DeviceType> &outputDevices), (override));
85
RegistCallback(uint32_t,IAudioSinkCallback *)86 void RegistCallback(uint32_t /* type */, IAudioSinkCallback * /* callback */) override {}
RegistCallback(uint32_t,std::shared_ptr<IAudioSinkCallback>)87 void RegistCallback(uint32_t /* type */, std::shared_ptr<IAudioSinkCallback> /* callback */) override {}
88 MOCK_METHOD(void, ResetActiveDeviceForDisconnect, (DeviceType device), (override));
89
90 MOCK_METHOD(int32_t, SetPaPower, (int32_t flag), (override));
91 MOCK_METHOD(int32_t, SetPriPaPower, (), (override));
92
93 MOCK_METHOD(int32_t, UpdateAppsUid, (const int32_t appsUid[MAX_MIX_CHANNELS], const size_t size), (override));
94 MOCK_METHOD(int32_t, UpdateAppsUid, (const std::vector<int32_t> &appsUid), (override));
95
SetRenderEmpty(int32_t)96 int32_t SetRenderEmpty(int32_t /* durationUs */) override { return 0; }
SetAddress(const std::string &)97 void SetAddress(const std::string & /* address */) override {}
SetInvalidState()98 void SetInvalidState() override {}
99
100 MOCK_METHOD(void, DumpInfo, (std::string &dumpString), (override));
101
IsSinkInited()102 bool IsSinkInited() override { return false; }
103
GetMmapBufferInfo(int &,uint32_t &,uint32_t &,uint32_t &,uint32_t &)104 int32_t GetMmapBufferInfo(int & /* fd */, uint32_t & /* totalSizeInframe */,
105 uint32_t & /* spanSizeInframe */, uint32_t & /* byteSizePerFrame */,
106 uint32_t & /* syncInfoSize */) override { return -1; }
GetMmapHandlePosition(uint64_t &,int64_t &,int64_t &)107 int32_t GetMmapHandlePosition(uint64_t & /* frames */, int64_t & /* timeSec */,
108 int64_t & /* timeNanoSec */) override { return -1; }
109
Drain(AudioDrainType)110 int32_t Drain(AudioDrainType /* type */) override { return -1; }
RegistOffloadHdiCallback(std::function<void (const RenderCallbackType type)>)111 void RegistOffloadHdiCallback(std::function<void(const RenderCallbackType type)> /* callback */) override {}
RegistDirectHdiCallback(std::function<void (const RenderCallbackType type)>)112 int32_t RegistDirectHdiCallback(std::function<void(const RenderCallbackType type)> /* callback */) override
113 {
114 return 0;
115 }
SetBufferSize(uint32_t)116 int32_t SetBufferSize(uint32_t /* sizeMs */) override { return -1; }
SetOffloadRenderCallbackType(RenderCallbackType)117 int32_t SetOffloadRenderCallbackType(RenderCallbackType /* type */) override { return -1; }
LockOffloadRunningLock()118 int32_t LockOffloadRunningLock() override { return -1; }
UnLockOffloadRunningLock()119 int32_t UnLockOffloadRunningLock() override { return -1; }
120
SplitRenderFrame(char &,uint64_t,uint64_t &,const char *)121 int32_t SplitRenderFrame(char & /* data */, uint64_t /* len */, uint64_t & /* writeLen */,
122 const char * /* streamType */) override { return -1; }
123
UpdatePrimaryConnectionState(uint32_t)124 int32_t UpdatePrimaryConnectionState(uint32_t /* operation */) override { return -1; }
125
SetDmDeviceType(uint16_t,DeviceType)126 void SetDmDeviceType(uint16_t /* dmDeviceType */, DeviceType /* deviceType */) override {}
127 };
128
PrepareNodeInfo(HpaeNodeInfo & nodeInfo)129 static void PrepareNodeInfo(HpaeNodeInfo &nodeInfo)
130 {
131 size_t frameLen = 960;
132 uint32_t nodeId = 1243;
133 nodeInfo.nodeId = nodeId;
134 nodeInfo.frameLen = frameLen;
135 nodeInfo.samplingRate = SAMPLE_RATE_48000;
136 nodeInfo.channels = STEREO;
137 nodeInfo.format = SAMPLE_F32LE;
138 }
139
140 HWTEST_F(HpaeSinkOutputNodeTest, constructHpaeSinkOutputNode, TestSize.Level0)
141 {
142 uint32_t sessionId = 10001;
143 HpaeNodeInfo nodeInfo;
144 PrepareNodeInfo(nodeInfo);
145 nodeInfo.sessionId = sessionId;
146 std::shared_ptr<HpaeSinkOutputNode> hpaeSinkOutputNode = std::make_shared<HpaeSinkOutputNode>(nodeInfo);
147 EXPECT_EQ(hpaeSinkOutputNode->GetSampleRate(), nodeInfo.samplingRate);
148 EXPECT_EQ(hpaeSinkOutputNode->GetFrameLen(), nodeInfo.frameLen);
149 EXPECT_EQ(hpaeSinkOutputNode->GetChannelCount(), nodeInfo.channels);
150 EXPECT_EQ(hpaeSinkOutputNode->GetBitWidth(), nodeInfo.format);
151 EXPECT_EQ(hpaeSinkOutputNode->GetSessionId(), nodeInfo.sessionId);
152
153 HpaeNodeInfo &retNi = hpaeSinkOutputNode->GetNodeInfo();
154 EXPECT_EQ(retNi.samplingRate, nodeInfo.samplingRate);
155 EXPECT_EQ(retNi.frameLen, nodeInfo.frameLen);
156 EXPECT_EQ(retNi.channels, nodeInfo.channels);
157 EXPECT_EQ(retNi.format, nodeInfo.format);
158 EXPECT_EQ(retNi.sessionId, nodeInfo.sessionId);
159 }
160
TestRendererRenderFrame(const char * data,uint64_t len)161 static int32_t TestRendererRenderFrame(const char *data, uint64_t len)
162 {
163 for (int32_t i = 0; i < len / SAMPLE_F32LE; i++) {
164 float diff = *((float *)data + i) - i;
165 EXPECT_EQ(diff, 0);
166 }
167 return 0;
168 }
169
170 HWTEST_F(HpaeSinkOutputNodeTest, testHpaeSinkOutConnectNode, TestSize.Level0)
171 {
172 size_t usedCount = 2;
173 HpaeNodeInfo nodeInfo;
174 PrepareNodeInfo(nodeInfo);
175 std::shared_ptr<HpaeSinkOutputNode> hpaeSinkOutputNode = std::make_shared<HpaeSinkOutputNode>(nodeInfo);
176 std::shared_ptr<HpaeSinkInputNode> hpaeSinkInputNode = std::make_shared<HpaeSinkInputNode>(nodeInfo);
177 hpaeSinkOutputNode->Connect(hpaeSinkInputNode);
178 std::shared_ptr<WriteIncDataCb> writeIncDataCb = std::make_shared<WriteIncDataCb>(SAMPLE_F32LE);
179 hpaeSinkInputNode->RegisterWriteCallback(writeIncDataCb);
180 std::string deviceClass = "file_io";
181 std::string deviceNetId = "LocalDevice";
182 EXPECT_EQ(hpaeSinkOutputNode->GetRenderSinkInstance(deviceClass, deviceNetId), 0);
183 EXPECT_EQ(hpaeSinkOutputNode->GetSinkState() == STREAM_MANAGER_NEW, true);
184 IAudioSinkAttr attr;
185 attr.adapterName = "file_io";
186 attr.openMicSpeaker = 0;
187 attr.format = nodeInfo.format;
188 attr.sampleRate = nodeInfo.samplingRate;
189 attr.channel = nodeInfo.channels;
190 attr.volume = 0.0f;
191 attr.filePath = ROOT_PATH;
192 attr.deviceNetworkId = deviceNetId.c_str();
193 attr.deviceType = 0;
194 attr.channelLayout = 0;
195 attr.audioStreamFlag = 0;
196
197 EXPECT_EQ(hpaeSinkOutputNode->RenderSinkInit(attr), SUCCESS);
198 EXPECT_EQ(hpaeSinkOutputNode->GetSinkState() == STREAM_MANAGER_IDLE, true);
199 EXPECT_EQ(hpaeSinkOutputNode->RenderSinkStart(), SUCCESS);
200 EXPECT_EQ(hpaeSinkOutputNode->GetSinkState() == STREAM_MANAGER_RUNNING, true);
201 EXPECT_EQ(hpaeSinkOutputNode->RenderSinkPause(), SUCCESS);
202 EXPECT_EQ(hpaeSinkOutputNode->GetSinkState() == STREAM_MANAGER_SUSPENDED, true);
203 EXPECT_EQ(hpaeSinkOutputNode->RenderSinkStop(), SUCCESS);
204 EXPECT_EQ(hpaeSinkOutputNode->GetSinkState() == STREAM_MANAGER_SUSPENDED, true);
205 hpaeSinkOutputNode->DoProcess();
206 TestRendererRenderFrame(hpaeSinkOutputNode->GetRenderFrameData(),
207 nodeInfo.frameLen * nodeInfo.channels * GetSizeFromFormat(nodeInfo.format));
208 EXPECT_EQ(hpaeSinkInputNode.use_count(), usedCount);
209 hpaeSinkOutputNode->DisConnect(hpaeSinkInputNode);
210 EXPECT_EQ(hpaeSinkInputNode.use_count(), 1);
211 hpaeSinkOutputNode->RenderSinkDeInit();
212 }
213
214 HWTEST_F(HpaeSinkOutputNodeTest, testHpaeSinkOutConnectNodeRemote, TestSize.Level0)
215 {
216 size_t usedCount = 2;
217 std::string deviceClass = "remote";
218 std::string deviceNetId = "LocalDevice";
219 HpaeNodeInfo nodeInfo;
220 nodeInfo.deviceClass = deviceClass;
221 PrepareNodeInfo(nodeInfo);
222 std::shared_ptr<HpaeSinkOutputNode> hpaeSinkOutputNode = std::make_shared<HpaeSinkOutputNode>(nodeInfo);
223 std::shared_ptr<HpaeSinkInputNode> hpaeSinkInputNode = std::make_shared<HpaeSinkInputNode>(nodeInfo);
224 hpaeSinkOutputNode->Connect(hpaeSinkInputNode);
225 std::shared_ptr<WriteIncDataCb> writeIncDataCb = std::make_shared<WriteIncDataCb>(SAMPLE_F32LE);
226 hpaeSinkInputNode->RegisterWriteCallback(writeIncDataCb);
227 EXPECT_EQ(hpaeSinkOutputNode->GetRenderSinkInstance(deviceClass, deviceNetId), 0);
228 EXPECT_EQ(hpaeSinkOutputNode->GetSinkState() == STREAM_MANAGER_NEW, true);
229 IAudioSinkAttr attr;
230 attr.adapterName = "file_io";
231 attr.openMicSpeaker = 0;
232 attr.format = nodeInfo.format;
233 attr.sampleRate = nodeInfo.samplingRate;
234 attr.channel = nodeInfo.channels;
235 attr.volume = 0.0f;
236 attr.filePath = ROOT_PATH;
237 attr.deviceNetworkId = deviceNetId.c_str();
238 attr.deviceType = 0;
239 attr.channelLayout = 0;
240 attr.audioStreamFlag = 0;
241
242 hpaeSinkOutputNode->RenderSinkInit(attr);
243 EXPECT_EQ(hpaeSinkOutputNode->GetSinkState() == STREAM_MANAGER_IDLE, true);
244 EXPECT_EQ(hpaeSinkOutputNode->RenderSinkStart(), SUCCESS);
245 EXPECT_EQ(hpaeSinkOutputNode->GetSinkState() == STREAM_MANAGER_RUNNING, true);
246 EXPECT_EQ(hpaeSinkOutputNode->RenderSinkPause(), SUCCESS);
247 EXPECT_EQ(hpaeSinkOutputNode->GetSinkState() == STREAM_MANAGER_SUSPENDED, true);
248 EXPECT_EQ(hpaeSinkOutputNode->RenderSinkStop(), SUCCESS);
249 EXPECT_EQ(hpaeSinkOutputNode->GetSinkState() == STREAM_MANAGER_SUSPENDED, true);
250 hpaeSinkOutputNode->remoteTimePoint_ = std::chrono::high_resolution_clock::now();
251 hpaeSinkOutputNode->DoProcess();
252 TestRendererRenderFrame(hpaeSinkOutputNode->GetRenderFrameData(),
253 nodeInfo.frameLen * nodeInfo.channels * GetSizeFromFormat(nodeInfo.format));
254 EXPECT_EQ(hpaeSinkInputNode.use_count(), usedCount);
255 hpaeSinkOutputNode->DisConnect(hpaeSinkInputNode);
256 EXPECT_EQ(hpaeSinkInputNode.use_count(), 1);
257 hpaeSinkOutputNode->RenderSinkDeInit();
258 }
259
260 HWTEST_F(HpaeSinkOutputNodeTest, testHpaeSinkOutHandlePaPower, TestSize.Level0)
261 {
262 std::string deviceClass = "primary";
263 std::string deviceNetId = "LocalDevice";
264 HpaeNodeInfo nodeInfo;
265 nodeInfo.deviceClass = deviceClass;
266 PrepareNodeInfo(nodeInfo);
267 std::shared_ptr<HpaeSinkOutputNode> hpaeSinkOutputNode = std::make_shared<HpaeSinkOutputNode>(nodeInfo);
268 std::shared_ptr<HpaeSinkInputNode> hpaeSinkInputNode = std::make_shared<HpaeSinkInputNode>(nodeInfo);
269 hpaeSinkOutputNode->Connect(hpaeSinkInputNode);
270 std::shared_ptr<WriteIncDataCb> writeIncDataCb = std::make_shared<WriteIncDataCb>(SAMPLE_F32LE);
271 hpaeSinkInputNode->RegisterWriteCallback(writeIncDataCb);
272 EXPECT_EQ(hpaeSinkOutputNode->GetRenderSinkInstance(deviceClass, deviceNetId), 0);
273 EXPECT_EQ(hpaeSinkOutputNode->GetSinkState() == STREAM_MANAGER_NEW, true);
274 IAudioSinkAttr attr;
275 attr.adapterName = "primary";
276 attr.openMicSpeaker = 0;
277 attr.format = nodeInfo.format;
278 attr.sampleRate = nodeInfo.samplingRate;
279 attr.channel = nodeInfo.channels;
280 attr.volume = 0.0f;
281 attr.filePath = ROOT_PATH;
282 attr.deviceNetworkId = deviceNetId.c_str();
283 attr.deviceType = 0;
284 attr.channelLayout = 0;
285 attr.audioStreamFlag = 0;
286
287 hpaeSinkOutputNode->RenderSinkInit(attr);
288 EXPECT_EQ(hpaeSinkOutputNode->GetSinkState() == STREAM_MANAGER_IDLE, true);
289 EXPECT_EQ(hpaeSinkOutputNode->RenderSinkStart(), SUCCESS);
290 EXPECT_EQ(hpaeSinkOutputNode->GetSinkState() == STREAM_MANAGER_RUNNING, true);
291 EXPECT_EQ(hpaeSinkOutputNode->RenderSinkPause(), SUCCESS);
292 EXPECT_EQ(hpaeSinkOutputNode->GetSinkState() == STREAM_MANAGER_SUSPENDED, true);
293 EXPECT_EQ(hpaeSinkOutputNode->RenderSinkStop(), SUCCESS);
294 EXPECT_EQ(hpaeSinkOutputNode->GetSinkState() == STREAM_MANAGER_SUSPENDED, true);
295 std::vector<HpaePcmBuffer *> &outputVec = hpaeSinkOutputNode->inputStream_.ReadPreOutputData();
296 EXPECT_FALSE(outputVec.empty());
297 HpaePcmBuffer *outputData = outputVec.front();
298 outputData->pcmBufferInfo_.state = PCM_BUFFER_STATE_SILENCE;
299 hpaeSinkOutputNode->isOpenPaPower_ = false;
300 hpaeSinkOutputNode->silenceDataUs_ = 500000000; // 500000000 us, long silence time
301 hpaeSinkOutputNode->HandlePaPower(outputData);
302 hpaeSinkOutputNode->RenderSinkDeInit();
303 }
304
305 HWTEST_F(HpaeSinkOutputNodeTest, testHpaeSinkOutHandlePaPower2, TestSize.Level0)
306 {
307 PcmBufferInfo bufferInfo = { 2, 960, 48000 }; // 2 channel, 960 framelen, 48000 sampleRate
308 std::shared_ptr<HpaePcmBuffer> outputData = std::make_shared<HpaePcmBuffer>(bufferInfo);
309 outputData->pcmBufferInfo_.state = PCM_BUFFER_STATE_SILENCE;
310
311 uint32_t sessionId = 10001; // default sessionID
312 HpaeNodeInfo nodeInfo;
313 PrepareNodeInfo(nodeInfo);
314 nodeInfo.sessionId = sessionId;
315 nodeInfo.deviceClass = "primary"; // primary set pa power
316 auto hpaeSinkOutputNode = std::make_shared<HpaeSinkOutputNode>(nodeInfo);
317 auto mockSink = std::make_shared<MockAudioRenderSink>();
318 hpaeSinkOutputNode->audioRendererSink_ = mockSink;
319 hpaeSinkOutputNode->isOpenPaPower_ = true;
320 hpaeSinkOutputNode->silenceDataUs_ = 500000000; // 500000000 us, long silence time
321
322 EXPECT_CALL(*mockSink, GetAudioScene())
323 .WillOnce(Return(0))
324 .WillOnce(Return(1));
325 EXPECT_CALL(*mockSink, SetPaPower(false))
326 .WillOnce(Return(0));
327 hpaeSinkOutputNode->HandlePaPower(outputData.get());
328
329 hpaeSinkOutputNode->isOpenPaPower_ = true;
330 hpaeSinkOutputNode->silenceDataUs_ = 500000000; // 500000000 us, long silence time
331 hpaeSinkOutputNode->HandlePaPower(outputData.get());
332 }
333
334 #ifdef ENABLE_HOOK_PCM
335 HWTEST_F(HpaeSinkOutputNodeTest, testDoProcessAfterResetPcmDumper, TestSize.Level0)
336 {
337 HpaeNodeInfo nodeInfo;
338 std::string deviceClass = "remote";
339 std::string deviceNetId = "LocalDevice";
340 nodeInfo.deviceClass = deviceClass;
341 PrepareNodeInfo(nodeInfo);
342 std::shared_ptr<HpaeSinkOutputNode> hpaeSinkOutputNode = std::make_shared<HpaeSinkOutputNode>(nodeInfo);
343 std::shared_ptr<HpaeSinkInputNode> hpaeSinkInputNode = std::make_shared<HpaeSinkInputNode>(nodeInfo);
344 hpaeSinkOutputNode->Connect(hpaeSinkInputNode);
345 std::shared_ptr<WriteIncDataCb> writeIncDataCb = std::make_shared<WriteIncDataCb>(SAMPLE_F32LE);
346 hpaeSinkInputNode->RegisterWriteCallback(writeIncDataCb);
347
348 EXPECT_EQ(hpaeSinkOutputNode->GetRenderSinkInstance(deviceClass, deviceNetId), SUCCESS);
349 EXPECT_EQ(hpaeSinkOutputNode->GetSinkState() == STREAM_MANAGER_NEW, true);
350
351 IAudioSinkAttr attr;
352 attr.adapterName = "file_io";
353 attr.openMicSpeaker = 0;
354 attr.format = nodeInfo.format;
355 attr.sampleRate = nodeInfo.samplingRate;
356 attr.channel = nodeInfo.channels;
357 attr.volume = 0.0f;
358 attr.filePath = ROOT_PATH;
359 attr.deviceNetworkId = deviceNetId.c_str();
360 attr.deviceType = 0;
361 attr.channelLayout = 0;
362 attr.audioStreamFlag = 0;
363 hpaeSinkOutputNode->RenderSinkInit(attr);
364 hpaeSinkOutputNode->RenderSinkStart();
365 hpaeSinkOutputNode->DoProcess();
366 hpaeSinkOutputNode->RenderSinkDeInit();
367 }
368 #endif
369
370 HWTEST_F(HpaeSinkOutputNodeTest, testHpaeSinkOutHandleHapticParam, TestSize.Level0)
371 {
372 size_t usedCount = 2;
373 HpaeNodeInfo nodeInfo;
374 PrepareNodeInfo(nodeInfo);
375 std::shared_ptr<HpaeSinkOutputNode> hpaeSinkOutputNode = std::make_shared<HpaeSinkOutputNode>(nodeInfo);
376 std::shared_ptr<HpaeSinkInputNode> hpaeSinkInputNode = std::make_shared<HpaeSinkInputNode>(nodeInfo);
377 hpaeSinkOutputNode->Connect(hpaeSinkInputNode);
378 std::shared_ptr<WriteIncDataCb> writeIncDataCb = std::make_shared<WriteIncDataCb>(SAMPLE_F32LE);
379 hpaeSinkInputNode->RegisterWriteCallback(writeIncDataCb);
380 std::string deviceClass = "file_io";
381 std::string deviceNetId = "LocalDevice";
382 EXPECT_EQ(hpaeSinkOutputNode->GetRenderSinkInstance(deviceClass, deviceNetId), 0);
383 EXPECT_EQ(hpaeSinkOutputNode->GetSinkState() == STREAM_MANAGER_NEW, true);
384 IAudioSinkAttr attr;
385 attr.adapterName = "file_io";
386 attr.openMicSpeaker = 0;
387 attr.format = nodeInfo.format;
388 attr.sampleRate = nodeInfo.samplingRate;
389 attr.channel = nodeInfo.channels;
390 attr.volume = 0.0f;
391 attr.filePath = ROOT_PATH;
392 attr.deviceNetworkId = deviceNetId.c_str();
393 attr.deviceType = 0;
394 attr.channelLayout = 0;
395 attr.audioStreamFlag = 0;
396 int32_t syncId = 123;
397
398 EXPECT_EQ(hpaeSinkOutputNode->RenderSinkInit(attr), SUCCESS);
399 EXPECT_EQ(hpaeSinkOutputNode->GetSinkState() == STREAM_MANAGER_IDLE, true);
400 EXPECT_EQ(hpaeSinkOutputNode->RenderSinkStart(), SUCCESS);
401 EXPECT_EQ(hpaeSinkOutputNode->GetSinkState() == STREAM_MANAGER_RUNNING, true);
402 EXPECT_EQ(hpaeSinkOutputNode->RenderSinkPause(), SUCCESS);
403 EXPECT_EQ(hpaeSinkOutputNode->GetSinkState() == STREAM_MANAGER_SUSPENDED, true);
404 EXPECT_EQ(hpaeSinkOutputNode->RenderSinkStop(), SUCCESS);
405 EXPECT_EQ(hpaeSinkOutputNode->GetSinkState() == STREAM_MANAGER_SUSPENDED, true);
406 EXPECT_EQ(hpaeSinkOutputNode->RenderSinkSetSyncId(syncId), SUCCESS);
407 hpaeSinkOutputNode->DoProcess();
408 TestRendererRenderFrame(hpaeSinkOutputNode->GetRenderFrameData(),
409 nodeInfo.frameLen * nodeInfo.channels * GetSizeFromFormat(nodeInfo.format));
410 EXPECT_EQ(hpaeSinkInputNode.use_count(), usedCount);
411 hpaeSinkOutputNode->DisConnect(hpaeSinkInputNode);
412 EXPECT_EQ(hpaeSinkInputNode.use_count(), 1);
413 hpaeSinkOutputNode->RenderSinkDeInit();
414 }
415 } // namespace HPAE
416 } // namespace AudioStandard
417 } // namespace OHOS