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 #ifndef LOG_TAG
17 #define LOG_TAG "HpaeSourceInputNode"
18 #endif
19
20 #include <cinttypes>
21 #include "hpae_source_input_node.h"
22 #include "hpae_format_convert.h"
23 #include "hpae_node_common.h"
24 #include "audio_errors.h"
25 #include "audio_utils.h"
26 #include "capturer_clock_manager.h"
27 #include "audio_engine_log.h"
28
29 #define BYTE_SIZE_SAMPLE_U8 1
30 #define BYTE_SIZE_SAMPLE_S16 2
31 #define BYTE_SIZE_SAMPLE_S24 3
32 #define BYTE_SIZE_SAMPLE_S32 4
33 #define FRAME_DURATION_DEFAULT 20
34 #define MILLISECOND_PER_SECOND 1000
35
36 namespace OHOS {
37 namespace AudioStandard {
38 namespace HPAE {
TransSourceBufferTypeToString(const HpaeSourceBufferType & type)39 static std::string TransSourceBufferTypeToString(const HpaeSourceBufferType &type)
40 {
41 if (type == HPAE_SOURCE_BUFFER_TYPE_MIC) {
42 return "MIC";
43 } else if (type == HPAE_SOURCE_BUFFER_TYPE_EC) {
44 return "EC";
45 } else if (type == HPAE_SOURCE_BUFFER_TYPE_MICREF) {
46 return "MICREF";
47 }
48 return "DEFAULT";
49 }
50
HpaeSourceInputNode(HpaeNodeInfo & nodeInfo)51 HpaeSourceInputNode::HpaeSourceInputNode(HpaeNodeInfo &nodeInfo)
52 : HpaeNode(nodeInfo), sourceInputNodeType_(nodeInfo.sourceInputNodeType)
53 {
54 HpaeSourceBufferType sourceBufferType = nodeInfo.sourceBufferType;
55 nodeInfoMap_.emplace(sourceBufferType, nodeInfo);
56 pcmBufferInfoMap_.emplace(
57 sourceBufferType, PcmBufferInfo(nodeInfo.channels, nodeInfo.frameLen, nodeInfo.samplingRate));
58 inputAudioBufferMap_.emplace(sourceBufferType, HpaePcmBuffer(pcmBufferInfoMap_.at(sourceBufferType)));
59 inputAudioBufferMap_.at(sourceBufferType).SetSourceBufferType(sourceBufferType);
60 frameByteSizeMap_.emplace(
61 sourceBufferType, nodeInfo.frameLen * nodeInfo.channels * GetSizeFromFormat(nodeInfo.format));
62 nodeInfoMap_[sourceBufferType].frameLen = FRAME_DURATION_DEFAULT * nodeInfo.samplingRate / MILLISECOND_PER_SECOND;
63 capturerFrameDataMap_.emplace(sourceBufferType, frameByteSizeMap_.at(sourceBufferType));
64 outputStreamMap_.emplace(sourceBufferType, this);
65 historyDataMap_.emplace(sourceBufferType, 0);
66 historyRemainSizeMap_.emplace(sourceBufferType, 0);
67 if (sourceInputNodeType_ == HPAE_SOURCE_EC) {
68 fdescMap_.emplace(sourceBufferType,
69 FrameDesc{capturerFrameDataMap_.at(sourceBufferType).data(), frameByteSizeMap_.at(sourceBufferType)});
70 fdescMap_.emplace(HPAE_SOURCE_BUFFER_TYPE_DEFAULT, FrameDesc{nullptr, 0});
71 }
72 #ifdef ENABLE_HIDUMP_DFX
73 SetNodeName("hpaeSourceInputNode[" + TransSourceBufferTypeToString(nodeInfo.sourceBufferType) + "]");
74 if (auto callback = GetNodeStatusCallback().lock()) {
75 callback->OnNotifyDfxNodeInfo(true, 0, GetNodeInfo());
76 }
77 #endif
78 }
79
HpaeSourceInputNode(std::vector<HpaeNodeInfo> & nodeInfos)80 HpaeSourceInputNode::HpaeSourceInputNode(std::vector<HpaeNodeInfo> &nodeInfos)
81 : HpaeNode(*nodeInfos.begin()), sourceInputNodeType_((*nodeInfos.begin()).sourceInputNodeType)
82 {
83 for (auto nodeInfo : nodeInfos) {
84 HpaeSourceBufferType sourceBufferType = nodeInfo.sourceBufferType;
85 nodeInfoMap_.emplace(sourceBufferType, nodeInfo);
86 pcmBufferInfoMap_.emplace(
87 sourceBufferType, PcmBufferInfo(nodeInfo.channels, nodeInfo.frameLen, nodeInfo.samplingRate));
88 inputAudioBufferMap_.emplace(sourceBufferType, HpaePcmBuffer(pcmBufferInfoMap_.at(sourceBufferType)));
89 inputAudioBufferMap_.at(sourceBufferType).SetSourceBufferType(sourceBufferType);
90 frameByteSizeMap_.emplace(
91 sourceBufferType, nodeInfo.frameLen * nodeInfo.channels * GetSizeFromFormat(nodeInfo.format));
92 nodeInfoMap_[sourceBufferType].frameLen =
93 FRAME_DURATION_DEFAULT * nodeInfo.samplingRate / MILLISECOND_PER_SECOND;
94 capturerFrameDataMap_.emplace(sourceBufferType, frameByteSizeMap_.at(sourceBufferType));
95 fdescMap_.emplace(sourceBufferType,
96 FrameDesc{capturerFrameDataMap_.at(sourceBufferType).data(), frameByteSizeMap_.at(sourceBufferType)});
97 outputStreamMap_.emplace(sourceBufferType, this);
98 historyDataMap_.emplace(sourceBufferType, frameByteSizeMap_.at(sourceBufferType));
99 if (historyDataMap_.find(sourceBufferType) != historyDataMap_.end()) {
100 historyDataMap_.at(sourceBufferType).resize(0);
101 }
102 }
103 #ifdef ENABLE_HIDUMP_DFX
104 SetNodeName("hpaeSourceInputNode[MIC_EC]");
105 if (auto callback = GetNodeStatusCallback().lock()) {
106 callback->OnNotifyDfxNodeInfo(true, 0, GetNodeInfo());
107 }
108 #endif
109 }
110
~HpaeSourceInputNode()111 HpaeSourceInputNode::~HpaeSourceInputNode()
112 {
113 #ifdef ENABLE_HIDUMP_DFX
114 AUDIO_INFO_LOG("NodeId: %{public}u NodeName: %{public}s destructed.",
115 GetNodeId(), GetNodeName().c_str());
116 #endif
117 }
118
SetBufferValid(const HpaeSourceBufferType & bufferType,const uint64_t & replyBytes)119 void HpaeSourceInputNode::SetBufferValid(const HpaeSourceBufferType &bufferType, const uint64_t &replyBytes)
120 {
121 CHECK_AND_RETURN_LOG(inputAudioBufferMap_.find(bufferType) != inputAudioBufferMap_.end(),
122 "set buffer valid with error type");
123 inputAudioBufferMap_.at(bufferType).SetBufferValid(true);
124 uint32_t byteSize = nodeInfoMap_.at(bufferType).channels * nodeInfoMap_.at(bufferType).frameLen *
125 static_cast<uint32_t>(GetSizeFromFormat(nodeInfoMap_.at(bufferType).format));
126 if (replyBytes != byteSize) {
127 AUDIO_WARNING_LOG("DoProcess(), request size[%{public}zu][%{public}u], reply size[%{public}" PRIu64 "]",
128 frameByteSizeMap_.at(bufferType), byteSize, replyBytes);
129 AUDIO_WARNING_LOG("DoProcess(), if reply != request, just drop now");
130 inputAudioBufferMap_.at(bufferType).SetBufferValid(false);
131 }
132 }
133
DoProcessInner(const HpaeSourceBufferType & bufferType,const uint64_t & replyBytes)134 void HpaeSourceInputNode::DoProcessInner(const HpaeSourceBufferType &bufferType, const uint64_t &replyBytes)
135 {
136 AUDIO_DEBUG_LOG("DoProcessInner, replyBytes: %{public}" PRIu64, replyBytes);
137 // todo: do not convert to float in SourceInputNode
138 ConvertToFloat(nodeInfoMap_.at(bufferType).format,
139 nodeInfoMap_.at(bufferType).channels * nodeInfoMap_.at(bufferType).frameLen,
140 capturerFrameDataMap_.at(bufferType).data(),
141 inputAudioBufferMap_.at(bufferType).GetPcmDataBuffer());
142 if (inputAudioBufferMap_.at(bufferType).IsValid()) {
143 outputStreamMap_.at(bufferType).WriteDataToOutput(&inputAudioBufferMap_.at(bufferType));
144 }
145 }
146
147 #ifdef IS_EMULATOR
DoProcessMicInner(const HpaeSourceBufferType & bufferType,const uint64_t & replyBytes)148 void HpaeSourceInputNode::DoProcessMicInner(const HpaeSourceBufferType &bufferType, const uint64_t &replyBytes)
149 {
150 AUDIO_DEBUG_LOG("DoProcessMicInner, replyBytes: %{public}" PRIu64, replyBytes);
151 auto &historyData = historyDataMap_.at(bufferType);
152 uint32_t byteSize = nodeInfoMap_.at(bufferType).channels * nodeInfoMap_.at(bufferType).frameLen *
153 static_cast<uint32_t>(GetSizeFromFormat(nodeInfoMap_.at(bufferType).format));
154
155 // todo: do not convert to float in SourceInputNode
156 ConvertToFloat(nodeInfoMap_.at(bufferType).format,
157 nodeInfoMap_.at(bufferType).channels * nodeInfoMap_.at(bufferType).frameLen,
158 historyData.data() + historyData.size() - historyRemainSizeMap_.at(bufferType),
159 inputAudioBufferMap_.at(bufferType).GetPcmDataBuffer());
160 historyRemainSizeMap_[bufferType] -= byteSize;
161 outputStreamMap_.at(bufferType).WriteDataToOutput(&inputAudioBufferMap_.at(bufferType));
162 }
163
DoProcess()164 void HpaeSourceInputNode::DoProcess()
165 {
166 Trace trace("[" + std::to_string(GetNodeId()) + "]HpaeSourceInputNode::DoProcess " + GetTraceInfo());
167 CHECK_AND_RETURN_LOG(audioCapturerSource_ != nullptr,
168 "audioCapturerSource_ is nullptr NodeId: %{public}u", GetNodeId());
169 uint64_t replyBytes = 0;
170 if (sourceInputNodeType_ == HpaeSourceInputNodeType::HPAE_SOURCE_MIC_EC) {
171 uint64_t replyBytesEc = 0;
172 audioCapturerSource_->CaptureFrameWithEc(&fdescMap_.at(HPAE_SOURCE_BUFFER_TYPE_MIC), replyBytes,
173 &fdescMap_.at(HPAE_SOURCE_BUFFER_TYPE_EC), replyBytesEc);
174 SetBufferValid(HPAE_SOURCE_BUFFER_TYPE_MIC, replyBytes);
175 DoProcessInner(HPAE_SOURCE_BUFFER_TYPE_MIC, replyBytes);
176 DoProcessInner(HPAE_SOURCE_BUFFER_TYPE_EC, replyBytesEc);
177 } else {
178 HpaeSourceBufferType sourceBufferType = nodeInfoMap_.begin()->second.sourceBufferType;
179 uint32_t byteSize = nodeInfoMap_.at(sourceBufferType).channels * nodeInfoMap_.at(sourceBufferType).frameLen *
180 static_cast<uint32_t>(GetSizeFromFormat(nodeInfoMap_.at(sourceBufferType).format));
181 auto &historyData = historyDataMap_.at(sourceBufferType);
182 while (historyRemainSizeMap_[sourceBufferType] < byteSize) {
183 if (historyRemainSizeMap_[sourceBufferType] > 0) {
184 historyData.erase(historyData.begin(), historyData.begin() + historyData.size() -
185 historyRemainSizeMap_[sourceBufferType]);
186 }
187 audioCapturerSource_->CaptureFrame(capturerFrameDataMap_.at(sourceBufferType).data(),
188 (uint64_t)frameByteSizeMap_.at(sourceBufferType), replyBytes);
189 CHECK_AND_RETURN_LOG(replyBytes != 0, "replyBytes is 0");
190 auto newData = capturerFrameDataMap_.at(sourceBufferType).data();
191 historyData.insert(historyData.end(), newData, newData + replyBytes);
192 historyRemainSizeMap_[sourceBufferType] += replyBytes;
193 }
194 DoProcessMicInner(sourceBufferType, replyBytes);
195 }
196 }
197
198 #else
DoProcessMicInner(const HpaeSourceBufferType & bufferType,const uint64_t & replyBytes)199 void HpaeSourceInputNode::DoProcessMicInner(const HpaeSourceBufferType &bufferType, const uint64_t &replyBytes)
200 {
201 AUDIO_DEBUG_LOG("DoProcessMicInner, replyBytes: %{public}" PRIu64, replyBytes);
202
203 auto &historyData = historyDataMap_.at(bufferType);
204 const char *newData = capturerFrameDataMap_.at(bufferType).data();
205 size_t remainCapacity = frameByteSizeMap_.at(bufferType) - historyData.size();
206
207 size_t appendSize = std::min<size_t>(replyBytes, remainCapacity);
208 historyData.insert(historyData.end(), newData, newData + appendSize);
209 uint32_t byteSize = nodeInfoMap_.at(bufferType).channels * nodeInfoMap_.at(bufferType).frameLen *
210 static_cast<uint32_t>(GetSizeFromFormat(nodeInfoMap_.at(bufferType).format));
211 if (replyBytes != byteSize && historyData.size() < frameByteSizeMap_.at(bufferType)) {
212 // replyBytes == byteSize should send data right now, else cached history
213 AUDIO_DEBUG_LOG("Partial frame accumulated: %{public}zu/%{public}zu",
214 historyData.size(), frameByteSizeMap_.at(bufferType));
215 return;
216 }
217
218 // todo: do not convert to float in SourceInputNode
219 ConvertToFloat(nodeInfoMap_.at(bufferType).format,
220 nodeInfoMap_.at(bufferType).channels * nodeInfoMap_.at(bufferType).frameLen,
221 historyData.data(),
222 inputAudioBufferMap_.at(bufferType).GetPcmDataBuffer());
223 outputStreamMap_.at(bufferType).WriteDataToOutput(&inputAudioBufferMap_.at(bufferType));
224
225 if (appendSize < replyBytes) {
226 historyData.assign(newData + appendSize, newData + replyBytes);
227 } else {
228 historyData.clear();
229 }
230 }
231
CheckEcAndMicRefReplyValid(const uint64_t & requestBytes,const uint64_t replyBytes)232 static bool CheckEcAndMicRefReplyValid(const uint64_t &requestBytes, const uint64_t replyBytes)
233 {
234 return replyBytes != 0 && requestBytes == replyBytes;
235 }
236
DoProcess()237 void HpaeSourceInputNode::DoProcess()
238 {
239 Trace trace("[" + std::to_string(GetNodeId()) + "]HpaeSourceInputNode::DoProcess " + GetTraceInfo());
240 CHECK_AND_RETURN_LOG(audioCapturerSource_ != nullptr,
241 "audioCapturerSource_ is nullptr NodeId: %{public}u", GetNodeId());
242 uint64_t replyBytes = 0;
243 if (sourceInputNodeType_ == HpaeSourceInputNodeType::HPAE_SOURCE_MIC_EC) {
244 uint64_t replyBytesEc = 0;
245 audioCapturerSource_->CaptureFrameWithEc(&fdescMap_.at(HPAE_SOURCE_BUFFER_TYPE_MIC), replyBytes,
246 &fdescMap_.at(HPAE_SOURCE_BUFFER_TYPE_EC), replyBytesEc);
247 DoProcessMicInner(HPAE_SOURCE_BUFFER_TYPE_MIC, replyBytes);
248 CHECK_AND_RETURN_LOG(
249 CheckEcAndMicRefReplyValid(frameByteSizeMap_.at(HPAE_SOURCE_BUFFER_TYPE_EC), replyBytesEc),
250 "same ec request != reply");
251 DoProcessInner(HPAE_SOURCE_BUFFER_TYPE_EC, replyBytesEc);
252 } else {
253 HpaeSourceBufferType sourceBufferType = nodeInfoMap_.begin()->second.sourceBufferType;
254 if (sourceInputNodeType_ == HPAE_SOURCE_EC) {
255 uint64_t replyBytesUnused = 0;
256 audioCapturerSource_->CaptureFrameWithEc(&fdescMap_.at(HPAE_SOURCE_BUFFER_TYPE_DEFAULT), replyBytesUnused,
257 &fdescMap_.at(HPAE_SOURCE_BUFFER_TYPE_EC), replyBytes);
258 } else {
259 audioCapturerSource_->CaptureFrame(capturerFrameDataMap_.at(sourceBufferType).data(),
260 (uint64_t)frameByteSizeMap_.at(sourceBufferType), replyBytes);
261 }
262
263 if (sourceInputNodeType_ == HPAE_SOURCE_MIC) {
264 DoProcessMicInner(sourceBufferType, replyBytes);
265 } else {
266 CHECK_AND_RETURN_LOG(CheckEcAndMicRefReplyValid(frameByteSizeMap_.at(sourceBufferType), replyBytes),
267 "request != reply");
268 DoProcessInner(sourceBufferType, replyBytes);
269 }
270 }
271 }
272 #endif
273
WriteCapturerData(char * data,int32_t dataSize)274 int32_t HpaeSourceInputNode::WriteCapturerData(char *data, int32_t dataSize)
275 {
276 auto itCapturerFrameData = capturerFrameDataMap_.begin();
277 auto itFrameByteSize = frameByteSizeMap_.begin();
278 CHECK_AND_RETURN_RET_LOG(
279 itCapturerFrameData != capturerFrameDataMap_.end() && itFrameByteSize != frameByteSizeMap_.end(),
280 ERROR, "outStreamMap_ is empty.");
281 int32_t ret = memcpy_s(itCapturerFrameData->second.data(), itFrameByteSize->second, data, dataSize);
282 CHECK_AND_RETURN_RET_LOG(ret == 0, ret, "memcpy error when WriteCapturerData");
283 return 0;
284 }
285
Reset()286 bool HpaeSourceInputNode::Reset()
287 {
288 return true;
289 }
290
ResetAll()291 bool HpaeSourceInputNode::ResetAll()
292 {
293 return true;
294 }
295
GetSharedInstance()296 std::shared_ptr<HpaeNode> HpaeSourceInputNode::GetSharedInstance()
297 {
298 return shared_from_this();
299 }
300
GetOutputPort()301 OutputPort<HpaePcmBuffer *> *HpaeSourceInputNode::GetOutputPort()
302 {
303 std::unordered_map<HpaeSourceBufferType, OutputPort<HpaePcmBuffer *>>::iterator it;
304 if (sourceInputNodeType_ != HPAE_SOURCE_MIC_EC) {
305 it = outputStreamMap_.begin();
306 } else {
307 it = outputStreamMap_.find(HPAE_SOURCE_BUFFER_TYPE_MIC);
308 }
309 CHECK_AND_RETURN_RET_LOG(it != outputStreamMap_.end(), nullptr, "outStreamMap_ is empty.");
310 return &(it->second);
311 }
312
GetOutputPort(HpaeNodeInfo & nodeInfo,bool isDisConnect)313 OutputPort<HpaePcmBuffer *> *HpaeSourceInputNode::GetOutputPort(HpaeNodeInfo &nodeInfo, bool isDisConnect)
314 {
315 auto it = outputStreamMap_.find(nodeInfo.sourceBufferType);
316 CHECK_AND_RETURN_RET_LOG(it != outputStreamMap_.end(), nullptr,
317 "can't find nodeKey in outStreamMap_, sourceBufferType = %{public}d.\n",
318 nodeInfo.sourceBufferType);
319 return &(it->second);
320 }
321
GetOutputPortBufferType(HpaeNodeInfo & nodeInfo)322 HpaeSourceBufferType HpaeSourceInputNode::GetOutputPortBufferType(HpaeNodeInfo &nodeInfo)
323 {
324 auto it = outputStreamMap_.find(nodeInfo.sourceBufferType);
325 CHECK_AND_RETURN_RET_LOG(it != outputStreamMap_.end(), HPAE_SOURCE_BUFFER_TYPE_DEFAULT,
326 "can't find nodeKey in outStreamMap_, sourceBufferType = %{public}d.\n", nodeInfo.sourceBufferType);
327 // todo: rewrite this function
328 if (sourceInputNodeType_ == HpaeSourceInputNodeType::HPAE_SOURCE_MIC_EC) {
329 if (nodeInfo.sourceBufferType == HPAE_SOURCE_BUFFER_TYPE_MIC) {
330 return HPAE_SOURCE_BUFFER_TYPE_MIC;
331 } else {
332 return HPAE_SOURCE_BUFFER_TYPE_EC;
333 }
334 } else {
335 return inputAudioBufferMap_.at(nodeInfo.sourceBufferType).GetSourceBufferType();
336 }
337 }
338
GetCapturerSourceAdapter(const std::string & deviceClass,const SourceType & sourceType,const std::string & info)339 int32_t HpaeSourceInputNode::GetCapturerSourceAdapter(
340 const std::string &deviceClass, const SourceType &sourceType, const std::string &info)
341 {
342 captureId_ = HDI_INVALID_ID;
343 if (info.empty()) {
344 captureId_ = HdiAdapterManager::GetInstance().GetCaptureIdByDeviceClass(
345 deviceClass, sourceType, HDI_ID_INFO_DEFAULT, true);
346 } else {
347 captureId_ = HdiAdapterManager::GetInstance().GetCaptureIdByDeviceClass(
348 deviceClass, sourceType, info, true);
349 }
350 audioCapturerSource_ = HdiAdapterManager::GetInstance().GetCaptureSource(captureId_, true);
351 if (audioCapturerSource_ == nullptr) {
352 AUDIO_ERR_LOG("get source fail, deviceClass: %{public}s, info: %{public}s, captureId_: %{public}u",
353 deviceClass.c_str(), info.c_str(), captureId_);
354 HdiAdapterManager::GetInstance().ReleaseId(captureId_);
355 return ERROR;
356 }
357 return SUCCESS;
358 }
359
GetCapturerSourceInstance(const std::string & deviceClass,const std::string & deviceNetId,const SourceType & sourceType,const std::string & sourceName)360 int32_t HpaeSourceInputNode::GetCapturerSourceInstance(const std::string &deviceClass, const std::string &deviceNetId,
361 const SourceType &sourceType, const std::string &sourceName)
362 {
363 if (sourceType == SOURCE_TYPE_WAKEUP || sourceName == HDI_ID_INFO_EC || sourceName == HDI_ID_INFO_MIC_REF) {
364 return GetCapturerSourceAdapter(deviceClass, sourceType, sourceName);
365 }
366 return GetCapturerSourceAdapter(deviceClass, sourceType, deviceNetId);
367 }
368
CapturerSourceInit(IAudioSourceAttr & attr)369 int32_t HpaeSourceInputNode::CapturerSourceInit(IAudioSourceAttr &attr)
370 {
371 CHECK_AND_RETURN_RET_LOG(audioCapturerSource_ != nullptr && captureId_ != HDI_INVALID_ID,
372 ERROR, "invalid audioCapturerSource");
373 Trace trace("HpaeSourceInputNode::CapturerSourceInit");
374 if (audioCapturerSource_->IsInited()) {
375 SetSourceState(STREAM_MANAGER_IDLE);
376 #ifdef IS_EMULATOR
377 AUDIO_INFO_LOG("do start and stop");
378 if (sourceInputNodeType_ == HPAE_SOURCE_MIC || sourceInputNodeType_ == HPAE_SOURCE_MIC_EC) {
379 audioCapturerSource_->Start();
380 audioCapturerSource_->Stop();
381 }
382 #endif
383 return SUCCESS;
384 }
385
386 audioSourceAttr_ = attr;
387 CHECK_AND_RETURN_RET_LOG(audioCapturerSource_->Init(attr) == SUCCESS, ERROR, "Source init fail");
388 SetSourceState(STREAM_MANAGER_IDLE);
389 #ifdef IS_EMULATOR
390 // Due to the peculiar implementation of the emulator's HDI,
391 // an initial start and stop sequence is required to circumvent protential issues and ensure proper functionality.
392 AUDIO_INFO_LOG("do start and stop");
393 if (sourceInputNodeType_ == HPAE_SOURCE_MIC || sourceInputNodeType_ == HPAE_SOURCE_MIC_EC) {
394 audioCapturerSource_->Start();
395 audioCapturerSource_->Stop();
396 }
397 #endif
398 return SUCCESS;
399 }
400
CapturerSourceDeInit()401 int32_t HpaeSourceInputNode::CapturerSourceDeInit()
402 {
403 CHECK_AND_RETURN_RET_LOG(audioCapturerSource_ != nullptr && captureId_ != HDI_INVALID_ID,
404 ERROR, "invalid audioCapturerSource");
405 CHECK_AND_RETURN_RET_LOG(audioCapturerSource_->IsInited(), ERROR, "invalid source state");
406 Trace trace("HpaeSourceInputNode::CapturerSourceDeInit");
407 audioCapturerSource_->DeInit();
408 audioCapturerSource_ = nullptr;
409 HdiAdapterManager::GetInstance().ReleaseId(captureId_);
410 return SUCCESS;
411 }
412
CapturerSourceFlush(void)413 int32_t HpaeSourceInputNode::CapturerSourceFlush(void)
414 {
415 CHECK_AND_RETURN_RET_LOG(audioCapturerSource_ != nullptr && captureId_ != HDI_INVALID_ID,
416 ERROR, "invalid audioCapturerSource");
417 CHECK_AND_RETURN_RET_LOG(audioCapturerSource_->IsInited(), ERROR, "invalid source state");
418 return audioCapturerSource_->Flush();
419 }
420
CapturerSourcePause(void)421 int32_t HpaeSourceInputNode::CapturerSourcePause(void)
422 {
423 CHECK_AND_RETURN_RET_LOG(audioCapturerSource_ != nullptr && captureId_ != HDI_INVALID_ID,
424 ERROR, "invalid audioCapturerSource");
425 CHECK_AND_RETURN_RET_LOG(audioCapturerSource_->IsInited(), ERROR, "invalid source state");
426 CHECK_AND_RETURN_RET_LOG(audioCapturerSource_->Pause() == SUCCESS, ERROR, "Source pause fail");
427 SetSourceState(STREAM_MANAGER_SUSPENDED);
428 return SUCCESS;
429 }
430
CapturerSourceReset(void)431 int32_t HpaeSourceInputNode::CapturerSourceReset(void)
432 {
433 CHECK_AND_RETURN_RET_LOG(audioCapturerSource_ != nullptr && captureId_ != HDI_INVALID_ID,
434 ERROR, "invalid audioCapturerSource");
435 return audioCapturerSource_->Reset();
436 }
437
CapturerSourceResume(void)438 int32_t HpaeSourceInputNode::CapturerSourceResume(void)
439 {
440 CHECK_AND_RETURN_RET_LOG(audioCapturerSource_ != nullptr && captureId_ != HDI_INVALID_ID,
441 ERROR, "invalid audioCapturerSource");
442 CHECK_AND_RETURN_RET_LOG(audioCapturerSource_->Resume() == SUCCESS, ERROR, "Source resume fail");
443 SetSourceState(STREAM_MANAGER_RUNNING);
444 return SUCCESS;
445 }
446
CapturerSourceStart(void)447 int32_t HpaeSourceInputNode::CapturerSourceStart(void)
448 {
449 CHECK_AND_RETURN_RET_LOG(audioCapturerSource_ != nullptr && captureId_ != HDI_INVALID_ID,
450 ERROR, "invalid audioCapturerSource");
451 CHECK_AND_RETURN_RET_LOG(audioCapturerSource_->IsInited(), ERROR, "invalid source state");
452 Trace trace("HpaeSourceInputNode::CapturerSourceStart");
453 CHECK_AND_RETURN_RET_LOG(audioCapturerSource_->Start() == SUCCESS, ERROR, "Source start fail");
454 SetSourceState(STREAM_MANAGER_RUNNING);
455 return SUCCESS;
456 }
457
CapturerSourceStop(void)458 int32_t HpaeSourceInputNode::CapturerSourceStop(void)
459 {
460 CHECK_AND_RETURN_RET_LOG(audioCapturerSource_ != nullptr && captureId_ != HDI_INVALID_ID,
461 ERROR, "invalid audioCapturerSource");
462 CHECK_AND_RETURN_RET_LOG(audioCapturerSource_->IsInited(), ERROR, "invalid source state");
463 Trace trace("HpaeSourceInputNode::CapturerSourceStop");
464 SetSourceState(STREAM_MANAGER_SUSPENDED);
465 if (audioCapturerSource_->Stop() != SUCCESS) {
466 AUDIO_ERR_LOG("CapturerSourceStop error, sourceInputNode[%{public}u]", sourceInputNodeType_);
467 }
468 return SUCCESS;
469 }
470
GetSourceState(void)471 StreamManagerState HpaeSourceInputNode::GetSourceState(void)
472 {
473 return state_;
474 }
475
SetSourceState(StreamManagerState sourceState)476 int32_t HpaeSourceInputNode::SetSourceState(StreamManagerState sourceState)
477 {
478 AUDIO_INFO_LOG("Source[%{public}s] state change:[%{public}s]-->[%{public}s]",
479 GetDeviceClass().c_str(), ConvertStreamManagerState2Str(state_).c_str(),
480 ConvertStreamManagerState2Str(sourceState).c_str());
481 state_ = sourceState;
482 return SUCCESS;
483 }
484
GetOutputPortNum()485 size_t HpaeSourceInputNode::GetOutputPortNum()
486 {
487 std::unordered_map<HpaeSourceBufferType, OutputPort<HpaePcmBuffer *>>::iterator it;
488 if (sourceInputNodeType_ != HPAE_SOURCE_MIC_EC) {
489 it = outputStreamMap_.begin();
490 } else {
491 it = outputStreamMap_.find(HPAE_SOURCE_BUFFER_TYPE_MIC);
492 }
493 CHECK_AND_RETURN_RET_LOG(it != outputStreamMap_.end(), 0, "outStreamMap_ is empty.");
494 return it->second.GetInputNum();
495 }
496
GetOutputPortNum(HpaeNodeInfo & nodeInfo)497 size_t HpaeSourceInputNode::GetOutputPortNum(HpaeNodeInfo &nodeInfo)
498 {
499 auto it = outputStreamMap_.find(nodeInfo.sourceBufferType);
500 CHECK_AND_RETURN_RET_LOG(it != outputStreamMap_.end(), 0, "can't find nodeKey in outStreamMap_.");
501 return it->second.GetInputNum();
502 }
503
GetSourceInputNodeType()504 HpaeSourceInputNodeType HpaeSourceInputNode::GetSourceInputNodeType()
505 {
506 return sourceInputNodeType_;
507 }
508
SetSourceInputNodeType(HpaeSourceInputNodeType type)509 void HpaeSourceInputNode::SetSourceInputNodeType(HpaeSourceInputNodeType type)
510 {
511 sourceInputNodeType_ = type;
512 }
513
GetNodeInfoWithInfo(HpaeSourceBufferType & type)514 HpaeNodeInfo &HpaeSourceInputNode::GetNodeInfoWithInfo(HpaeSourceBufferType &type)
515 {
516 auto it = nodeInfoMap_.find(type);
517 CHECK_AND_RETURN_RET_LOG(it != nodeInfoMap_.end(), nodeInfoMap_.begin()->second,
518 "can't find nodeKey in nodeInfoMap_.");
519 return it->second;
520 }
521
UpdateAppsUidAndSessionId(std::vector<int32_t> & appsUid,std::vector<int32_t> & sessionsId)522 void HpaeSourceInputNode::UpdateAppsUidAndSessionId(std::vector<int32_t> &appsUid, std::vector<int32_t> &sessionsId)
523 {
524 CHECK_AND_RETURN_LOG(audioCapturerSource_ != nullptr && captureId_ != HDI_INVALID_ID,
525 "audioCapturerSource_ is nullptr");
526 CHECK_AND_RETURN_LOG(audioCapturerSource_->IsInited(), "invalid source state");
527 audioCapturerSource_->UpdateAppsUid(appsUid);
528 std::shared_ptr<AudioSourceClock> clock =
529 CapturerClockManager::GetInstance().GetAudioSourceClock(captureId_);
530 if (clock != nullptr) {
531 clock->UpdateSessionId(sessionsId);
532 }
533 }
534
GetCaptureId() const535 uint32_t HpaeSourceInputNode::GetCaptureId() const
536 {
537 return captureId_;
538 }
539 } // namespace HPAE
540 } // namespace AudioStandard
541 } // namespace OHOS