1 /*
2 * Copyright (c) 2023 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 #ifndef LOG_TAG
16 #define LOG_TAG "PaAdapterManager"
17 #endif
18
19 #include "pa_adapter_manager.h"
20 #include <sstream>
21 #include <atomic>
22 #include "audio_common_log.h"
23 #include "audio_errors.h"
24 #include "audio_schedule.h"
25 #include "pa_adapter_tools.h"
26 #include "pa_renderer_stream_impl.h"
27 #include "pa_capturer_stream_impl.h"
28 #include "audio_utils.h"
29 #include "audio_info.h"
30 #include "policy_handler.h"
31
32 namespace OHOS {
33 namespace AudioStandard {
34 const uint32_t CHECK_UTIL_SUCCESS = 0;
35 const uint64_t BUF_LENGTH_IN_MSEC = 20;
36 static const uint32_t PA_RECORD_MAX_LENGTH_NORMAL = 4;
37 static const uint32_t PA_RECORD_MAX_LENGTH_WAKEUP = 30;
38 static const int32_t CONNECT_STREAM_TIMEOUT_IN_SEC = 5; // 5S
39 static const std::unordered_map<AudioStreamType, std::string> STREAM_TYPE_ENUM_STRING_MAP = {
40 {STREAM_VOICE_CALL, "voice_call"},
41 {STREAM_MUSIC, "music"},
42 {STREAM_RING, "ring"},
43 {STREAM_MEDIA, "media"},
44 {STREAM_VOICE_ASSISTANT, "voice_assistant"},
45 {STREAM_SYSTEM, "system"},
46 {STREAM_ALARM, "alarm"},
47 {STREAM_NOTIFICATION, "notification"},
48 {STREAM_BLUETOOTH_SCO, "bluetooth_sco"},
49 {STREAM_ENFORCED_AUDIBLE, "enforced_audible"},
50 {STREAM_DTMF, "dtmf"},
51 {STREAM_TTS, "tts"},
52 {STREAM_ACCESSIBILITY, "accessibility"},
53 {STREAM_RECORDING, "recording"},
54 {STREAM_MOVIE, "movie"},
55 {STREAM_GAME, "game"},
56 {STREAM_SPEECH, "speech"},
57 {STREAM_SYSTEM_ENFORCED, "system_enforced"},
58 {STREAM_ULTRASONIC, "ultrasonic"},
59 {STREAM_WAKEUP, "wakeup"},
60 {STREAM_VOICE_MESSAGE, "voice_message"},
61 {STREAM_NAVIGATION, "navigation"},
62 {STREAM_VOICE_COMMUNICATION, "voice_call"},
63 {STREAM_VOICE_RING, "ring"},
64 {STREAM_VOICE_CALL_ASSISTANT, "voice_call_assistant"},
65 {STREAM_CAMCORDER, "camcorder"},
66 };
67
CheckReturnIfinvalid(bool expr,const int32_t retVal)68 static int32_t CheckReturnIfinvalid(bool expr, const int32_t retVal)
69 {
70 do {
71 if (!(expr)) {
72 return retVal;
73 }
74 } while (false);
75 return CHECK_UTIL_SUCCESS;
76 }
77
IsEnhanceMode(SourceType sourceType)78 static bool IsEnhanceMode(SourceType sourceType)
79 {
80 if (sourceType == SOURCE_TYPE_MIC || sourceType == SOURCE_TYPE_VOICE_COMMUNICATION ||
81 sourceType == SOURCE_TYPE_VOICE_CALL) {
82 return true;
83 }
84 return false;
85 }
86
PaAdapterManager(ManagerType type)87 PaAdapterManager::PaAdapterManager(ManagerType type)
88 {
89 AUDIO_INFO_LOG("Constructor with type:%{public}d", type);
90 mainLoop_ = nullptr;
91 api_ = nullptr;
92 context_ = nullptr;
93 isContextConnected_ = false;
94 isMainLoopStarted_ = false;
95 managerType_ = type;
96 }
97
CreateRender(AudioProcessConfig processConfig,std::shared_ptr<IRendererStream> & stream)98 int32_t PaAdapterManager::CreateRender(AudioProcessConfig processConfig, std::shared_ptr<IRendererStream> &stream)
99 {
100 AUDIO_DEBUG_LOG("Create renderer start");
101 int32_t ret = InitPaContext();
102 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Failed to init pa context");
103 uint32_t sessionId = 0;
104 if (managerType_ == DUP_PLAYBACK || managerType_ == DUAL_PLAYBACK ||
105 processConfig.originalSessionId < MIN_SESSIONID || processConfig.originalSessionId > MAX_SESSIONID) {
106 sessionId = PolicyHandler::GetInstance().GenerateSessionId(processConfig.appInfo.appUid);
107 } else {
108 sessionId = processConfig.originalSessionId;
109 }
110 AUDIO_DEBUG_LOG("Create [%{public}d] type renderer:[%{public}u]", managerType_, sessionId);
111
112 // PaAdapterManager is solely responsible for creating paStream objects
113 // while the PaRendererStreamImpl has full authority over the subsequent management of the paStream
114 pa_stream *paStream = InitPaStream(processConfig, sessionId, false);
115 CHECK_AND_RETURN_RET_LOG(paStream != nullptr, ERR_OPERATION_FAILED, "Failed to init render");
116 std::shared_ptr<IRendererStream> rendererStream = CreateRendererStream(processConfig, paStream);
117 CHECK_AND_RETURN_RET_LOG(rendererStream != nullptr, ERR_DEVICE_INIT, "Failed to init pa stream");
118 rendererStream->SetStreamIndex(sessionId);
119 std::lock_guard<std::mutex> lock(streamMapMutex_);
120 rendererStreamMap_[sessionId] = rendererStream;
121 stream = rendererStream;
122 return SUCCESS;
123 }
124
ReleaseRender(uint32_t streamIndex)125 int32_t PaAdapterManager::ReleaseRender(uint32_t streamIndex)
126 {
127 AUDIO_DEBUG_LOG("Release [%{public}d] type render:[%{public}u]", managerType_, streamIndex);
128 std::unique_lock<std::mutex> lock(streamMapMutex_);
129 auto it = rendererStreamMap_.find(streamIndex);
130 if (it == rendererStreamMap_.end()) {
131 AUDIO_WARNING_LOG("No matching stream");
132 return SUCCESS;
133 }
134 std::shared_ptr<IRendererStream> currentRender = rendererStreamMap_[streamIndex];
135 rendererStreamMap_[streamIndex] = nullptr;
136 rendererStreamMap_.erase(streamIndex);
137 lock.unlock();
138
139 if (currentRender->Release() < 0) {
140 AUDIO_WARNING_LOG("Release stream %{public}d failed", streamIndex);
141 return ERR_OPERATION_FAILED;
142 }
143
144 if (isHighResolutionExist_ == true && highResolutionIndex_ == streamIndex) {
145 isHighResolutionExist_ = false;
146 }
147 AUDIO_INFO_LOG("rendererStreamMap_.size() : %{public}zu", rendererStreamMap_.size());
148 if (rendererStreamMap_.size() == 0) {
149 AUDIO_INFO_LOG("Release the last stream");
150 }
151 return SUCCESS;
152 }
153
StartRender(uint32_t streamIndex)154 int32_t PaAdapterManager::StartRender(uint32_t streamIndex)
155 {
156 AUDIO_DEBUG_LOG("Enter StartRender");
157 std::lock_guard<std::mutex> lock(streamMapMutex_);
158 auto it = rendererStreamMap_.find(streamIndex);
159 if (it == rendererStreamMap_.end()) {
160 AUDIO_WARNING_LOG("No matching stream");
161 return SUCCESS;
162 }
163 return rendererStreamMap_[streamIndex]->Start();
164 }
165
StopRender(uint32_t streamIndex)166 int32_t PaAdapterManager::StopRender(uint32_t streamIndex)
167 {
168 AUDIO_DEBUG_LOG("Enter StopRender");
169 std::lock_guard<std::mutex> lock(streamMapMutex_);
170 auto it = rendererStreamMap_.find(streamIndex);
171 if (it == rendererStreamMap_.end()) {
172 AUDIO_WARNING_LOG("No matching stream");
173 return SUCCESS;
174 }
175 return rendererStreamMap_[streamIndex]->Stop();
176 }
177
PauseRender(uint32_t streamIndex)178 int32_t PaAdapterManager::PauseRender(uint32_t streamIndex)
179 {
180 AUDIO_DEBUG_LOG("Enter PauseRender");
181 std::lock_guard<std::mutex> lock(streamMapMutex_);
182 auto it = rendererStreamMap_.find(streamIndex);
183 if (it == rendererStreamMap_.end()) {
184 AUDIO_WARNING_LOG("No matching stream");
185 return SUCCESS;
186 }
187 rendererStreamMap_[streamIndex]->Pause();
188 return SUCCESS;
189 }
190
TriggerStartIfNecessary()191 int32_t PaAdapterManager::TriggerStartIfNecessary()
192 {
193 return SUCCESS;
194 }
195
GetStreamCount() const196 int32_t PaAdapterManager::GetStreamCount() const noexcept
197 {
198 if (managerType_ == RECORDER) {
199 return capturerStreamMap_.size();
200 } else {
201 return rendererStreamMap_.size();
202 }
203 }
204
CreateCapturer(AudioProcessConfig processConfig,std::shared_ptr<ICapturerStream> & stream)205 int32_t PaAdapterManager::CreateCapturer(AudioProcessConfig processConfig, std::shared_ptr<ICapturerStream> &stream)
206 {
207 AUDIO_DEBUG_LOG("Create capturer start");
208 CHECK_AND_RETURN_RET_LOG(managerType_ == RECORDER, ERROR, "Invalid managerType:%{public}d", managerType_);
209 int32_t ret = InitPaContext();
210 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Failed to init pa context");
211 uint32_t sessionId = 0;
212 if (processConfig.originalSessionId < MIN_SESSIONID || processConfig.originalSessionId > MAX_SESSIONID) {
213 sessionId = PolicyHandler::GetInstance().GenerateSessionId(processConfig.appInfo.appUid);
214 } else {
215 sessionId = processConfig.originalSessionId;
216 }
217
218 // PaAdapterManager is solely responsible for creating paStream objects
219 // while the PaCapturerStreamImpl has full authority over the subsequent management of the paStream
220 pa_stream *paStream = InitPaStream(processConfig, sessionId, true);
221 CHECK_AND_RETURN_RET_LOG(paStream != nullptr, ERR_OPERATION_FAILED, "Failed to init capture");
222 std::shared_ptr<ICapturerStream> capturerStream = CreateCapturerStream(processConfig, paStream);
223 CHECK_AND_RETURN_RET_LOG(capturerStream != nullptr, ERR_DEVICE_INIT, "Failed to init pa stream");
224 capturerStream->SetStreamIndex(sessionId);
225 std::lock_guard<std::mutex> lock(streamMapMutex_);
226 capturerStreamMap_[sessionId] = capturerStream;
227 stream = capturerStream;
228 return SUCCESS;
229 }
230
ReleaseCapturer(uint32_t streamIndex)231 int32_t PaAdapterManager::ReleaseCapturer(uint32_t streamIndex)
232 {
233 AUDIO_DEBUG_LOG("Enter ReleaseCapturer");
234 std::lock_guard<std::mutex> lock(streamMapMutex_);
235 auto it = capturerStreamMap_.find(streamIndex);
236 if (it == capturerStreamMap_.end()) {
237 AUDIO_WARNING_LOG("No matching stream");
238 return SUCCESS;
239 }
240
241 if (capturerStreamMap_[streamIndex]->Release() < 0) {
242 AUDIO_WARNING_LOG("Release stream %{public}d failed", streamIndex);
243 return ERR_OPERATION_FAILED;
244 }
245
246 capturerStreamMap_[streamIndex] = nullptr;
247 capturerStreamMap_.erase(streamIndex);
248 if (capturerStreamMap_.size() == 0) {
249 AUDIO_INFO_LOG("Release the last stream");
250 }
251 return SUCCESS;
252 }
253
ResetPaContext()254 int32_t PaAdapterManager::ResetPaContext()
255 {
256 AUDIO_DEBUG_LOG("Enter ResetPaContext");
257 if (context_) {
258 pa_context_set_state_callback(context_, nullptr, nullptr);
259 if (isContextConnected_ == true) {
260 PaLockGuard lock(mainLoop_);
261 pa_context_disconnect(context_);
262 pa_context_unref(context_);
263 isContextConnected_ = false;
264 context_ = nullptr;
265 }
266 }
267
268 if (mainLoop_) {
269 pa_threaded_mainloop_free(mainLoop_);
270 isMainLoopStarted_ = false;
271 mainLoop_ = nullptr;
272 }
273
274 api_ = nullptr;
275 return SUCCESS;
276 }
277
InitPaContext()278 int32_t PaAdapterManager::InitPaContext()
279 {
280 AUDIO_DEBUG_LOG("Enter InitPaContext");
281 std::lock_guard<std::mutex> lock(paElementsMutex_);
282 if (context_ != nullptr) {
283 AUDIO_INFO_LOG("Context is not null, return");
284 return SUCCESS;
285 }
286 mainLoop_ = pa_threaded_mainloop_new();
287 CHECK_AND_RETURN_RET_LOG(mainLoop_ != nullptr, ERR_DEVICE_INIT, "Failed to init pa mainLoop");
288 api_ = pa_threaded_mainloop_get_api(mainLoop_);
289 if (managerType_ == PLAYBACK) {
290 pa_threaded_mainloop_set_name(mainLoop_, "OS_RendererML");
291 } else if (managerType_ == DUP_PLAYBACK) {
292 pa_threaded_mainloop_set_name(mainLoop_, "OS_DRendererML");
293 } else if (managerType_ == DUAL_PLAYBACK) {
294 pa_threaded_mainloop_set_name(mainLoop_, "OS_DualRendererML");
295 } else if (managerType_ == RECORDER) {
296 pa_threaded_mainloop_set_name(mainLoop_, "OS_CapturerML");
297 } else {
298 AUDIO_ERR_LOG("Not supported managerType:%{public}d", managerType_);
299 }
300 if (api_ == nullptr) {
301 AUDIO_ERR_LOG("Get api from mainLoop failed");
302 pa_threaded_mainloop_free(mainLoop_);
303 return ERR_DEVICE_INIT;
304 }
305
306 std::stringstream ss;
307 ss << "app-pid<" << getpid() << ">-uid<" << getuid() << ">";
308 std::string packageName = "";
309 ss >> packageName;
310
311 context_ = pa_context_new(api_, packageName.c_str());
312 if (context_ == nullptr) {
313 AUDIO_ERR_LOG("New context failed");
314 pa_threaded_mainloop_free(mainLoop_);
315 return ERR_DEVICE_INIT;
316 }
317
318 pa_context_set_state_callback(context_, PAContextStateCb, mainLoop_);
319 if (pa_context_connect(context_, nullptr, PA_CONTEXT_NOFAIL, nullptr) < 0) {
320 int error = pa_context_errno(context_);
321 AUDIO_ERR_LOG("Context connect error: %{public}s", pa_strerror(error));
322 return ERR_DEVICE_INIT;
323 }
324 isContextConnected_ = true;
325 CHECK_AND_RETURN_RET_LOG(HandleMainLoopStart() == SUCCESS, ERR_DEVICE_INIT, "Failed to start pa mainLoop");
326
327 return SUCCESS;
328 }
329
HandleMainLoopStart()330 int32_t PaAdapterManager::HandleMainLoopStart()
331 {
332 if (pa_threaded_mainloop_start(mainLoop_) < 0) {
333 return ERR_DEVICE_INIT;
334 }
335
336 PaLockGuard lock(mainLoop_);
337 isMainLoopStarted_ = true;
338
339 while (true) {
340 pa_context_state_t state = pa_context_get_state(context_);
341 if (state == PA_CONTEXT_READY) {
342 AUDIO_INFO_LOG("pa context is ready");
343 break;
344 }
345
346 if (!PA_CONTEXT_IS_GOOD(state)) {
347 int error = pa_context_errno(context_);
348 AUDIO_ERR_LOG("Context bad state error: %{public}s", pa_strerror(error));
349 lock.Unlock();
350 ResetPaContext();
351 return ERR_DEVICE_INIT;
352 }
353 pa_threaded_mainloop_wait(mainLoop_);
354 }
355 return SUCCESS;
356 }
357
GetDeviceNameForConnect(AudioProcessConfig processConfig,uint32_t sessionId,std::string & deviceName)358 int32_t PaAdapterManager::GetDeviceNameForConnect(AudioProcessConfig processConfig, uint32_t sessionId,
359 std::string &deviceName)
360 {
361 deviceName = "";
362 if (processConfig.audioMode == AUDIO_MODE_RECORD) {
363 if (processConfig.isWakeupCapturer) {
364 int32_t ret = PolicyHandler::GetInstance().SetWakeUpAudioCapturerFromAudioServer(processConfig);
365 if (ret < 0) {
366 AUDIO_ERR_LOG("ErrorCode: %{public}d", ret);
367 return ERROR;
368 }
369 deviceName = PRIMARY_WAKEUP;
370 }
371 if (processConfig.isInnerCapturer) {
372 if (processConfig.innerCapMode == MODERN_INNER_CAP) {
373 AUDIO_INFO_LOG("Create the modern inner-cap.");
374 deviceName = NEW_INNER_CAPTURER_SOURCE;
375 } else {
376 deviceName = INNER_CAPTURER_SOURCE;
377 }
378 } else if (processConfig.capturerInfo.sourceType == SOURCE_TYPE_REMOTE_CAST) {
379 deviceName = REMOTE_CAST_INNER_CAPTURER_SINK_NAME + MONITOR_SOURCE_SUFFIX;
380 }
381 return PolicyHandler::GetInstance().NotifyCapturerAdded(processConfig.capturerInfo,
382 processConfig.streamInfo, sessionId);
383 }
384 return SUCCESS;
385 }
386
InitPaStream(AudioProcessConfig processConfig,uint32_t sessionId,bool isRecording)387 pa_stream *PaAdapterManager::InitPaStream(AudioProcessConfig processConfig, uint32_t sessionId, bool isRecording)
388 {
389 AUDIO_DEBUG_LOG("Enter InitPaStream");
390 std::lock_guard<std::mutex> lock(paElementsMutex_);
391 PaLockGuard palock(mainLoop_);
392 if (CheckReturnIfinvalid(mainLoop_ && context_, ERR_ILLEGAL_STATE) < 0) {
393 AUDIO_ERR_LOG("CheckReturnIfinvalid failed");
394 return nullptr;
395 }
396
397 // Use struct to save spec size
398 pa_sample_spec sampleSpec = ConvertToPAAudioParams(processConfig);
399 pa_proplist *propList = pa_proplist_new();
400 CHECK_AND_RETURN_RET_LOG(propList != nullptr, nullptr, "pa_proplist_new failed");
401
402 const std::string streamName = GetStreamName(processConfig.streamType);
403 pa_channel_map map;
404 if (SetPaProplist(propList, map, processConfig, streamName, sessionId) != 0) {
405 AUDIO_ERR_LOG("set pa proplist failed");
406 pa_proplist_free(propList);
407 return nullptr;
408 }
409
410 pa_stream *paStream = pa_stream_new_with_proplist(context_, streamName.c_str(), &sampleSpec,
411 isRecording ? nullptr : &map, propList);
412 if (!paStream) {
413 int32_t error = pa_context_errno(context_);
414 AUDIO_ERR_LOG("pa_stream_new_with_proplist failed, error: %{public}d", error);
415 pa_proplist_free(propList);
416 return nullptr;
417 }
418
419 pa_proplist_free(propList);
420 pa_stream_set_state_callback(paStream, PAStreamStateCb, reinterpret_cast<void *>(this));
421 palock.Unlock();
422
423 std::string deviceName;
424 int32_t errorCode = GetDeviceNameForConnect(processConfig, sessionId, deviceName);
425 if (errorCode != SUCCESS) {
426 AUDIO_ERR_LOG("getdevicename err: %{public}d", errorCode);
427 ReleasePaStream(paStream);
428 return nullptr;
429 }
430
431 int32_t ret = ConnectStreamToPA(paStream, sampleSpec, processConfig.capturerInfo.sourceType, deviceName);
432 if (ret < 0) {
433 AUDIO_ERR_LOG("ConnectStreamToPA Failed");
434 ReleasePaStream(paStream);
435 return nullptr;
436 }
437 if (processConfig.audioMode == AUDIO_MODE_RECORD) {
438 ret = SetStreamAudioEnhanceMode(paStream, enhanceMode_);
439 if (ret != SUCCESS) {
440 AUDIO_ERR_LOG("capturer set audio enhance mode failed.");
441 }
442 }
443 return paStream;
444 }
445
ReleasePaStream(pa_stream * paStream)446 void PaAdapterManager::ReleasePaStream(pa_stream *paStream)
447 {
448 if (!paStream) {
449 AUDIO_INFO_LOG("paStream is nullptr. No need to release.");
450 return;
451 }
452 if (!mainLoop_) {
453 AUDIO_ERR_LOG("mainLoop_ is nullptr!");
454 return;
455 }
456
457 PaLockGuard palock(mainLoop_);
458 pa_stream_set_state_callback(paStream, nullptr, nullptr);
459
460 pa_stream_state_t state = pa_stream_get_state(paStream);
461 if (state == PA_STREAM_UNCONNECTED) {
462 AUDIO_INFO_LOG("Release paStream unconnected");
463 pa_stream_terminate(paStream);
464 }
465 pa_stream_unref(paStream);
466 AUDIO_INFO_LOG("Release paStream because of errs");
467 }
468
IsEffectNone(StreamUsage streamUsage)469 bool PaAdapterManager::IsEffectNone(StreamUsage streamUsage)
470 {
471 if (streamUsage == STREAM_USAGE_SYSTEM || streamUsage == STREAM_USAGE_DTMF ||
472 streamUsage == STREAM_USAGE_ENFORCED_TONE || streamUsage == STREAM_USAGE_ULTRASONIC ||
473 streamUsage == STREAM_USAGE_NAVIGATION || streamUsage == STREAM_USAGE_NOTIFICATION) {
474 return true;
475 }
476 return false;
477 }
478
CheckHighResolution(const AudioProcessConfig & processConfig)479 bool PaAdapterManager::CheckHighResolution(const AudioProcessConfig &processConfig)
480 {
481 DeviceType deviceType = processConfig.deviceType;
482 AudioStreamType streamType = processConfig.streamType;
483 AudioSamplingRate sampleRate = processConfig.streamInfo.samplingRate;
484 AudioSampleFormat sampleFormat = processConfig.streamInfo.format;
485
486 AUDIO_DEBUG_LOG("deviceType:%{public}d, streamType:%{public}d, sampleRate:%{public}d, sampleFormat:%{public}d",
487 deviceType, streamType, sampleRate, sampleFormat);
488
489 if (deviceType == DEVICE_TYPE_BLUETOOTH_A2DP && streamType == STREAM_MUSIC &&
490 sampleRate >= SAMPLE_RATE_48000 && sampleFormat >= SAMPLE_S24LE) {
491 return true;
492 }
493 return false;
494 }
495
SetHighResolution(pa_proplist * propList,AudioProcessConfig & processConfig,uint32_t sessionId)496 void PaAdapterManager::SetHighResolution(pa_proplist *propList, AudioProcessConfig &processConfig, uint32_t sessionId)
497 {
498 bool spatializationEnabled = processConfig.rendererInfo.spatializationEnabled;
499 AUDIO_DEBUG_LOG("spatializationEnabled : %{public}d, isHighResolutionExist_ : %{public}d",
500 spatializationEnabled, isHighResolutionExist_);
501
502 if (spatializationEnabled == false && isHighResolutionExist_ == false && CheckHighResolution(processConfig)) {
503 AUDIO_INFO_LOG("current stream marked as high resolution");
504 pa_proplist_sets(propList, "stream.highResolution", "1");
505 isHighResolutionExist_ = true;
506 highResolutionIndex_ = sessionId;
507 } else {
508 AUDIO_INFO_LOG("current stream marked as non-high resolution");
509 pa_proplist_sets(propList, "stream.highResolution", "0");
510 }
511 }
512
SetRecordProplist(pa_proplist * propList,AudioProcessConfig & processConfig)513 void PaAdapterManager::SetRecordProplist(pa_proplist *propList, AudioProcessConfig &processConfig)
514 {
515 pa_proplist_sets(propList, "stream.isInnerCapturer", std::to_string(processConfig.isInnerCapturer).c_str());
516 pa_proplist_sets(propList, "stream.isWakeupCapturer", std::to_string(processConfig.isWakeupCapturer).c_str());
517 pa_proplist_sets(propList, "stream.isIpcCapturer", std::to_string(true).c_str());
518 pa_proplist_sets(propList, "stream.capturerSource",
519 std::to_string(processConfig.capturerInfo.sourceType).c_str());
520 pa_proplist_sets(propList, "scene.type", GetEnhanceSceneName(processConfig.capturerInfo.sourceType).c_str());
521 enhanceMode_ = IsEnhanceMode(processConfig.capturerInfo.sourceType) ? EFFECT_DEFAULT : EFFECT_NONE;
522 pa_proplist_sets(propList, "scene.mode", GetEnhanceModeName(enhanceMode_).c_str());
523 }
524
SetPaProplist(pa_proplist * propList,pa_channel_map & map,AudioProcessConfig & processConfig,const std::string & streamName,uint32_t sessionId)525 int32_t PaAdapterManager::SetPaProplist(pa_proplist *propList, pa_channel_map &map, AudioProcessConfig &processConfig,
526 const std::string &streamName, uint32_t sessionId)
527 {
528 // for remote audio device router filter
529 pa_proplist_sets(propList, "stream.sessionID", std::to_string(sessionId).c_str());
530 pa_proplist_sets(propList, "stream.client.uid", std::to_string(processConfig.appInfo.appUid).c_str());
531 pa_proplist_sets(propList, "stream.client.pid", std::to_string(processConfig.appInfo.appPid).c_str());
532 pa_proplist_sets(propList, "stream.type", streamName.c_str());
533 pa_proplist_sets(propList, "media.name", streamName.c_str());
534
535 float mVolumeFactor = 1.0f;
536 float mPowerVolumeFactor = 1.0f;
537 float mDuckVolumeFactor = 1.0f;
538 pa_proplist_sets(propList, "stream.volumeFactor", std::to_string(mVolumeFactor).c_str());
539 pa_proplist_sets(propList, "stream.powerVolumeFactor", std::to_string(mPowerVolumeFactor).c_str());
540 pa_proplist_sets(propList, "stream.duckVolumeFactor", std::to_string(mDuckVolumeFactor).c_str());
541 auto timenow = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
542 const std::string streamStartTime = ctime(&timenow);
543 pa_proplist_sets(propList, "stream.startTime", streamStartTime.c_str());
544
545 if (processConfig.audioMode == AUDIO_MODE_PLAYBACK) {
546 pa_proplist_sets(propList, "scene.mode",
547 IsEffectNone(processConfig.rendererInfo.streamUsage) ? "EFFECT_NONE" : "EFFECT_DEFAULT");
548 // mark dup stream for dismissing volume handle
549 std::string streamMode = managerType_ == DUP_PLAYBACK ? DUP_STREAM
550 : (managerType_ == DUAL_PLAYBACK ? DUAL_TONE_STREAM : NORMAL_STREAM);
551 pa_proplist_sets(propList, "stream.mode", streamMode.c_str());
552 pa_proplist_sets(propList, "stream.flush", "false");
553 pa_proplist_sets(propList, "spatialization.enabled", "0");
554 pa_proplist_sets(propList, "fadeoutPause", "0");
555 pa_proplist_sets(propList, "stream.privacyType", std::to_string(processConfig.privacyType).c_str());
556 pa_proplist_sets(propList, "stream.usage", std::to_string(processConfig.rendererInfo.streamUsage).c_str());
557 pa_proplist_sets(propList, "scene.type", processConfig.rendererInfo.sceneType.c_str());
558 pa_proplist_sets(propList, "stream.usage", std::to_string(processConfig.rendererInfo.streamUsage).c_str());
559 pa_proplist_sets(propList, "spatialization.enabled",
560 std::to_string(processConfig.rendererInfo.spatializationEnabled).c_str());
561 pa_proplist_sets(propList, "headtracking.enabled",
562 std::to_string(processConfig.rendererInfo.headTrackingEnabled).c_str());
563 SetHighResolution(propList, processConfig, sessionId);
564 } else if (processConfig.audioMode == AUDIO_MODE_RECORD) {
565 SetRecordProplist(propList, processConfig);
566 }
567
568 AUDIO_INFO_LOG("Creating stream of channels %{public}d", processConfig.streamInfo.channels);
569 if (processConfig.streamInfo.channelLayout == 0) {
570 processConfig.streamInfo.channelLayout = defaultChCountToLayoutMap[processConfig.streamInfo.channels];
571 }
572 pa_proplist_sets(propList, "stream.channelLayout", std::to_string(processConfig.streamInfo.channelLayout).c_str());
573
574 pa_channel_map_init(&map);
575 map.channels = processConfig.streamInfo.channels;
576 uint32_t channelsInLayout = ConvertChLayoutToPaChMap(processConfig.streamInfo.channelLayout, map);
577 CHECK_AND_RETURN_RET_LOG(channelsInLayout == processConfig.streamInfo.channels && channelsInLayout != 0,
578 ERR_INVALID_PARAM, "Invalid channel Layout");
579 return SUCCESS;
580 }
581
CreateRendererStream(AudioProcessConfig processConfig,pa_stream * paStream)582 std::shared_ptr<IRendererStream> PaAdapterManager::CreateRendererStream(AudioProcessConfig processConfig,
583 pa_stream *paStream)
584 {
585 std::lock_guard<std::mutex> lock(paElementsMutex_);
586 std::shared_ptr<PaRendererStreamImpl> rendererStream =
587 std::make_shared<PaRendererStreamImpl>(paStream, processConfig, mainLoop_);
588 if (rendererStream->InitParams() != SUCCESS) {
589 int32_t error = pa_context_errno(context_);
590 AUDIO_ERR_LOG("Create rendererStream Failed, error: %{public}d", error);
591 return nullptr;
592 }
593 return rendererStream;
594 }
595
CreateCapturerStream(AudioProcessConfig processConfig,pa_stream * paStream)596 std::shared_ptr<ICapturerStream> PaAdapterManager::CreateCapturerStream(AudioProcessConfig processConfig,
597 pa_stream *paStream)
598 {
599 std::lock_guard<std::mutex> lock(paElementsMutex_);
600 std::shared_ptr<PaCapturerStreamImpl> capturerStream =
601 std::make_shared<PaCapturerStreamImpl>(paStream, processConfig, mainLoop_);
602 if (capturerStream->InitParams() != SUCCESS) {
603 int32_t error = pa_context_errno(context_);
604 AUDIO_ERR_LOG("Create capturerStream Failed, error: %{public}d", error);
605 return nullptr;
606 }
607 return capturerStream;
608 }
609
ConnectStreamToPA(pa_stream * paStream,pa_sample_spec sampleSpec,SourceType source,const std::string & deviceName)610 int32_t PaAdapterManager::ConnectStreamToPA(pa_stream *paStream, pa_sample_spec sampleSpec,
611 SourceType source, const std::string &deviceName)
612 {
613 AUDIO_DEBUG_LOG("Enter PaAdapterManager::ConnectStreamToPA");
614 if (CheckReturnIfinvalid(mainLoop_ && context_ && paStream, ERROR) < 0) {
615 return ERR_ILLEGAL_STATE;
616 }
617
618 PaLockGuard lock(mainLoop_);
619 int32_t XcollieFlag = 1; // flag 1 generate log file
620 if (managerType_ == PLAYBACK || managerType_ == DUP_PLAYBACK || managerType_ == DUAL_PLAYBACK) {
621 int32_t rendererRet = ConnectRendererStreamToPA(paStream, sampleSpec);
622 CHECK_AND_RETURN_RET_LOG(rendererRet == SUCCESS, rendererRet, "ConnectRendererStreamToPA failed");
623 }
624 if (managerType_ == RECORDER) {
625 XcollieFlag = (1 | 2); // flag 1 generate log file, flag 2 die when timeout, restart server
626 int32_t capturerRet = ConnectCapturerStreamToPA(paStream, sampleSpec, source, deviceName);
627 CHECK_AND_RETURN_RET_LOG(capturerRet == SUCCESS, capturerRet, "ConnectCapturerStreamToPA failed");
628 }
629 while (waitConnect_) {
630 pa_stream_state_t state = pa_stream_get_state(paStream);
631 if (state == PA_STREAM_READY) {
632 AUDIO_INFO_LOG("PaStream is ready");
633 break;
634 }
635 if (!PA_STREAM_IS_GOOD(state)) {
636 int32_t error = pa_context_errno(context_);
637 AUDIO_ERR_LOG("connection to stream error: %{public}s, state: %{public}d", pa_strerror(error), state);
638 return ERR_INVALID_OPERATION;
639 }
640 AudioXCollie audioXCollie("PaAdapterManager::ConnectStreamToPA", CONNECT_STREAM_TIMEOUT_IN_SEC,
641 [this](void *) {
642 AUDIO_ERR_LOG("ConnectStreamToPA timeout");
643 waitConnect_ = false;
644 }, nullptr, XcollieFlag);
645 pa_threaded_mainloop_wait(mainLoop_);
646 }
647 return SUCCESS;
648 }
649
ConnectRendererStreamToPA(pa_stream * paStream,pa_sample_spec sampleSpec)650 int32_t PaAdapterManager::ConnectRendererStreamToPA(pa_stream *paStream, pa_sample_spec sampleSpec)
651 {
652 uint32_t tlength = 4; // 4 is tlength of playback
653 uint32_t maxlength = 4; // 4 is max buffer length of playback
654 uint32_t prebuf = 1; // 1 is prebuf of playback
655
656 if (managerType_ == DUP_PLAYBACK || managerType_ == DUAL_PLAYBACK) {
657 maxlength = 20; // 20 for cover offload
658 prebuf = 2; // 2 is double of normal, use more prebuf for dup stream
659 }
660 AUDIO_INFO_LOG("Create ipc playback stream tlength: %{public}u, maxlength: %{public}u prebuf: %{public}u", tlength,
661 maxlength, prebuf);
662 pa_buffer_attr bufferAttr;
663 bufferAttr.fragsize = static_cast<uint32_t>(-1);
664 bufferAttr.prebuf = pa_usec_to_bytes(BUF_LENGTH_IN_MSEC * PA_USEC_PER_MSEC * prebuf, &sampleSpec);
665 bufferAttr.maxlength = pa_usec_to_bytes(BUF_LENGTH_IN_MSEC * PA_USEC_PER_MSEC * maxlength, &sampleSpec);
666 bufferAttr.tlength = pa_usec_to_bytes(BUF_LENGTH_IN_MSEC * PA_USEC_PER_MSEC * tlength, &sampleSpec);
667 bufferAttr.minreq = pa_usec_to_bytes(BUF_LENGTH_IN_MSEC * PA_USEC_PER_MSEC, &sampleSpec);
668
669 const char *sinkName = managerType_ == DUP_PLAYBACK ? INNER_CAPTURER_SINK.c_str() :
670 (managerType_ == DUAL_PLAYBACK ? "Speaker" : nullptr);
671 uint32_t flags = PA_STREAM_ADJUST_LATENCY | PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_START_CORKED |
672 PA_STREAM_VARIABLE_RATE;
673 if (managerType_ == DUP_PLAYBACK || managerType_ == DUAL_PLAYBACK) {
674 flags |= PA_STREAM_DONT_MOVE; // should not move dup streams
675 }
676 int32_t result = pa_stream_connect_playback(paStream, sinkName, &bufferAttr, static_cast<pa_stream_flags_t>(flags),
677 nullptr, nullptr);
678 if (result < 0) {
679 int32_t error = pa_context_errno(context_);
680 AUDIO_ERR_LOG("connection to stream error: %{public}d -- %{public}s,result:%{public}d", error,
681 pa_strerror(error), result);
682 return ERR_INVALID_OPERATION;
683 }
684 return SUCCESS;
685 }
686
ConnectCapturerStreamToPA(pa_stream * paStream,pa_sample_spec sampleSpec,SourceType source,const std::string & deviceName)687 int32_t PaAdapterManager::ConnectCapturerStreamToPA(pa_stream *paStream, pa_sample_spec sampleSpec,
688 SourceType source, const std::string &deviceName)
689 {
690 uint32_t fragsize = 1; // 1 is frag size of recorder
691 uint32_t maxlength = (source == SOURCE_TYPE_WAKEUP) ? PA_RECORD_MAX_LENGTH_WAKEUP : PA_RECORD_MAX_LENGTH_NORMAL;
692 pa_buffer_attr bufferAttr;
693 bufferAttr.maxlength = pa_usec_to_bytes(BUF_LENGTH_IN_MSEC * PA_USEC_PER_MSEC * maxlength, &sampleSpec);
694 bufferAttr.fragsize = pa_usec_to_bytes(BUF_LENGTH_IN_MSEC * PA_USEC_PER_MSEC * fragsize, &sampleSpec);
695 AUDIO_INFO_LOG("bufferAttr, maxLength: %{public}d, fragsize: %{public}d",
696 bufferAttr.maxlength, bufferAttr.fragsize);
697
698 const char *cDeviceName = (deviceName == "") ? nullptr : deviceName.c_str();
699
700 uint32_t flags = PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_START_CORKED | PA_STREAM_VARIABLE_RATE;
701 if (source == SOURCE_TYPE_PLAYBACK_CAPTURE) {
702 flags |= PA_STREAM_DONT_MOVE; //inner cap source-output,should not be moved!
703 }
704 int32_t result = pa_stream_connect_record(paStream, cDeviceName, &bufferAttr,
705 static_cast<pa_stream_flags_t>(flags));
706 // PA_STREAM_ADJUST_LATENCY exist, return peek length from server;
707 if (result < 0) {
708 int32_t error = pa_context_errno(context_);
709 AUDIO_ERR_LOG("connection to stream error: %{public}d -- %{public}s,result:%{public}d", error,
710 pa_strerror(error), result);
711 return ERR_INVALID_OPERATION;
712 }
713 return SUCCESS;
714 }
715
SetStreamAudioEnhanceMode(pa_stream * paStream,AudioEffectMode audioEnhanceMode)716 int32_t PaAdapterManager::SetStreamAudioEnhanceMode(pa_stream *paStream, AudioEffectMode audioEnhanceMode)
717 {
718 PaLockGuard lock(mainLoop_);
719 pa_proplist *propList = pa_proplist_new();
720 if (propList == nullptr) {
721 AUDIO_ERR_LOG("pa_proplist_new failed.");
722 return ERROR;
723 }
724 std::string upDevice = "DEVICE_TYPE_MIC";
725 std::string downDevice = "DEVICE_TYPE_SPEAKER";
726 std::string upAndDownDevice = upDevice + "_&_" + downDevice;
727 pa_proplist_sets(propList, "device.upAndDown", upAndDownDevice.c_str());
728 pa_operation *updatePropOperation = pa_stream_proplist_update(paStream, PA_UPDATE_REPLACE, propList,
729 nullptr, nullptr);
730 if (updatePropOperation == nullptr) {
731 AUDIO_ERR_LOG("pa_stream_proplist_update failed.");
732 return ERROR;
733 }
734 pa_proplist_free(propList);
735 pa_operation_unref(updatePropOperation);
736 return SUCCESS;
737 }
738
GetEnhanceModeName(AudioEffectMode audioEnhanceMode)739 const std::string PaAdapterManager::GetEnhanceModeName(AudioEffectMode audioEnhanceMode)
740 {
741 std::string name;
742 switch (audioEnhanceMode) {
743 case AudioEffectMode::EFFECT_NONE:
744 name = "EFFECT_NONE";
745 break;
746 case AudioEffectMode::EFFECT_DEFAULT:
747 name = "EFFECT_DEFAULT";
748 break;
749 default:
750 name = "EFFECT_DEFAULT";
751 break;
752 }
753 const std::string modeName = name;
754 return modeName;
755 }
756
PAStreamUpdateStreamIndexSuccessCb(pa_stream * stream,int32_t success,void * userdata)757 void PaAdapterManager::PAStreamUpdateStreamIndexSuccessCb(pa_stream *stream, int32_t success, void *userdata)
758 {
759 AUDIO_DEBUG_LOG("PAStreamUpdateStreamIndexSuccessCb in");
760 }
761
PAContextStateCb(pa_context * context,void * userdata)762 void PaAdapterManager::PAContextStateCb(pa_context *context, void *userdata)
763 {
764 pa_threaded_mainloop *mainLoop = reinterpret_cast<pa_threaded_mainloop *>(userdata);
765 AUDIO_INFO_LOG("Current Context State: %{public}d", pa_context_get_state(context));
766 ScheduleThreadInServer(getpid(), gettid());
767
768 switch (pa_context_get_state(context)) {
769 case PA_CONTEXT_READY:
770 pa_threaded_mainloop_signal(mainLoop, 0);
771 break;
772 case PA_CONTEXT_TERMINATED:
773 case PA_CONTEXT_FAILED:
774 pa_threaded_mainloop_signal(mainLoop, 0);
775 break;
776
777 case PA_CONTEXT_UNCONNECTED:
778 case PA_CONTEXT_CONNECTING:
779 case PA_CONTEXT_AUTHORIZING:
780 case PA_CONTEXT_SETTING_NAME:
781 default:
782 break;
783 }
784 }
785
PAStreamStateCb(pa_stream * stream,void * userdata)786 void PaAdapterManager::PAStreamStateCb(pa_stream *stream, void *userdata)
787 {
788 if (!userdata) {
789 AUDIO_ERR_LOG("PAStreamStateCb: userdata is null");
790 return;
791 }
792 PaAdapterManager *adapterManger = reinterpret_cast<PaAdapterManager *>(userdata);
793 AUDIO_INFO_LOG("Current Stream State: %{public}d", pa_stream_get_state(stream));
794 switch (pa_stream_get_state(stream)) {
795 case PA_STREAM_READY:
796 case PA_STREAM_FAILED:
797 case PA_STREAM_TERMINATED:
798 pa_threaded_mainloop_signal(adapterManger->mainLoop_, 0);
799 break;
800 case PA_STREAM_UNCONNECTED:
801 case PA_STREAM_CREATING:
802 default:
803 break;
804 }
805 }
806
GetStreamName(AudioStreamType audioType)807 const std::string PaAdapterManager::GetStreamName(AudioStreamType audioType)
808 {
809 std::string name = "unknown";
810 if (STREAM_TYPE_ENUM_STRING_MAP.find(audioType) != STREAM_TYPE_ENUM_STRING_MAP.end()) {
811 name = STREAM_TYPE_ENUM_STRING_MAP.at(audioType);
812 } else {
813 AUDIO_ERR_LOG("GetStreamName: Invalid stream type [%{public}d], return unknown", audioType);
814 }
815 const std::string streamName = name;
816 return streamName;
817 }
818
ConvertToPAAudioParams(AudioProcessConfig processConfig)819 pa_sample_spec PaAdapterManager::ConvertToPAAudioParams(AudioProcessConfig processConfig)
820 {
821 pa_sample_spec paSampleSpec;
822 paSampleSpec.channels = processConfig.streamInfo.channels;
823 paSampleSpec.rate = processConfig.streamInfo.samplingRate;
824 switch (processConfig.streamInfo.format) {
825 case SAMPLE_U8:
826 paSampleSpec.format = (pa_sample_format_t)PA_SAMPLE_U8;
827 break;
828 case SAMPLE_S16LE:
829 paSampleSpec.format = (pa_sample_format_t)PA_SAMPLE_S16LE;
830 break;
831 case SAMPLE_S24LE:
832 paSampleSpec.format = (pa_sample_format_t)PA_SAMPLE_S24LE;
833 break;
834 case SAMPLE_S32LE:
835 paSampleSpec.format = (pa_sample_format_t)PA_SAMPLE_S32LE;
836 break;
837 default:
838 paSampleSpec.format = (pa_sample_format_t)PA_SAMPLE_INVALID;
839 break;
840 }
841 return paSampleSpec;
842 }
843
844
ConvertChLayoutToPaChMap(const uint64_t & channelLayout,pa_channel_map & paMap)845 uint32_t PaAdapterManager::ConvertChLayoutToPaChMap(const uint64_t &channelLayout, pa_channel_map &paMap)
846 {
847 if (channelLayout == CH_LAYOUT_MONO) {
848 pa_channel_map_init_mono(&paMap);
849 return AudioChannel::MONO;
850 }
851 uint32_t channelNum = 0;
852 uint64_t mode = (channelLayout & CH_MODE_MASK) >> CH_MODE_OFFSET;
853 switch (mode) {
854 case 0: {
855 for (auto bit = chSetToPaPositionMap.begin(); bit != chSetToPaPositionMap.end(); ++bit) {
856 if (channelNum >= PA_CHANNELS_MAX) {
857 return 0;
858 }
859 if ((channelLayout & (bit->first)) != 0) {
860 paMap.map[channelNum++] = bit->second;
861 }
862 }
863 break;
864 }
865 case 1: {
866 uint64_t order = (channelLayout & CH_HOA_ORDNUM_MASK) >> CH_HOA_ORDNUM_OFFSET;
867 channelNum = (order + 1) * (order + 1);
868 if (channelNum > PA_CHANNELS_MAX) {
869 return 0;
870 }
871 for (uint32_t i = 0; i < channelNum; ++i) {
872 paMap.map[i] = chSetToPaPositionMap[FRONT_LEFT];
873 }
874 break;
875 }
876 default:
877 channelNum = 0;
878 break;
879 }
880 return channelNum;
881 }
882
GetEnhanceSceneName(SourceType sourceType)883 const std::string PaAdapterManager::GetEnhanceSceneName(SourceType sourceType)
884 {
885 std::string name;
886 switch (sourceType) {
887 case SOURCE_TYPE_MIC:
888 case SOURCE_TYPE_CAMCORDER:
889 name = "SCENE_RECORD";
890 break;
891 case SOURCE_TYPE_VOICE_CALL:
892 case SOURCE_TYPE_VOICE_COMMUNICATION:
893 name = "SCENE_VOIP_3A";
894 break;
895 default:
896 name = "SCENE_OTHERS";
897 }
898 const std::string sceneName = name;
899 return sceneName;
900 }
901
902 } // namespace AudioStandard
903 } // namespace OHOS
904