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 "HpaeCapturerManager"
18 #endif
19
20 #include "hpae_capturer_manager.h"
21 #include "audio_info.h"
22 #include "audio_errors.h"
23 #include "hpae_node_common.h"
24 #include "audio_utils.h"
25 #include "audio_effect_map.h"
26 #include "hpae_policy_manager.h"
27 #include "audio_engine_log.h"
28
29 namespace OHOS {
30 namespace AudioStandard {
31 namespace HPAE {
32 const std::string DEFAULT_DEVICE_CLASS = "primary";
33 const std::string DEFAULT_DEVICE_NETWORKID = "LocalDevice";
34
HpaeCapturerManager(HpaeSourceInfo & sourceInfo)35 HpaeCapturerManager::HpaeCapturerManager(HpaeSourceInfo &sourceInfo)
36 : hpaeNoLockQueue_(CURRENT_REQUEST_COUNT), sourceInfo_(sourceInfo)
37 {
38 AUDIO_INFO_LOG("Source info: mic[%{public}d_%{public}d_%{public}d] "\
39 "ec[%{public}d_%{public}d_%{public}d_%{public}d] "\
40 "micref[%{public}d_%{public}d_%{public}d_%{public}d]",
41 sourceInfo.samplingRate, sourceInfo.channels, sourceInfo.format,
42 sourceInfo.ecType, sourceInfo.ecSamplingRate, sourceInfo.ecChannels, sourceInfo.ecFormat,
43 sourceInfo.micRef, sourceInfo.micRefSamplingRate, sourceInfo.micRefChannels, sourceInfo.micRefFormat);
44 }
45
~HpaeCapturerManager()46 HpaeCapturerManager::~HpaeCapturerManager()
47 {
48 if (isInit_.load()) {
49 DeInit();
50 }
51 }
52
CaptureEffectCreate(const HpaeProcessorType & processorType,const AudioEnhanceScene & sceneType)53 int32_t HpaeCapturerManager::CaptureEffectCreate(const HpaeProcessorType &processorType,
54 const AudioEnhanceScene &sceneType)
55 {
56 const std::unordered_map<AudioEnhanceScene, std::string> &audioEnhanceSupportedSceneTypes =
57 GetEnhanceSupportedSceneType();
58 auto item = audioEnhanceSupportedSceneTypes.find(sceneType);
59 CHECK_AND_RETURN_RET_LOG(item != audioEnhanceSupportedSceneTypes.end(), ERROR,
60 "sceneType %{public}d not supported", sceneType);
61 uint64_t sceneCode = static_cast<uint64_t>(sceneType);
62 uint64_t sceneKeyCode = 0;
63 sceneKeyCode = (sceneCode << SCENE_TYPE_OFFSET) + (captureId_ << CAPTURER_ID_OFFSET) + renderId_;
64 AUDIO_INFO_LOG("sceneCode:%{public}" PRIu64 "sceneKeyCode:%{public}" PRIu64, sceneCode, sceneKeyCode);
65 CaptureEffectAttr attr = {};
66 attr.micChannels = static_cast<uint32_t>(sourceInfo_.channels);
67 attr.ecChannels = static_cast<uint32_t>(sourceInfo_.ecChannels);
68 attr.micRefChannels = static_cast<uint32_t>(sourceInfo_.micRefChannels);
69
70 int32_t ret = sceneClusterMap_[processorType]->CaptureEffectCreate(sceneKeyCode, attr);
71 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERROR, "sceneType[%{public}u] create failed", sceneType);
72 return SUCCESS;
73 }
74
CreateOutputSession(const HpaeStreamInfo & streamInfo)75 int32_t HpaeCapturerManager::CreateOutputSession(const HpaeStreamInfo &streamInfo)
76 {
77 AUDIO_INFO_LOG("Create output node:%{public}d", streamInfo.sessionId);
78 HpaeNodeInfo nodeInfo;
79 nodeInfo.channels = streamInfo.channels;
80 nodeInfo.format = streamInfo.format;
81 nodeInfo.frameLen = streamInfo.frameLen;
82 nodeInfo.streamType = streamInfo.streamType;
83 nodeInfo.sessionId = streamInfo.sessionId;
84 nodeInfo.samplingRate = (AudioSamplingRate)streamInfo.samplingRate;
85 HpaeProcessorType sceneType = TransSourceTypeToSceneType(streamInfo.sourceType);
86 nodeInfo.sceneType = sceneType;
87 nodeInfo.sourceBufferType = HPAE_SOURCE_BUFFER_TYPE_MIC;
88 nodeInfo.statusCallback = weak_from_this();
89
90 // todo: sourceType->processorType->sceneType => sourceType->sceneType
91 AudioEnhanceScene enhanceScene = TransProcessType2EnhanceScene(sceneType);
92 nodeInfo.effectInfo.enhanceScene = enhanceScene;
93 sourceOutputNodeMap_[streamInfo.sessionId] = std::make_shared<HpaeSourceOutputNode>(nodeInfo);
94 sourceOutputNodeMap_[streamInfo.sessionId]->SetAppUid(streamInfo.uid);
95 sessionNodeMap_[streamInfo.sessionId].sceneType = sceneType;
96
97 if (sceneType != HPAE_SCENE_EFFECT_NONE && !SafeGetMap(sceneClusterMap_, sceneType)) {
98 // todo: algorithm instance count control
99 sceneClusterMap_[sceneType] = std::make_shared<HpaeSourceProcessCluster>(nodeInfo);
100 if (CaptureEffectCreate(sceneType, enhanceScene) != SUCCESS) {
101 sceneClusterMap_.erase(sceneType);
102 }
103 }
104
105 return SUCCESS;
106 }
107
CaptureEffectRelease(const HpaeProcessorType & sceneType)108 int32_t HpaeCapturerManager::CaptureEffectRelease(const HpaeProcessorType &sceneType)
109 {
110 uint64_t sceneCode = static_cast<uint64_t>(TransProcessType2EnhanceScene(sceneType));
111 uint64_t sceneKeyCode = 0;
112 sceneKeyCode = (sceneCode << SCENE_TYPE_OFFSET) + (captureId_ << CAPTURER_ID_OFFSET) + renderId_;
113 int32_t ret = sceneClusterMap_[sceneType]->CaptureEffectRelease(sceneKeyCode);
114 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERROR, "sceneType[%{public}u] release failed", sceneType);
115 return SUCCESS;
116 }
117
DisConnectSceneClusterFromSourceInputCluster(HpaeProcessorType & sceneType)118 void HpaeCapturerManager::DisConnectSceneClusterFromSourceInputCluster(HpaeProcessorType &sceneType)
119 {
120 CHECK_AND_RETURN_LOG(SafeGetMap(sceneClusterMap_, sceneType), "connot find sceneType:%{public}u", sceneType);
121 CHECK_AND_RETURN_LOG(sceneClusterMap_[sceneType]->GetOutputPortNum() == 0,
122 "sceneType:%{public}u outputNum:%{public}u",
123 sceneType, static_cast<uint32_t>(sceneClusterMap_[sceneType]->GetOutputPortNum()));
124 // need to disconnect sceneCluster and sourceInputCluster
125 HpaeNodeInfo ecNodeInfo;
126 HpaeSourceInputNodeType ecNodeType;
127 if (CheckEcCondition(sceneType, ecNodeInfo, ecNodeType)) {
128 sceneClusterMap_[sceneType]->DisConnectWithInfo(sourceInputClusterMap_[ecNodeType], ecNodeInfo); // ec
129 }
130
131 HpaeNodeInfo micRefNodeInfo;
132 if (CheckMicRefCondition(sceneType, micRefNodeInfo)) {
133 // micref
134 sceneClusterMap_[sceneType]->DisConnectWithInfo(sourceInputClusterMap_[HPAE_SOURCE_MICREF], micRefNodeInfo);
135 }
136
137 HpaeNodeInfo micNodeInfo;
138 if (SafeGetMap(sourceInputClusterMap_, mainMicType_) &&
139 sceneClusterMap_[sceneType]->GetCapturerEffectConfig(micNodeInfo, HPAE_SOURCE_BUFFER_TYPE_MIC)) {
140 sceneClusterMap_[sceneType]->DisConnectWithInfo(
141 sourceInputClusterMap_[mainMicType_], micNodeInfo); // mic
142 }
143 return;
144 }
145
DeleteOutputSession(uint32_t sessionId)146 int32_t HpaeCapturerManager::DeleteOutputSession(uint32_t sessionId)
147 {
148 AUDIO_INFO_LOG("delete output node:%{public}d, source name:%{public}s", sessionId, sourceInfo_.deviceClass.c_str());
149 if (!SafeGetMap(sourceOutputNodeMap_, sessionId)) {
150 return SUCCESS;
151 }
152
153 if (!sourceOutputNodeMap_[sessionId]) {
154 sourceOutputNodeMap_.erase(sessionId);
155 sessionNodeMap_.erase(sessionId);
156 return SUCCESS;
157 }
158
159 HpaeProcessorType sceneType = sessionNodeMap_[sessionId].sceneType;
160 if (sceneType != HPAE_SCENE_EFFECT_NONE && SafeGetMap(sceneClusterMap_, sceneType)) {
161 sourceOutputNodeMap_[sessionId]->DisConnectWithInfo(
162 sceneClusterMap_[sceneType], sourceOutputNodeMap_[sessionId]->GetNodeInfo());
163 DisConnectSceneClusterFromSourceInputCluster(sceneType);
164 if (sceneClusterMap_[sceneType]->GetOutputPortNum() == 0) {
165 CaptureEffectRelease(sceneType);
166 sceneClusterMap_.erase(sceneType);
167 }
168 } else if (SafeGetMap(sourceInputClusterMap_, mainMicType_)) {
169 sourceOutputNodeMap_[sessionId]->DisConnectWithInfo(sourceInputClusterMap_[mainMicType_],
170 sourceOutputNodeMap_[sessionId]->GetNodeInfo());
171 }
172
173 if (SafeGetMap(sourceInputClusterMap_, mainMicType_) &&
174 sourceInputClusterMap_[mainMicType_]->GetOutputPortNum() == 0) {
175 CapturerSourceStop();
176 }
177 sourceOutputNodeMap_.erase(sessionId);
178 sessionNodeMap_.erase(sessionId);
179 return SUCCESS;
180 }
181
SetSessionState(uint32_t sessionId,HpaeSessionState capturerState)182 void HpaeCapturerManager::SetSessionState(uint32_t sessionId, HpaeSessionState capturerState)
183 {
184 sessionNodeMap_[sessionId].state = capturerState;
185 sourceOutputNodeMap_[sessionId]->SetState(capturerState);
186 }
187
CreateStream(const HpaeStreamInfo & streamInfo)188 int32_t HpaeCapturerManager::CreateStream(const HpaeStreamInfo &streamInfo)
189 {
190 if (!IsInit()) {
191 AUDIO_ERR_LOG("HpaeCapturerManager is not init");
192 return ERR_INVALID_OPERATION;
193 }
194 auto request = [this, streamInfo]() {
195 AUDIO_INFO_LOG("CreateStream sessionId %{public}u deviceName %{public}s",
196 streamInfo.sessionId,
197 sourceInfo_.deviceName.c_str());
198 CreateOutputSession(streamInfo);
199 SetSessionState(streamInfo.sessionId, HPAE_SESSION_PREPARED);
200 };
201 SendRequest(request);
202 return SUCCESS;
203 }
204
DestroyStream(uint32_t sessionId)205 int32_t HpaeCapturerManager::DestroyStream(uint32_t sessionId)
206 {
207 if (!IsInit()) {
208 AUDIO_ERR_LOG("HpaeCapturerManager is not init");
209 return ERR_INVALID_OPERATION;
210 }
211 auto request = [this, sessionId]() {
212 // map check in DeleteOutputSession
213 DeleteOutputSession(sessionId);
214 };
215 SendRequest(request);
216 return SUCCESS;
217 }
218
CheckEcCondition(const HpaeProcessorType & sceneType,HpaeNodeInfo & ecNodeInfo,HpaeSourceInputNodeType & ecNodeType)219 bool HpaeCapturerManager::CheckEcCondition(const HpaeProcessorType &sceneType, HpaeNodeInfo &ecNodeInfo,
220 HpaeSourceInputNodeType &ecNodeType)
221 {
222 CHECK_AND_RETURN_RET_LOG(sourceInfo_.ecType != HPAE_EC_TYPE_NONE, false, "source not need ec");
223 CHECK_AND_RETURN_RET_LOG(CheckSceneTypeNeedEc(sceneType), false, "scene not need ec");
224 CHECK_AND_RETURN_RET_LOG(SafeGetMap(sceneClusterMap_, sceneType) &&
225 sceneClusterMap_[sceneType]->GetCapturerEffectConfig(ecNodeInfo, HPAE_SOURCE_BUFFER_TYPE_EC),
226 false, "capture effect node has no ec config");
227 ecNodeType = sourceInfo_.ecType == HPAE_EC_TYPE_SAME_ADAPTER ? mainMicType_ : HPAE_SOURCE_EC;
228 AUDIO_INFO_LOG("resolve connect or disconnect for ecNode type[%{public}u]", ecNodeType);
229 CHECK_AND_RETURN_RET_LOG(SafeGetMap(sourceInputClusterMap_, ecNodeType), false, "ec node is null");
230 return true;
231 }
232
CheckMicRefCondition(const HpaeProcessorType & sceneType,HpaeNodeInfo & micRefNodeInfo)233 bool HpaeCapturerManager::CheckMicRefCondition(const HpaeProcessorType &sceneType, HpaeNodeInfo &micRefNodeInfo)
234 {
235 CHECK_AND_RETURN_RET_LOG(sourceInfo_.micRef == HPAE_REF_ON, false, "source not need micref");
236 CHECK_AND_RETURN_RET_LOG(CheckSceneTypeNeedMicRef(sceneType), false, "scene not need micref");
237 CHECK_AND_RETURN_RET_LOG(SafeGetMap(sceneClusterMap_, sceneType) &&
238 sceneClusterMap_[sceneType]->GetCapturerEffectConfig(micRefNodeInfo, HPAE_SOURCE_BUFFER_TYPE_MICREF),
239 false, "capture effect node has no micref config");
240 CHECK_AND_RETURN_RET_LOG(SafeGetMap(sourceInputClusterMap_, HPAE_SOURCE_MICREF), false, "micref node is null");
241 return true;
242 }
243
ConnectProcessClusterWithEc(HpaeProcessorType & sceneType)244 void HpaeCapturerManager::ConnectProcessClusterWithEc(HpaeProcessorType &sceneType)
245 {
246 HpaeNodeInfo ecNodeInfo;
247 HpaeSourceInputNodeType ecNodeType;
248 CHECK_AND_RETURN_LOG(CheckEcCondition(sceneType, ecNodeInfo, ecNodeType), "connect ec failed");
249 sceneClusterMap_[sceneType]->ConnectWithInfo(sourceInputClusterMap_[ecNodeType], ecNodeInfo); // ec
250 }
251
ConnectProcessClusterWithMicRef(HpaeProcessorType & sceneType)252 void HpaeCapturerManager::ConnectProcessClusterWithMicRef(HpaeProcessorType &sceneType)
253 {
254 HpaeNodeInfo micRefNodeInfo;
255 CHECK_AND_RETURN_LOG(CheckMicRefCondition(sceneType, micRefNodeInfo), "connect micref failed");
256 sceneClusterMap_[sceneType]->ConnectWithInfo(sourceInputClusterMap_[HPAE_SOURCE_MICREF], micRefNodeInfo); // micref
257 }
258
ConnectOutputSession(uint32_t sessionId)259 int32_t HpaeCapturerManager::ConnectOutputSession(uint32_t sessionId)
260 {
261 CHECK_AND_RETURN_RET_LOG(SafeGetMap(sourceOutputNodeMap_, sessionId), ERR_INVALID_PARAM,
262 "ConnectOutputSession error, sessionId %{public}u can not find in sourceOutputNodeMap.\n", sessionId);
263
264 HpaeProcessorType sceneType = sessionNodeMap_[sessionId].sceneType;
265 if (sceneType != HPAE_SCENE_EFFECT_NONE && SafeGetMap(sceneClusterMap_, sceneType)) {
266 HpaeNodeInfo micNodeInfo;
267 if (sceneClusterMap_[sceneType]->GetCapturerEffectConfig(micNodeInfo, HPAE_SOURCE_BUFFER_TYPE_MIC)) {
268 sceneClusterMap_[sceneType]->ConnectWithInfo(sourceInputClusterMap_[mainMicType_], micNodeInfo); // mic
269 }
270 ConnectProcessClusterWithEc(sceneType);
271 ConnectProcessClusterWithMicRef(sceneType);
272
273 // 1. Determine if the ResampleNode needs to be created
274 // 2. If ResampleNode needs to be created, it should be connected to the UpEffectNode after creation
275 // 3. Connect the SourceOutputNode to the ResampleNode
276 sourceOutputNodeMap_[sessionId]->ConnectWithInfo(sceneClusterMap_[sceneType],
277 sourceOutputNodeMap_[sessionId]->GetNodeInfo());
278 } else {
279 sourceOutputNodeMap_[sessionId]->ConnectWithInfo(sourceInputClusterMap_[mainMicType_],
280 sourceOutputNodeMap_[sessionId]->GetNodeInfo());
281 }
282 return SUCCESS;
283 }
284
CapturerSourceStart()285 int32_t HpaeCapturerManager::CapturerSourceStart()
286 {
287 CHECK_AND_RETURN_RET_LOG(sourceInputClusterMap_[mainMicType_], ERR_ILLEGAL_STATE,
288 "sourceInputClusterMap_[%{public}d] is nullptr", mainMicType_);
289 CHECK_AND_RETURN_RET_LOG(sourceInputClusterMap_[mainMicType_]->GetSourceState() != STREAM_MANAGER_RUNNING,
290 SUCCESS, "capturer source is already opened");
291 int32_t ret = sourceInputClusterMap_[mainMicType_]->CapturerSourceStart();
292 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "capturer source start error, ret = %{public}d.", ret);
293 if (sourceInfo_.ecType == HPAE_EC_TYPE_DIFF_ADAPTER) {
294 CHECK_AND_RETURN_RET_LOG(sourceInputClusterMap_[HPAE_SOURCE_EC], ERR_ILLEGAL_STATE,
295 "sourceInputClusterMap_[%{public}d] is nullptr", HPAE_SOURCE_EC);
296 ret = sourceInputClusterMap_[HPAE_SOURCE_EC]->CapturerSourceStart();
297 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "ec capturer source start error, ret = %{public}d.", ret);
298 }
299 if (sourceInfo_.micRef == HPAE_REF_ON) {
300 CHECK_AND_RETURN_RET_LOG(sourceInputClusterMap_[HPAE_SOURCE_MICREF], ERR_ILLEGAL_STATE,
301 "sourceInputClusterMap_[%{public}d] is nullptr", HPAE_SOURCE_MICREF);
302 ret = sourceInputClusterMap_[HPAE_SOURCE_MICREF]->CapturerSourceStart();
303 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "micref capturer source start error, ret = %{public}d.", ret);
304 }
305 return SUCCESS;
306 }
307
Start(uint32_t sessionId)308 int32_t HpaeCapturerManager::Start(uint32_t sessionId)
309 {
310 auto request = [this, sessionId]() {
311 Trace trace("[" + std::to_string(sessionId) + "]HpaeCapturerManager::Start");
312 AUDIO_INFO_LOG("Start sessionId %{public}u", sessionId);
313 CHECK_AND_RETURN_LOG(ConnectOutputSession(sessionId) == SUCCESS, "Connect node error.");
314 SetSessionState(sessionId, HPAE_SESSION_RUNNING);
315 CHECK_AND_RETURN_LOG(CapturerSourceStart() == SUCCESS, "CapturerSourceStart error.");
316 };
317 SendRequest(request);
318 return SUCCESS;
319 }
320
DisConnectOutputSession(uint32_t sessionId)321 int32_t HpaeCapturerManager::DisConnectOutputSession(uint32_t sessionId)
322 {
323 HpaeProcessorType sceneType = sessionNodeMap_[sessionId].sceneType;
324 if (sceneType != HPAE_SCENE_EFFECT_NONE && SafeGetMap(sceneClusterMap_, sceneType)) {
325 // 1. Disconnect SourceOutputNode and ResampleNode
326 // 2. Disconnect the ResampleNode and UpEffectNode
327 // 3. If the ResampleNode has no output, it needs to be deleted
328 sourceOutputNodeMap_[sessionId]->DisConnectWithInfo(
329 sceneClusterMap_[sceneType], sourceOutputNodeMap_[sessionId]->GetNodeInfo());
330 DisConnectSceneClusterFromSourceInputCluster(sceneType);
331 } else if (SafeGetMap(sourceInputClusterMap_, mainMicType_)) {
332 AUDIO_INFO_LOG("sceneType[%{public}u] do not exist sceneCluster", sceneType);
333 sourceOutputNodeMap_[sessionId]->DisConnectWithInfo(sourceInputClusterMap_[mainMicType_],
334 sourceOutputNodeMap_[sessionId]->GetNodeInfo());
335 }
336
337 if (sourceInputClusterMap_[mainMicType_]->GetOutputPortNum() == 0) {
338 CapturerSourceStop();
339 }
340 return SUCCESS;
341 }
342
Pause(uint32_t sessionId)343 int32_t HpaeCapturerManager::Pause(uint32_t sessionId)
344 {
345 auto request = [this, sessionId]() {
346 Trace trace("[" + std::to_string(sessionId) + "]HpaeCapturerManager::Pause");
347 AUDIO_INFO_LOG("Pause sessionId %{public}u", sessionId);
348 CHECK_AND_RETURN_LOG(SafeGetMap(sourceOutputNodeMap_, sessionId),
349 "Pause not find sessionId %{public}u", sessionId);
350 DisConnectOutputSession(sessionId);
351 SetSessionState(sessionId, HPAE_SESSION_PAUSED);
352 TriggerCallback(UPDATE_STATUS, HPAE_STREAM_CLASS_TYPE_RECORD, sessionId,
353 HPAE_SESSION_PAUSED, OPERATION_PAUSED);
354 };
355 SendRequest(request);
356 return SUCCESS;
357 }
358
Flush(uint32_t sessionId)359 int32_t HpaeCapturerManager::Flush(uint32_t sessionId)
360 {
361 if (!IsInit()) {
362 AUDIO_ERR_LOG("HpaeCapturerManager is not init");
363 return ERR_INVALID_OPERATION;
364 }
365 auto request = [this, sessionId]() {
366 Trace trace("[" + std::to_string(sessionId) + "]HpaeCapturerManager::Flush");
367 CHECK_AND_RETURN_LOG(SafeGetMap(sourceOutputNodeMap_, sessionId),
368 "Flush not find sessionId %{public}u", sessionId);
369 // no cache data need to flush
370 };
371 SendRequest(request);
372 return SUCCESS;
373 }
374
Drain(uint32_t sessionId)375 int32_t HpaeCapturerManager::Drain(uint32_t sessionId)
376 {
377 if (!IsInit()) {
378 AUDIO_ERR_LOG("HpaeCapturerManager is not init");
379 return ERR_INVALID_OPERATION;
380 }
381 auto request = [this, sessionId]() {
382 Trace trace("[" + std::to_string(sessionId) + "]HpaeCapturerManager::Drain");
383 CHECK_AND_RETURN_LOG(SafeGetMap(sourceOutputNodeMap_, sessionId),
384 "Drain not find sessionId %{public}u", sessionId);
385 // no cache data need to drain
386 TriggerCallback(UPDATE_STATUS, HPAE_STREAM_CLASS_TYPE_RECORD, sessionId,
387 sessionNodeMap_[sessionId].state, OPERATION_DRAINED);
388 };
389 SendRequest(request);
390 return SUCCESS;
391 }
392
CapturerSourceStopForRemote()393 void HpaeCapturerManager::CapturerSourceStopForRemote()
394 {
395 CHECK_AND_RETURN_LOG(sourceInfo_.deviceClass == "remote", "not remote source");
396 CHECK_AND_RETURN_LOG(SafeGetMap(sourceInputClusterMap_, mainMicType_),
397 "sourceInputClusterMap_[%{public}d] is nullptr", mainMicType_);
398 CHECK_AND_RETURN_LOG(sourceInputClusterMap_[mainMicType_]->GetOutputPortNum() == 0, "source has running stream");
399 sourceInputClusterMap_[mainMicType_]->CapturerSourceStop();
400 }
401
CapturerSourceStop()402 int32_t HpaeCapturerManager::CapturerSourceStop()
403 {
404 CHECK_AND_RETURN_RET_LOG(SafeGetMap(sourceInputClusterMap_, mainMicType_), ERR_ILLEGAL_STATE,
405 "sourceInputClusterMap_[%{public}d] is nullptr", mainMicType_);
406
407 // If remote source has no running stream, stop source
408 CapturerSourceStopForRemote();
409
410 CHECK_AND_RETURN_RET_LOG(sourceInputClusterMap_[mainMicType_]->GetSourceState() != STREAM_MANAGER_SUSPENDED,
411 SUCCESS, "capturer source is already stopped");
412 sourceInputClusterMap_[mainMicType_]->CapturerSourceStop();
413
414 if (sourceInfo_.ecType == HPAE_EC_TYPE_DIFF_ADAPTER && SafeGetMap(sourceInputClusterMap_, HPAE_SOURCE_EC)) {
415 sourceInputClusterMap_[HPAE_SOURCE_EC]->CapturerSourceStop();
416 }
417
418 if (sourceInfo_.micRef == HPAE_REF_ON && SafeGetMap(sourceInputClusterMap_, HPAE_SOURCE_MICREF)) {
419 sourceInputClusterMap_[HPAE_SOURCE_MICREF]->CapturerSourceStop();
420 }
421 HpaePolicyManager::GetInstance().SendInitCommandToAlgo();
422 return SUCCESS;
423 }
424
Stop(uint32_t sessionId)425 int32_t HpaeCapturerManager::Stop(uint32_t sessionId)
426 {
427 auto request = [this, sessionId]() {
428 Trace trace("[" + std::to_string(sessionId) + "]HpaeCapturerManager::Stop");
429 CHECK_AND_RETURN_LOG(SafeGetMap(sourceOutputNodeMap_, sessionId),
430 "Stop not find sessionId %{public}u", sessionId);
431 DisConnectOutputSession(sessionId);
432 SetSessionState(sessionId, HPAE_SESSION_STOPPED);
433 TriggerCallback(UPDATE_STATUS, HPAE_STREAM_CLASS_TYPE_RECORD, sessionId,
434 HPAE_SESSION_STOPPED, OPERATION_STOPPED);
435 };
436 SendRequest(request);
437 return SUCCESS;
438 }
439
Release(uint32_t sessionId)440 int32_t HpaeCapturerManager::Release(uint32_t sessionId)
441 {
442 Trace trace("[" + std::to_string(sessionId) + "]HpaeCapturerManager::Release");
443 return DestroyStream(sessionId);
444 }
445
SetStreamMute(uint32_t sessionId,bool isMute)446 int32_t HpaeCapturerManager::SetStreamMute(uint32_t sessionId, bool isMute)
447 {
448 auto request = [this, sessionId, isMute]() {
449 CHECK_AND_RETURN_LOG(SafeGetMap(sourceOutputNodeMap_, sessionId),
450 "Mute not find sessionId %{public}u", sessionId);
451 sourceOutputNodeMap_[sessionId]->SetMute(isMute);
452 };
453 SendRequest(request);
454 return SUCCESS;
455 }
456
SetMute(bool isMute)457 int32_t HpaeCapturerManager::SetMute(bool isMute)
458 {
459 // to do check pulseaudio
460 auto request = [this, isMute]() {
461 if (isMute_ != isMute) {
462 isMute_ = isMute; // todo: fadein and fadeout and mute feature
463 }
464 };
465 SendRequest(request);
466 return SUCCESS;
467 }
468
Process()469 void HpaeCapturerManager::Process()
470 {
471 Trace trace("HpaeCapturerManager::Process");
472 if (IsRunning()) {
473 UpdateAppsUidAndSessionId();
474 for (const auto &sourceOutputNodePair : sourceOutputNodeMap_) {
475 if (sourceOutputNodePair.second->GetState() == HPAE_SESSION_RUNNING) {
476 sourceOutputNodePair.second->DoProcess();
477 }
478 }
479 }
480 }
481
UpdateAppsUidAndSessionId()482 void HpaeCapturerManager::UpdateAppsUidAndSessionId()
483 {
484 appsUid_.clear();
485 sessionsId_.clear();
486 for (const auto &sourceOutputNodePair : sourceOutputNodeMap_) {
487 if (sourceOutputNodePair.second->GetState() == HPAE_SESSION_RUNNING) {
488 appsUid_.emplace_back(sourceOutputNodePair.second->GetAppUid());
489 sessionsId_.emplace_back(static_cast<int32_t>(sourceOutputNodePair.first));
490 }
491 }
492 if (SafeGetMap(sourceInputClusterMap_, mainMicType_) && sourceInputClusterMap_[mainMicType_]) {
493 sourceInputClusterMap_[mainMicType_]->UpdateAppsUidAndSessionId(appsUid_, sessionsId_);
494 }
495 }
496
HandleMsg()497 void HpaeCapturerManager::HandleMsg()
498 {
499 hpaeNoLockQueue_.HandleRequests();
500 }
501
PrepareCapturerEc(HpaeNodeInfo & ecNodeInfo)502 int32_t HpaeCapturerManager::PrepareCapturerEc(HpaeNodeInfo &ecNodeInfo)
503 {
504 if (sourceInfo_.ecType == HPAE_EC_TYPE_DIFF_ADAPTER) {
505 ecNodeInfo.frameLen = sourceInfo_.ecFrameLen;
506 ecNodeInfo.channels = sourceInfo_.ecChannels;
507 ecNodeInfo.format = sourceInfo_.ecFormat;
508 ecNodeInfo.samplingRate = sourceInfo_.ecSamplingRate;
509 ecNodeInfo.sourceBufferType = HPAE_SOURCE_BUFFER_TYPE_EC;
510 ecNodeInfo.sourceInputNodeType = HPAE_SOURCE_EC;
511 ecNodeInfo.statusCallback = weak_from_this();
512 sourceInputClusterMap_[HPAE_SOURCE_EC] = std::make_shared<HpaeSourceInputCluster>(ecNodeInfo);
513 int32_t ret = sourceInputClusterMap_[HPAE_SOURCE_EC]->GetCapturerSourceInstance(
514 DEFAULT_DEVICE_CLASS, DEFAULT_DEVICE_NETWORKID, SOURCE_TYPE_INVALID, HDI_ID_INFO_EC);
515 if (ret != SUCCESS) {
516 AUDIO_ERR_LOG("get ec capturer soruce instance error, ret = %{public}d.\n", ret);
517 sourceInputClusterMap_.erase(HPAE_SOURCE_EC);
518 }
519 }
520 return SUCCESS;
521 }
522
PrepareCapturerMicRef(HpaeNodeInfo & micRefNodeInfo)523 int32_t HpaeCapturerManager::PrepareCapturerMicRef(HpaeNodeInfo &micRefNodeInfo)
524 {
525 if (sourceInfo_.micRef == HPAE_REF_ON) {
526 micRefNodeInfo.frameLen = sourceInfo_.micRefFrameLen;
527 micRefNodeInfo.channels = sourceInfo_.micRefChannels;
528 micRefNodeInfo.format = sourceInfo_.micRefFormat;
529 micRefNodeInfo.samplingRate = sourceInfo_.micRefSamplingRate;
530 micRefNodeInfo.sourceBufferType = HPAE_SOURCE_BUFFER_TYPE_MICREF;
531 micRefNodeInfo.sourceInputNodeType = HPAE_SOURCE_MICREF;
532 micRefNodeInfo.statusCallback = weak_from_this();
533 sourceInputClusterMap_[HPAE_SOURCE_MICREF] = std::make_shared<HpaeSourceInputCluster>(micRefNodeInfo);
534 int32_t ret = sourceInputClusterMap_[HPAE_SOURCE_MICREF]->GetCapturerSourceInstance(
535 DEFAULT_DEVICE_CLASS, DEFAULT_DEVICE_NETWORKID, SOURCE_TYPE_INVALID, HDI_ID_INFO_MIC_REF);
536 if (ret != SUCCESS) {
537 AUDIO_ERR_LOG("get micRef capturer soruce instance error, ret = %{public}d.\n", ret);
538 sourceInputClusterMap_.erase(HPAE_SOURCE_MICREF);
539 }
540 }
541 return SUCCESS;
542 }
543
CreateSourceAttr(IAudioSourceAttr & attr)544 void HpaeCapturerManager::CreateSourceAttr(IAudioSourceAttr &attr)
545 {
546 attr.adapterName = sourceInfo_.adapterName;
547 attr.sampleRate = sourceInfo_.samplingRate;
548 attr.channel = sourceInfo_.channels;
549 attr.format = sourceInfo_.format;
550 attr.channelLayout = sourceInfo_.channelLayout;
551 attr.deviceType = sourceInfo_.deviceType;
552 attr.volume = sourceInfo_.volume;
553 attr.deviceNetworkId = sourceInfo_.deviceNetId.c_str();
554 attr.filePath = sourceInfo_.filePath.c_str();
555 attr.isBigEndian = false;
556 attr.sourceType = static_cast<int32_t>(sourceInfo_.sourceType);
557 attr.openMicSpeaker = sourceInfo_.openMicSpeaker;
558 attr.hasEcConfig = mainMicType_ == HPAE_SOURCE_MIC_EC;
559 return;
560 }
561
InitCapturer()562 int32_t HpaeCapturerManager::InitCapturer()
563 {
564 IAudioSourceAttr attr;
565 CreateSourceAttr(attr);
566 if (attr.hasEcConfig) {
567 attr.formatEc = sourceInfo_.ecFormat;
568 attr.sampleRateEc = sourceInfo_.ecSamplingRate;
569 attr.channelEc = sourceInfo_.ecChannels;
570 }
571 int32_t ret = sourceInputClusterMap_[mainMicType_]->CapturerSourceInit(attr);
572 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_INVALID_OPERATION,
573 "init mic source input node err, , ret = %{public}d.\n", ret);
574 if (sourceInfo_.ecType == HPAE_EC_TYPE_DIFF_ADAPTER && SafeGetMap(sourceInputClusterMap_, HPAE_SOURCE_EC)) {
575 IAudioSourceAttr attrEc;
576 attrEc.sourceType = SOURCE_TYPE_EC;
577 attrEc.adapterName = sourceInfo_.ecAdapterName;
578 attrEc.deviceType = DEVICE_TYPE_MIC;
579 attrEc.sampleRate = sourceInfo_.ecSamplingRate;
580 attrEc.channel = sourceInfo_.ecChannels;
581 attrEc.format = sourceInfo_.ecFormat;
582 attrEc.isBigEndian = false;
583 attrEc.openMicSpeaker = sourceInfo_.openMicSpeaker;
584 ret = sourceInputClusterMap_[HPAE_SOURCE_EC]->CapturerSourceInit(attrEc);
585 if (ret != SUCCESS) {
586 AUDIO_ERR_LOG("init ec source input node err, ret = %{public}d.\n", ret);
587 sourceInputClusterMap_.erase(HPAE_SOURCE_EC);
588 }
589 }
590 if (sourceInfo_.micRef == HPAE_REF_ON && SafeGetMap(sourceInputClusterMap_, HPAE_SOURCE_MICREF)) {
591 IAudioSourceAttr attrMicRef;
592 attrMicRef.sourceType = SOURCE_TYPE_MIC_REF;
593 attrMicRef.adapterName = "primary";
594 attrMicRef.deviceType = DEVICE_TYPE_MIC;
595 attrMicRef.sampleRate = sourceInfo_.micRefSamplingRate;
596 attrMicRef.channel = sourceInfo_.micRefChannels;
597 attrMicRef.format = sourceInfo_.micRefFormat;
598 attrMicRef.isBigEndian = false;
599 attrMicRef.openMicSpeaker = sourceInfo_.openMicSpeaker;
600 ret = sourceInputClusterMap_[HPAE_SOURCE_MICREF]->CapturerSourceInit(attrMicRef);
601 if (ret != SUCCESS) {
602 AUDIO_ERR_LOG("init micRef source input node err, ret = %{public}d.\n", ret);
603 sourceInputClusterMap_.erase(HPAE_SOURCE_MICREF);
604 }
605 }
606 return SUCCESS;
607 }
608
ReloadCaptureManager(const HpaeSourceInfo & sourceInfo)609 int32_t HpaeCapturerManager::ReloadCaptureManager(const HpaeSourceInfo &sourceInfo)
610 {
611 if (IsInit()) {
612 DeInit();
613 }
614 hpaeSignalProcessThread_ = std::make_unique<HpaeSignalProcessThread>();
615 auto request = [this, sourceInfo] {
616 // disconnect
617 std::vector<HpaeCaptureMoveInfo> moveInfos;
618 for (const auto &it : sourceOutputNodeMap_) {
619 HpaeCaptureMoveInfo moveInfo;
620 moveInfo.sessionId = it.first;
621 moveInfo.sourceOutputNode = it.second;
622 if (sessionNodeMap_.find(it.first) != sessionNodeMap_.end()) {
623 moveInfo.sessionInfo = sessionNodeMap_[it.first];
624 moveInfos.emplace_back(moveInfo);
625 }
626 }
627 for (const auto &it : moveInfos) {
628 DeleteOutputSession(it.sessionId);
629 }
630 sourceInfo_ = sourceInfo;
631 int32_t ret = InitCapturerManager();
632 if (ret != SUCCESS) {
633 AUDIO_INFO_LOG("re-Init HpaeCapturerManager failed");
634 TriggerCallback(INIT_DEVICE_RESULT, sourceInfo_.deviceName, ret);
635 return;
636 }
637 AUDIO_INFO_LOG("re-Init HpaeCapturerManager success");
638 HpaePolicyManager::GetInstance().SetInputDevice(captureId_, static_cast<DeviceType>(sourceInfo_.deviceType));
639 // connect
640 for (const auto &moveInfo : moveInfos) {
641 AddSingleNodeToSource(moveInfo, true);
642 }
643 TriggerCallback(INIT_DEVICE_RESULT, sourceInfo_.deviceName, ret);
644 TriggerCallback(INIT_SOURCE_RESULT, sourceInfo_.sourceType);
645 };
646 SendRequest(request, true);
647 hpaeSignalProcessThread_->ActivateThread(shared_from_this());
648 return SUCCESS;
649 }
650
InitCapturerManager()651 int32_t HpaeCapturerManager::InitCapturerManager()
652 {
653 HpaeNodeInfo nodeInfo;
654 HpaeNodeInfo ecNodeInfo;
655 HpaeNodeInfo micRefNodeInfo;
656 nodeInfo.deviceClass = sourceInfo_.deviceClass;
657 nodeInfo.channels = sourceInfo_.channels;
658 nodeInfo.format = sourceInfo_.format;
659 nodeInfo.frameLen = sourceInfo_.frameLen;
660 nodeInfo.samplingRate = sourceInfo_.samplingRate;
661 nodeInfo.sourceBufferType = HPAE_SOURCE_BUFFER_TYPE_MIC;
662 nodeInfo.statusCallback = weak_from_this();
663 mainMicType_ = sourceInfo_.ecType == HPAE_EC_TYPE_SAME_ADAPTER ? HPAE_SOURCE_MIC_EC : HPAE_SOURCE_MIC;
664
665 if (mainMicType_ == HPAE_SOURCE_MIC_EC) {
666 ecNodeInfo.channels = sourceInfo_.ecChannels;
667 ecNodeInfo.format = sourceInfo_.ecFormat;
668 ecNodeInfo.samplingRate = sourceInfo_.ecSamplingRate;
669 ecNodeInfo.frameLen = sourceInfo_.ecFrameLen;
670 ecNodeInfo.sourceBufferType = HPAE_SOURCE_BUFFER_TYPE_EC;
671 ecNodeInfo.statusCallback = weak_from_this();
672 nodeInfo.sourceInputNodeType = HPAE_SOURCE_MIC_EC;
673 std::vector<HpaeNodeInfo> nodeInfos = {nodeInfo, ecNodeInfo};
674 sourceInputClusterMap_[mainMicType_] = std::make_shared<HpaeSourceInputCluster>(nodeInfos);
675 } else {
676 nodeInfo.sourceInputNodeType = HPAE_SOURCE_MIC;
677 sourceInputClusterMap_[mainMicType_] = std::make_shared<HpaeSourceInputCluster>(nodeInfo);
678 }
679
680 sourceInputClusterMap_[mainMicType_]->SetSourceInputNodeType(mainMicType_); // to do rewrite, optimise
681 int32_t ret = sourceInputClusterMap_[mainMicType_]->GetCapturerSourceInstance(
682 sourceInfo_.deviceClass, sourceInfo_.deviceNetId, sourceInfo_.sourceType, sourceInfo_.sourceName);
683 captureId_ = sourceInputClusterMap_[mainMicType_]->GetCaptureId();
684 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "get mic capturer soruce instance error, ret = %{public}d.\n", ret);
685 PrepareCapturerEc(ecNodeInfo);
686 PrepareCapturerMicRef(micRefNodeInfo);
687 ret = InitCapturer();
688 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "init main capturer error");
689 isInit_.store(true);
690 return SUCCESS;
691 }
692
693
Init(bool isReload)694 int32_t HpaeCapturerManager::Init(bool isReload)
695 {
696 hpaeSignalProcessThread_ = std::make_unique<HpaeSignalProcessThread>();
697 auto request = [this] {
698 int32_t ret = InitCapturerManager();
699 TriggerCallback(INIT_DEVICE_RESULT, sourceInfo_.deviceName, ret);
700 CHECK_AND_RETURN_LOG(ret == SUCCESS, "Init HpaeCapturerManager failed");
701 TriggerCallback(INIT_SOURCE_RESULT, sourceInfo_.sourceType);
702 AUDIO_INFO_LOG("Init HpaeCapturerManager success");
703 CheckIfAnyStreamRunning();
704 HpaePolicyManager::GetInstance().SetInputDevice(captureId_,
705 static_cast<DeviceType>(sourceInfo_.deviceType));
706 };
707 SendRequest(request, true);
708 hpaeSignalProcessThread_->ActivateThread(shared_from_this());
709 return SUCCESS;
710 }
711
DeInit(bool isMoveDefault)712 int32_t HpaeCapturerManager::DeInit(bool isMoveDefault)
713 {
714 AUDIO_INFO_LOG("DeInit device:%{public}s", sourceInfo_.deviceName.c_str());
715 if (hpaeSignalProcessThread_ != nullptr) {
716 hpaeSignalProcessThread_->DeactivateThread();
717 hpaeSignalProcessThread_ = nullptr;
718 }
719 hpaeNoLockQueue_.HandleRequests();
720 for (auto outputNode : sourceOutputNodeMap_) {
721 outputNode.second->ResetAll();
722 }
723 CHECK_AND_RETURN_RET_LOG(SafeGetMap(sourceInputClusterMap_, mainMicType_), ERR_INVALID_OPERATION,
724 "sourceInputClusterMap_[%{public}d] is nullptr", mainMicType_);
725 CapturerSourceStop();
726 sourceInputClusterMap_[mainMicType_]->CapturerSourceDeInit();
727 if (sourceInfo_.ecType == HPAE_EC_TYPE_DIFF_ADAPTER && SafeGetMap(sourceInputClusterMap_, HPAE_SOURCE_EC)) {
728 sourceInputClusterMap_[HPAE_SOURCE_EC]->CapturerSourceDeInit();
729 }
730 if (sourceInfo_.micRef == HPAE_REF_ON && SafeGetMap(sourceInputClusterMap_, HPAE_SOURCE_MICREF)) {
731 sourceInputClusterMap_[HPAE_SOURCE_MICREF]->CapturerSourceDeInit();
732 }
733 isInit_.store(false);
734
735 if (isMoveDefault) {
736 std::string name = "";
737 std::vector<uint32_t> ids;
738 AUDIO_INFO_LOG("move all source to default source");
739 MoveAllStreamToNewSource(name, ids, MOVE_ALL);
740 }
741 sourceInputClusterMap_.clear();
742 return SUCCESS;
743 }
744
DeactivateThread()745 bool HpaeCapturerManager::DeactivateThread()
746 {
747 if (hpaeSignalProcessThread_ != nullptr) {
748 hpaeSignalProcessThread_->DeactivateThread();
749 hpaeSignalProcessThread_ = nullptr;
750 }
751 hpaeNoLockQueue_.HandleRequests();
752 return true;
753 }
754
RegisterReadCallback(uint32_t sessionId,const std::weak_ptr<ICapturerStreamCallback> & callback)755 int32_t HpaeCapturerManager::RegisterReadCallback(uint32_t sessionId,
756 const std::weak_ptr<ICapturerStreamCallback> &callback)
757 {
758 auto request = [this, sessionId, callback]() {
759 if (SafeGetMap(sourceOutputNodeMap_, sessionId)) {
760 sourceOutputNodeMap_[sessionId]->RegisterReadCallback(callback);
761 }
762 };
763 SendRequest(request);
764 return SUCCESS;
765 }
766
GetSourceOutputInfo(uint32_t sessionId,HpaeSourceOutputInfo & sourceOutputInfo)767 int32_t HpaeCapturerManager::GetSourceOutputInfo(uint32_t sessionId, HpaeSourceOutputInfo &sourceOutputInfo)
768 {
769 if (!SafeGetMap(sourceOutputNodeMap_, sessionId)) {
770 return ERR_INVALID_OPERATION;
771 }
772 sourceOutputInfo.nodeInfo = sourceOutputNodeMap_[sessionId]->GetNodeInfo();
773 sourceOutputInfo.capturerSessionInfo = sessionNodeMap_[sessionId];
774 return SUCCESS;
775 }
776
GetSourceInfo()777 HpaeSourceInfo HpaeCapturerManager::GetSourceInfo()
778 {
779 return sourceInfo_;
780 }
781
GetAllSourceOutputsInfo()782 std::vector<SourceOutput> HpaeCapturerManager::GetAllSourceOutputsInfo()
783 {
784 return {};
785 }
786
IsInit()787 bool HpaeCapturerManager::IsInit()
788 {
789 return isInit_.load();
790 }
791
IsMsgProcessing()792 bool HpaeCapturerManager::IsMsgProcessing()
793 {
794 return !hpaeNoLockQueue_.IsFinishProcess();
795 }
796
IsRunning(void)797 bool HpaeCapturerManager::IsRunning(void)
798 {
799 if (SafeGetMap(sourceInputClusterMap_, mainMicType_) &&
800 hpaeSignalProcessThread_ != nullptr) {
801 return sourceInputClusterMap_[mainMicType_]->GetSourceState() == STREAM_MANAGER_RUNNING &&
802 hpaeSignalProcessThread_->IsRunning();
803 } else {
804 return false;
805 }
806 }
807
SendRequest(Request && request,bool isInit)808 void HpaeCapturerManager::SendRequest(Request &&request, bool isInit)
809 {
810 if (!isInit && !IsInit()) {
811 AUDIO_INFO_LOG("HpaeCapturerManager not init");
812 return;
813 }
814 hpaeNoLockQueue_.PushRequest(std::move(request));
815 CHECK_AND_RETURN_LOG(hpaeSignalProcessThread_, "hpaeSignalProcessThread_ capturer is nullptr");
816 hpaeSignalProcessThread_->Notify();
817 }
818
OnNodeStatusUpdate(uint32_t sessionId,IOperation operation)819 void HpaeCapturerManager::OnNodeStatusUpdate(uint32_t sessionId, IOperation operation)
820 {
821 TriggerCallback(UPDATE_STATUS, HPAE_STREAM_CLASS_TYPE_RECORD, sessionId,
822 sessionNodeMap_[sessionId].state, operation);
823 }
824
AddAllNodesToSource(const std::vector<HpaeCaptureMoveInfo> & moveInfos,bool isConnect)825 int32_t HpaeCapturerManager::AddAllNodesToSource(const std::vector<HpaeCaptureMoveInfo> &moveInfos, bool isConnect)
826 {
827 auto request = [this, moveInfos, isConnect]() {
828 for (const auto &moveInfo : moveInfos) {
829 AddSingleNodeToSource(moveInfo, isConnect);
830 }
831 };
832 SendRequest(request);
833 return SUCCESS;
834 }
835
AddNodeToSource(const HpaeCaptureMoveInfo & moveInfo)836 int32_t HpaeCapturerManager::AddNodeToSource(const HpaeCaptureMoveInfo &moveInfo)
837 {
838 auto request = [this, moveInfo]() { AddSingleNodeToSource(moveInfo); };
839 SendRequest(request);
840 return SUCCESS;
841 }
842
AddSingleNodeToSource(const HpaeCaptureMoveInfo & moveInfo,bool isConnect)843 void HpaeCapturerManager::AddSingleNodeToSource(const HpaeCaptureMoveInfo &moveInfo, bool isConnect)
844 {
845 uint32_t sessionId = moveInfo.sessionId;
846 AUDIO_INFO_LOG("[FinishMove] session :%{public}u to source:[%{public}s].",
847 sessionId, sourceInfo_.sourceName.c_str());
848 CHECK_AND_RETURN_LOG(moveInfo.sourceOutputNode != nullptr, "move fail, sourceoutputnode is null");
849 HpaeNodeInfo nodeInfo = moveInfo.sourceOutputNode->GetNodeInfo();
850 sourceOutputNodeMap_[sessionId] = moveInfo.sourceOutputNode;
851 sessionNodeMap_[sessionId] = moveInfo.sessionInfo;
852 HpaeProcessorType sceneType = sessionNodeMap_[sessionId].sceneType;
853 AudioEnhanceScene enhanceScene = TransProcessType2EnhanceScene(sceneType);
854 if (sceneType != HPAE_SCENE_EFFECT_NONE) {
855 // todo: algorithm instance count control
856 if (!SafeGetMap(sceneClusterMap_, sceneType)) {
857 sceneClusterMap_[sceneType] = std::make_shared<HpaeSourceProcessCluster>(nodeInfo);
858 }
859 }
860 if (CaptureEffectCreate(sceneType, enhanceScene) != SUCCESS) {
861 AUDIO_WARNING_LOG("[FinishMove] session :%{public}u,create effect failed.", sessionId);
862 sceneClusterMap_.erase(sceneType);
863 }
864
865 if (moveInfo.sessionInfo.state == HPAE_SESSION_RUNNING) {
866 ConnectOutputSession(sessionId);
867 CHECK_AND_RETURN_LOG(CapturerSourceStart() == SUCCESS, "CapturerSourceStart error.");
868 hpaeSignalProcessThread_->Notify();
869 }
870 }
871
MoveAllStream(const std::string & sourceName,const std::vector<uint32_t> & sessionIds,MoveSessionType moveType)872 int32_t HpaeCapturerManager::MoveAllStream(const std::string &sourceName, const std::vector<uint32_t>& sessionIds,
873 MoveSessionType moveType)
874 {
875 if (!IsInit()) {
876 AUDIO_INFO_LOG("source is not init ,use sync mode move to: %{public}s", sourceName.c_str());
877 MoveAllStreamToNewSource(sourceName, sessionIds, moveType);
878 } else {
879 AUDIO_INFO_LOG("source is init ,use async mode move to: %{public}s", sourceName.c_str());
880 auto request = [this, sourceName, sessionIds, moveType]() {
881 MoveAllStreamToNewSource(sourceName, sessionIds, moveType);
882 };
883 SendRequest(request);
884 }
885 return SUCCESS;
886 }
887
MoveAllStreamToNewSource(const std::string & sourceName,const std::vector<uint32_t> & moveIds,MoveSessionType moveType)888 void HpaeCapturerManager::MoveAllStreamToNewSource(const std::string &sourceName,
889 const std::vector<uint32_t>& moveIds, MoveSessionType moveType)
890 {
891 std::string name = sourceName;
892 std::vector<HpaeCaptureMoveInfo> moveInfos;
893 std::string idStr;
894 for (const auto &it : sourceOutputNodeMap_) {
895 if (moveType == MOVE_ALL || std::find(moveIds.begin(), moveIds.end(), it.first) != moveIds.end()) {
896 HpaeCaptureMoveInfo moveInfo;
897 moveInfo.sessionId = it.first;
898 moveInfo.sourceOutputNode = it.second;
899 idStr.append("[").append(std::to_string(it.first)).append("],");
900 if (sessionNodeMap_.find(it.first) != sessionNodeMap_.end()) {
901 moveInfo.sessionInfo = sessionNodeMap_[it.first];
902 moveInfos.emplace_back(moveInfo);
903 }
904 }
905 }
906
907 for (const auto &it : moveInfos) {
908 DeleteOutputSession(it.sessionId);
909 }
910 AUDIO_INFO_LOG("[StartMove] session:%{public}s to source name:%{public}s, move type:%{public}d",
911 idStr.c_str(), name.c_str(), moveType);
912 TriggerCallback(MOVE_ALL_SOURCE_OUTPUT, moveInfos, name);
913 }
914
MoveStream(uint32_t sessionId,const std::string & sourceName)915 int32_t HpaeCapturerManager::MoveStream(uint32_t sessionId, const std::string& sourceName)
916 {
917 auto request = [this, sessionId, sourceName]() {
918 if (!SafeGetMap(sourceOutputNodeMap_, sessionId)) {
919 AUDIO_ERR_LOG("[StartMove] session:%{public}u failed,not find session,move %{public}s --> %{public}s",
920 sessionId, sourceInfo_.sourceName.c_str(), sourceName.c_str());
921 TriggerCallback(MOVE_SESSION_FAILED, HPAE_STREAM_CLASS_TYPE_RECORD, sessionId, MOVE_SINGLE, sourceName);
922 return;
923 }
924 std::shared_ptr<HpaeSourceOutputNode> sourceNode = sourceOutputNodeMap_[sessionId];
925 if (sessionNodeMap_.find(sessionId)==sessionNodeMap_.end()) {
926 AUDIO_ERR_LOG("[StartMove] session:%{public}u failed,not find session node,move %{public}s --> %{public}s",
927 sessionId, sourceInfo_.sourceName.c_str(), sourceName.c_str());
928 TriggerCallback(MOVE_SESSION_FAILED, HPAE_STREAM_CLASS_TYPE_RECORD, sessionId, MOVE_SINGLE, sourceName);
929 return;
930 }
931 CHECK_AND_RETURN_LOG(!sourceName.empty(), "[StartMove] session:%{public}u failed,sourceName is empty",
932 sessionId);
933 AUDIO_INFO_LOG("[StartMove] session: %{public}u, source [%{public}s] --> [%{public}s]",
934 sessionId, sourceInfo_.sourceName.c_str(), sourceName.c_str());
935 HpaeCapturerSessionInfo sessionInfo = sessionNodeMap_[sessionId];
936 HpaeCaptureMoveInfo moveInfo;
937 moveInfo.sessionId = sessionId;
938 moveInfo.sourceOutputNode = sourceNode;
939 moveInfo.sessionInfo = sessionInfo;
940 DeleteOutputSession(sessionId);
941 std::string name = sourceName;
942 TriggerCallback(MOVE_SOURCE_OUTPUT, moveInfo, name);
943 };
944 SendRequest(request);
945 return SUCCESS;
946 }
947
OnNotifyQueue()948 void HpaeCapturerManager::OnNotifyQueue()
949 {
950 CHECK_AND_RETURN_LOG(hpaeSignalProcessThread_, "hpaeSignalProcessThread_ is nullptr");
951 hpaeSignalProcessThread_->Notify();
952 }
953
OnRequestLatency(uint32_t sessionId,uint64_t & latency)954 void HpaeCapturerManager::OnRequestLatency(uint32_t sessionId, uint64_t &latency)
955 {
956 // todo: add processLatency
957 latency = 0;
958 return;
959 }
960
GetThreadName()961 std::string HpaeCapturerManager::GetThreadName()
962 {
963 return sourceInfo_.deviceName;
964 }
965
DumpSourceInfo()966 int32_t HpaeCapturerManager::DumpSourceInfo()
967 {
968 CHECK_AND_RETURN_RET_LOG(IsInit(), ERR_ILLEGAL_STATE, "HpaeCapturerManager not init");
969 SendRequest([this]() {
970 AUDIO_INFO_LOG("DumpSourceInfo deviceName %{public}s", sourceInfo_.deviceName.c_str());
971 UploadDumpSourceInfo(sourceInfo_.deviceName);
972 });
973 return SUCCESS;
974 }
975
CheckIfAnyStreamRunning()976 void HpaeCapturerManager::CheckIfAnyStreamRunning()
977 {
978 CHECK_AND_RETURN_LOG(!sessionNodeMap_.empty(), "no stream need start");
979 for (auto &sessionPair : sessionNodeMap_) {
980 if (sessionPair.second.state == HPAE_SESSION_RUNNING) {
981 ConnectOutputSession(sessionPair.first);
982 CHECK_AND_RETURN_LOG(CapturerSourceStart() == SUCCESS, "CapturerSourceStart error.");
983 }
984 }
985 }
986
GetDeviceHDFDumpInfo()987 std::string HpaeCapturerManager::GetDeviceHDFDumpInfo()
988 {
989 std::string config;
990 TransDeviceInfoToString(sourceInfo_, config);
991 return config;
992 }
993 } // namespace HPAE
994 } // namespace AudioStandard
995 } // namespace OHOS