1 /*
2 * Copyright (c) 2021-2024 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 "AudioRenderer"
17 #endif
18
19 #include <sstream>
20 #include "securec.h"
21 #include <atomic>
22 #include <cinttypes>
23 #include <memory>
24
25 #include "audio_renderer.h"
26 #include "audio_renderer_private.h"
27
28 #include "audio_renderer_log.h"
29 #include "audio_errors.h"
30 #include "audio_policy_manager.h"
31 #include "audio_utils.h"
32
33 #include "media_monitor_manager.h"
34
35 namespace OHOS {
36 namespace AudioStandard {
37
38 static const std::vector<StreamUsage> NEED_VERIFY_PERMISSION_STREAMS = {
39 STREAM_USAGE_SYSTEM,
40 STREAM_USAGE_DTMF,
41 STREAM_USAGE_ENFORCED_TONE,
42 STREAM_USAGE_ULTRASONIC,
43 STREAM_USAGE_VOICE_MODEM_COMMUNICATION
44 };
45 static constexpr uid_t UID_MSDP_SA = 6699;
46 static constexpr int32_t WRITE_UNDERRUN_NUM = 100;
47 constexpr int32_t TIME_OUT_SECONDS = 10;
48
SetStreamInfoToParams(const AudioStreamInfo & streamInfo)49 static AudioRendererParams SetStreamInfoToParams(const AudioStreamInfo &streamInfo)
50 {
51 AudioRendererParams params;
52 params.sampleFormat = streamInfo.format;
53 params.sampleRate = streamInfo.samplingRate;
54 params.channelCount = streamInfo.channels;
55 params.encodingType = streamInfo.encoding;
56 params.channelLayout = streamInfo.channelLayout;
57 return params;
58 }
59
60 std::mutex AudioRenderer::createRendererMutex_;
61
62 AudioRenderer::~AudioRenderer() = default;
~AudioRendererPrivate()63 AudioRendererPrivate::~AudioRendererPrivate()
64 {
65 AUDIO_INFO_LOG("Destruct in");
66 abortRestore_ = true;
67
68 std::shared_ptr<OutputDeviceChangeWithInfoCallbackImpl> outputDeviceChangeCallback = outputDeviceChangeCallback_;
69 if (outputDeviceChangeCallback != nullptr) {
70 outputDeviceChangeCallback->RemoveCallback();
71 outputDeviceChangeCallback->UnsetAudioRendererObj();
72 }
73 std::shared_ptr<AudioRendererConcurrencyCallbackImpl> cb = audioConcurrencyCallback_;
74 if (cb != nullptr) {
75 cb->UnsetAudioRendererObj();
76 AudioPolicyManager::GetInstance().UnsetAudioConcurrencyCallback(sessionID_);
77 }
78 for (auto id : usedSessionId_) {
79 AudioPolicyManager::GetInstance().UnregisterDeviceChangeWithInfoCallback(id);
80 }
81
82 RendererState state = GetStatus();
83 if (state != RENDERER_RELEASED && state != RENDERER_NEW) {
84 Release();
85 }
86
87 if (rendererProxyObj_ != nullptr) {
88 rendererProxyObj_->UnsetRendererObj();
89 }
90
91 RemoveRendererPolicyServiceDiedCallback();
92 DumpFileUtil::CloseDumpFile(&dumpFile_);
93 }
94
CheckMaxRendererInstances()95 int32_t AudioRenderer::CheckMaxRendererInstances()
96 {
97 int32_t ret = AudioPolicyManager::GetInstance().CheckMaxRendererInstances();
98 if (ret == ERR_OVERFLOW) {
99 return ret;
100 }
101 return SUCCESS;
102 }
103
GetFormatSize(const AudioStreamParams & info)104 size_t GetFormatSize(const AudioStreamParams& info)
105 {
106 size_t bitWidthSize = 0;
107 switch (info.format) {
108 case SAMPLE_U8:
109 bitWidthSize = 1; // size is 1
110 break;
111 case SAMPLE_S16LE:
112 bitWidthSize = 2; // size is 2
113 break;
114 case SAMPLE_S24LE:
115 bitWidthSize = 3; // size is 3
116 break;
117 case SAMPLE_S32LE:
118 bitWidthSize = 4; // size is 4
119 break;
120 default:
121 bitWidthSize = 2; // size is 2
122 break;
123 }
124 return bitWidthSize;
125 }
126
Create(AudioStreamType audioStreamType)127 std::unique_ptr<AudioRenderer> AudioRenderer::Create(AudioStreamType audioStreamType)
128 {
129 AppInfo appInfo = {};
130 return Create(audioStreamType, appInfo);
131 }
132
Create(AudioStreamType audioStreamType,const AppInfo & appInfo)133 std::unique_ptr<AudioRenderer> AudioRenderer::Create(AudioStreamType audioStreamType, const AppInfo &appInfo)
134 {
135 if (audioStreamType == STREAM_MEDIA) {
136 audioStreamType = STREAM_MUSIC;
137 }
138
139 return std::make_unique<AudioRendererPrivate>(audioStreamType, appInfo, true);
140 }
141
Create(const AudioRendererOptions & rendererOptions)142 std::unique_ptr<AudioRenderer> AudioRenderer::Create(const AudioRendererOptions &rendererOptions)
143 {
144 AppInfo appInfo = {};
145 return Create("", rendererOptions, appInfo);
146 }
147
Create(const AudioRendererOptions & rendererOptions,const AppInfo & appInfo)148 std::unique_ptr<AudioRenderer> AudioRenderer::Create(const AudioRendererOptions &rendererOptions,
149 const AppInfo &appInfo)
150 {
151 return Create("", rendererOptions, appInfo);
152 }
153
Create(const std::string cachePath,const AudioRendererOptions & rendererOptions)154 std::unique_ptr<AudioRenderer> AudioRenderer::Create(const std::string cachePath,
155 const AudioRendererOptions &rendererOptions)
156 {
157 AppInfo appInfo = {};
158 return Create(cachePath, rendererOptions, appInfo);
159 }
160
Create(const std::string cachePath,const AudioRendererOptions & rendererOptions,const AppInfo & appInfo)161 std::unique_ptr<AudioRenderer> AudioRenderer::Create(const std::string cachePath,
162 const AudioRendererOptions &rendererOptions, const AppInfo &appInfo)
163 {
164 Trace trace("AudioRenderer::Create");
165 std::lock_guard<std::mutex> lock(createRendererMutex_);
166 CHECK_AND_RETURN_RET_LOG(AudioPolicyManager::GetInstance().GetAudioPolicyManagerProxy() != nullptr,
167 nullptr, "sa not start");
168 AudioStreamType audioStreamType = IAudioStream::GetStreamType(rendererOptions.rendererInfo.contentType,
169 rendererOptions.rendererInfo.streamUsage);
170 if (audioStreamType == STREAM_ULTRASONIC && getuid() != UID_MSDP_SA) {
171 AudioRenderer::SendRendererCreateError(rendererOptions.rendererInfo.streamUsage,
172 ERR_INVALID_PARAM);
173 AUDIO_ERR_LOG("ULTRASONIC can only create by MSDP");
174 return nullptr;
175 }
176
177 auto audioRenderer = std::make_unique<AudioRendererPrivate>(audioStreamType, appInfo, false);
178 if (audioRenderer == nullptr) {
179 AudioRenderer::SendRendererCreateError(rendererOptions.rendererInfo.streamUsage,
180 ERR_OPERATION_FAILED);
181 }
182 CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, nullptr, "Failed to create renderer object");
183 if (!cachePath.empty()) {
184 AUDIO_DEBUG_LOG("Set application cache path");
185 audioRenderer->cachePath_ = cachePath;
186 }
187
188 int32_t rendererFlags = rendererOptions.rendererInfo.rendererFlags;
189 AUDIO_INFO_LOG("StreamClientState for Renderer::Create. content: %{public}d, usage: %{public}d, "\
190 "flags: %{public}d, uid: %{public}d", rendererOptions.rendererInfo.contentType,
191 rendererOptions.rendererInfo.streamUsage, rendererFlags, appInfo.appUid);
192
193 audioRenderer->rendererInfo_.contentType = rendererOptions.rendererInfo.contentType;
194 audioRenderer->rendererInfo_.streamUsage = rendererOptions.rendererInfo.streamUsage;
195 audioRenderer->rendererInfo_.samplingRate = rendererOptions.streamInfo.samplingRate;
196 audioRenderer->rendererInfo_.rendererFlags = rendererFlags;
197 audioRenderer->rendererInfo_.originalFlag = rendererFlags;
198 audioRenderer->privacyType_ = rendererOptions.privacyType;
199 audioRenderer->strategy_ = rendererOptions.strategy;
200 audioRenderer->originalStrategy_ = rendererOptions.strategy;
201 AudioRendererParams params = SetStreamInfoToParams(rendererOptions.streamInfo);
202 if (audioRenderer->SetParams(params) != SUCCESS) {
203 AUDIO_ERR_LOG("SetParams failed in renderer");
204 audioRenderer = nullptr;
205 AudioRenderer::SendRendererCreateError(rendererOptions.rendererInfo.streamUsage,
206 ERR_OPERATION_FAILED);
207 }
208
209 return audioRenderer;
210 }
211
SendRendererCreateError(const StreamUsage & sreamUsage,const int32_t & errorCode)212 void AudioRenderer::SendRendererCreateError(const StreamUsage &sreamUsage,
213 const int32_t &errorCode)
214 {
215 std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
216 Media::MediaMonitor::AUDIO, Media::MediaMonitor::AUDIO_STREAM_CREATE_ERROR_STATS,
217 Media::MediaMonitor::FREQUENCY_AGGREGATION_EVENT);
218 bean->Add("IS_PLAYBACK", 1);
219 bean->Add("CLIENT_UID", static_cast<int32_t>(getuid()));
220 bean->Add("STREAM_TYPE", sreamUsage);
221 bean->Add("ERROR_CODE", errorCode);
222 Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
223 }
224
AudioRendererPrivate(AudioStreamType audioStreamType,const AppInfo & appInfo,bool createStream)225 AudioRendererPrivate::AudioRendererPrivate(AudioStreamType audioStreamType, const AppInfo &appInfo, bool createStream)
226 {
227 appInfo_ = appInfo;
228 if (!(appInfo_.appPid)) {
229 appInfo_.appPid = getpid();
230 }
231
232 if (appInfo_.appUid < 0) {
233 appInfo_.appUid = static_cast<int32_t>(getuid());
234 }
235
236 if (createStream) {
237 AudioStreamParams tempParams = {};
238 audioStream_ = IAudioStream::GetPlaybackStream(IAudioStream::PA_STREAM, tempParams, audioStreamType,
239 appInfo_.appUid);
240 if (audioStream_ && STREAM_TYPE_USAGE_MAP.count(audioStreamType) != 0) {
241 // Initialize the streamUsage based on the streamType
242 rendererInfo_.streamUsage = STREAM_TYPE_USAGE_MAP.at(audioStreamType);
243 }
244 AUDIO_INFO_LOG("AudioRendererPrivate create normal stream for old mode.");
245 }
246
247 rendererProxyObj_ = std::make_shared<AudioRendererProxyObj>();
248 if (!rendererProxyObj_) {
249 AUDIO_WARNING_LOG("AudioRendererProxyObj Memory Allocation Failed !!");
250 }
251
252 audioInterrupt_.audioFocusType.streamType = audioStreamType;
253 audioInterrupt_.pid = appInfo_.appPid;
254 audioInterrupt_.mode = SHARE_MODE;
255 audioInterrupt_.parallelPlayFlag = false;
256
257 state_ = RENDERER_PREPARED;
258 }
259
InitAudioInterruptCallback()260 int32_t AudioRendererPrivate::InitAudioInterruptCallback()
261 {
262 AUDIO_DEBUG_LOG("in");
263
264 if (audioInterrupt_.sessionId != 0) {
265 AUDIO_INFO_LOG("old session already has interrupt, need to reset");
266 (void)AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt_);
267 (void)AudioPolicyManager::GetInstance().UnsetAudioInterruptCallback(audioInterrupt_.sessionId);
268 }
269
270 CHECK_AND_RETURN_RET_LOG(audioInterrupt_.mode == SHARE_MODE || audioInterrupt_.mode == INDEPENDENT_MODE,
271 ERR_INVALID_PARAM, "Invalid interrupt mode!");
272 CHECK_AND_RETURN_RET_LOG(audioStream_->GetAudioSessionID(audioInterrupt_.sessionId) == 0, ERR_INVALID_INDEX,
273 "GetAudioSessionID failed");
274 sessionID_ = audioInterrupt_.sessionId;
275 audioInterrupt_.streamUsage = rendererInfo_.streamUsage;
276 audioInterrupt_.contentType = rendererInfo_.contentType;
277 audioInterrupt_.sessionStrategy = strategy_;
278
279 AUDIO_INFO_LOG("interruptMode %{public}d, streamType %{public}d, sessionID %{public}d",
280 audioInterrupt_.mode, audioInterrupt_.audioFocusType.streamType, audioInterrupt_.sessionId);
281
282 if (audioInterruptCallback_ == nullptr) {
283 audioInterruptCallback_ = std::make_shared<AudioRendererInterruptCallbackImpl>(audioStream_, audioInterrupt_);
284 CHECK_AND_RETURN_RET_LOG(audioInterruptCallback_ != nullptr, ERROR,
285 "Failed to allocate memory for audioInterruptCallback_");
286 }
287 return AudioPolicyManager::GetInstance().SetAudioInterruptCallback(sessionID_, audioInterruptCallback_,
288 appInfo_.appUid);
289 }
290
InitOutputDeviceChangeCallback()291 int32_t AudioRendererPrivate::InitOutputDeviceChangeCallback()
292 {
293 if (!outputDeviceChangeCallback_) {
294 outputDeviceChangeCallback_ = std::make_shared<OutputDeviceChangeWithInfoCallbackImpl>();
295 CHECK_AND_RETURN_RET_LOG(outputDeviceChangeCallback_ != nullptr, ERROR, "Memory allocation failed");
296 }
297
298 outputDeviceChangeCallback_->SetAudioRendererObj(this);
299
300 uint32_t sessionId;
301 int32_t ret = GetAudioStreamId(sessionId);
302 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Get sessionId failed");
303
304 usedSessionId_.push_back(sessionId);
305 ret = AudioPolicyManager::GetInstance().RegisterDeviceChangeWithInfoCallback(sessionId,
306 outputDeviceChangeCallback_);
307 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Register failed");
308
309 return SUCCESS;
310 }
311
InitAudioStream(AudioStreamParams audioStreamParams)312 int32_t AudioRendererPrivate::InitAudioStream(AudioStreamParams audioStreamParams)
313 {
314 Trace trace("AudioRenderer::InitAudioStream");
315 AudioRenderer *renderer = this;
316 rendererProxyObj_->SaveRendererObj(renderer);
317 audioStream_->SetRendererInfo(rendererInfo_);
318 audioStream_->SetClientID(appInfo_.appPid, appInfo_.appUid, appInfo_.appTokenId, appInfo_.appFullTokenId);
319
320 SetAudioPrivacyType(privacyType_);
321 audioStream_->SetStreamTrackerState(false);
322
323 int32_t ret = audioStream_->SetAudioStreamInfo(audioStreamParams, rendererProxyObj_);
324 CHECK_AND_RETURN_RET_LOG(!ret, ret, "SetParams SetAudioStreamInfo Failed");
325
326 ret = GetAudioStreamId(sessionID_);
327 CHECK_AND_RETURN_RET_LOG(!ret, ret, "GetAudioStreamId err");
328 InitLatencyMeasurement(audioStreamParams);
329 InitAudioConcurrencyCallback();
330
331 return SUCCESS;
332 }
333
GetFrameCount(uint32_t & frameCount) const334 int32_t AudioRendererPrivate::GetFrameCount(uint32_t &frameCount) const
335 {
336 return audioStream_->GetFrameCount(frameCount);
337 }
338
GetLatency(uint64_t & latency) const339 int32_t AudioRendererPrivate::GetLatency(uint64_t &latency) const
340 {
341 return audioStream_->GetLatency(latency);
342 }
343
SetAudioPrivacyType(AudioPrivacyType privacyType)344 void AudioRendererPrivate::SetAudioPrivacyType(AudioPrivacyType privacyType)
345 {
346 privacyType_ = privacyType;
347 if (audioStream_ == nullptr) {
348 return;
349 }
350 audioStream_->SetPrivacyType(privacyType);
351 }
352
GetAudioPrivacyType()353 AudioPrivacyType AudioRendererPrivate::GetAudioPrivacyType()
354 {
355 return privacyType_;
356 }
357
GetPreferredStreamClass(AudioStreamParams audioStreamParams)358 IAudioStream::StreamClass AudioRendererPrivate::GetPreferredStreamClass(AudioStreamParams audioStreamParams)
359 {
360 if (rendererInfo_.originalFlag == AUDIO_FLAG_FORCED_NORMAL) {
361 return IAudioStream::PA_STREAM;
362 }
363 if (rendererInfo_.originalFlag == AUDIO_FLAG_MMAP &&
364 !IAudioStream::IsStreamSupported(rendererInfo_.originalFlag, audioStreamParams)) {
365 AUDIO_WARNING_LOG("Unsupported stream params, will create normal stream");
366 rendererInfo_.originalFlag = AUDIO_FLAG_NORMAL;
367 rendererInfo_.rendererFlags = AUDIO_FLAG_NORMAL;
368 }
369 int32_t flag = AudioPolicyManager::GetInstance().GetPreferredOutputStreamType(rendererInfo_);
370 AUDIO_INFO_LOG("Preferred renderer flag: %{public}d", flag);
371 if (flag == AUDIO_FLAG_MMAP) {
372 rendererInfo_.rendererFlags = AUDIO_FLAG_MMAP;
373 isFastRenderer_ = true;
374 return IAudioStream::FAST_STREAM;
375 }
376 if (flag == AUDIO_FLAG_VOIP_FAST) {
377 // It is not possible to directly create a fast VoIP stream
378 isFastVoipSupported_ = true;
379 } else if (flag == AUDIO_FLAG_VOIP_DIRECT) {
380 isDirectVoipSupported_ = IsDirectVoipParams(audioStreamParams);
381 rendererInfo_.originalFlag = isDirectVoipSupported_ ? AUDIO_FLAG_VOIP_DIRECT : AUDIO_FLAG_NORMAL;
382 // The VoIP direct mode can only be used for RENDER_MODE_CALLBACK
383 rendererInfo_.rendererFlags = (isDirectVoipSupported_ && audioRenderMode_ == RENDER_MODE_CALLBACK) ?
384 AUDIO_FLAG_VOIP_DIRECT : AUDIO_FLAG_NORMAL;
385 AUDIO_INFO_LOG("Preferred renderer flag is VOIP_DIRECT. Actual flag: %{public}d", rendererInfo_.rendererFlags);
386 return IAudioStream::PA_STREAM;
387 }
388
389 rendererInfo_.rendererFlags = AUDIO_FLAG_NORMAL;
390 return IAudioStream::PA_STREAM;
391 }
392
IsDirectVoipParams(const AudioStreamParams & audioStreamParams)393 bool AudioRendererPrivate::IsDirectVoipParams(const AudioStreamParams &audioStreamParams)
394 {
395 // VoIP derect only supports 8K, 16K and 48K sampling rate.
396 if (!(audioStreamParams.samplingRate == SAMPLE_RATE_8000 ||
397 audioStreamParams.samplingRate == SAMPLE_RATE_16000 ||
398 audioStreamParams.samplingRate == SAMPLE_RATE_48000)) {
399 AUDIO_ERR_LOG("The sampling rate %{public}d is not supported for direct VoIP mode",
400 audioStreamParams.samplingRate);
401 return false;
402 }
403
404 // VoIP derect only supports MONO and STEREO.
405 if (!(audioStreamParams.channels == MONO || audioStreamParams.channels == STEREO)) {
406 AUDIO_ERR_LOG("The channels %{public}d is not supported for direct VoIP mode",
407 audioStreamParams.channels);
408 return false;
409 }
410
411 // VoIP derect only supports 16bit and 32bit.
412 if (!(audioStreamParams.format == SAMPLE_S16LE || audioStreamParams.format == SAMPLE_S32LE)) {
413 AUDIO_ERR_LOG("The format %{public}d is not supported for direct VoIP mode",
414 audioStreamParams.format);
415 return false;
416 }
417
418 AUDIO_INFO_LOG("Valid params for direct VoIP: sampling rate %{public}d, format %{public}d, channels %{public}d",
419 audioStreamParams.samplingRate, audioStreamParams.format, audioStreamParams.channels);
420 return true;
421 }
422
SetParams(const AudioRendererParams params)423 int32_t AudioRendererPrivate::SetParams(const AudioRendererParams params)
424 {
425 Trace trace("AudioRenderer::SetParams");
426 AUDIO_INFO_LOG("StreamClientState for Renderer::SetParams.");
427
428 std::shared_lock<std::shared_mutex> lockShared(rendererMutex_);
429 std::lock_guard<std::mutex> lock(setParamsMutex_);
430 AudioStreamParams audioStreamParams = ConvertToAudioStreamParams(params);
431
432 AudioStreamType audioStreamType = IAudioStream::GetStreamType(rendererInfo_.contentType, rendererInfo_.streamUsage);
433 IAudioStream::StreamClass streamClass = GetPreferredStreamClass(audioStreamParams);
434 int32_t ret = PrepareAudioStream(audioStreamParams, audioStreamType, streamClass);
435 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_INVALID_PARAM, "PrepareAudioStream failed");
436
437 ret = InitAudioStream(audioStreamParams);
438 // When the fast stream creation fails, a normal stream is created
439 if (ret != SUCCESS && streamClass == IAudioStream::FAST_STREAM) {
440 AUDIO_INFO_LOG("Create fast Stream fail, play by normal stream.");
441 streamClass = IAudioStream::PA_STREAM;
442 isFastRenderer_ = false;
443 audioStream_ = IAudioStream::GetPlaybackStream(streamClass, audioStreamParams, audioStreamType,
444 appInfo_.appUid);
445 CHECK_AND_RETURN_RET_LOG(audioStream_ != nullptr,
446 ERR_INVALID_PARAM, "SetParams GetPlayBackStream failed when create normal stream.");
447 ret = InitAudioStream(audioStreamParams);
448 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "InitAudioStream failed");
449 audioStream_->SetRenderMode(RENDER_MODE_CALLBACK);
450 }
451
452 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "SetAudioStreamInfo Failed");
453 AUDIO_INFO_LOG("SetAudioStreamInfo Succeeded");
454
455 RegisterRendererPolicyServiceDiedCallback();
456 // eg: 100005_44100_2_1_client_in.pcm
457 std::string dumpFileName = std::to_string(sessionID_) + "_" + std::to_string(params.sampleRate) + "_" +
458 std::to_string(params.channelCount) + "_" + std::to_string(params.sampleFormat) + "_client_in.pcm";
459 DumpFileUtil::OpenDumpFile(DUMP_CLIENT_PARA, dumpFileName, &dumpFile_);
460
461 ret = InitOutputDeviceChangeCallback();
462 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "InitOutputDeviceChangeCallback Failed");
463
464 return InitAudioInterruptCallback();
465 }
466
PrepareAudioStream(const AudioStreamParams & audioStreamParams,const AudioStreamType & audioStreamType,IAudioStream::StreamClass & streamClass)467 int32_t AudioRendererPrivate::PrepareAudioStream(const AudioStreamParams &audioStreamParams,
468 const AudioStreamType &audioStreamType, IAudioStream::StreamClass &streamClass)
469 {
470 AUDIO_INFO_LOG("Create stream with flag: %{public}d, original flag: %{public}d, streamClass: %{public}d",
471 rendererInfo_.rendererFlags, rendererInfo_.originalFlag, streamClass);
472
473 // check AudioStreamParams for fast stream
474 // As fast stream only support specified audio format, we should call GetPlaybackStream with audioStreamParams.
475 ActivateAudioConcurrency(audioStreamParams, audioStreamType, streamClass);
476 if (audioStream_ == nullptr) {
477 audioStream_ = IAudioStream::GetPlaybackStream(streamClass, audioStreamParams, audioStreamType,
478 appInfo_.appUid);
479 CHECK_AND_RETURN_RET_LOG(audioStream_ != nullptr, ERR_INVALID_PARAM, "SetParams GetPlayBackStream failed.");
480 AUDIO_INFO_LOG("IAudioStream::GetStream success");
481 audioStream_->SetApplicationCachePath(cachePath_);
482 }
483 return SUCCESS;
484 }
485
GetParams(AudioRendererParams & params) const486 int32_t AudioRendererPrivate::GetParams(AudioRendererParams ¶ms) const
487 {
488 AudioStreamParams audioStreamParams;
489 int32_t result = audioStream_->GetAudioStreamInfo(audioStreamParams);
490 if (!result) {
491 params.sampleFormat = static_cast<AudioSampleFormat>(audioStreamParams.format);
492 params.sampleRate = static_cast<AudioSamplingRate>(audioStreamParams.samplingRate);
493 params.channelCount = static_cast<AudioChannel>(audioStreamParams.channels);
494 params.encodingType = static_cast<AudioEncodingType>(audioStreamParams.encoding);
495 params.channelLayout = static_cast<AudioChannelLayout>(audioStreamParams.channelLayout);
496 }
497
498 return result;
499 }
500
GetRendererInfo(AudioRendererInfo & rendererInfo) const501 int32_t AudioRendererPrivate::GetRendererInfo(AudioRendererInfo &rendererInfo) const
502 {
503 rendererInfo = rendererInfo_;
504
505 return SUCCESS;
506 }
507
GetStreamInfo(AudioStreamInfo & streamInfo) const508 int32_t AudioRendererPrivate::GetStreamInfo(AudioStreamInfo &streamInfo) const
509 {
510 AudioStreamParams audioStreamParams;
511 int32_t result = audioStream_->GetAudioStreamInfo(audioStreamParams);
512 if (!result) {
513 streamInfo.format = static_cast<AudioSampleFormat>(audioStreamParams.format);
514 streamInfo.samplingRate = static_cast<AudioSamplingRate>(audioStreamParams.samplingRate);
515 streamInfo.channels = static_cast<AudioChannel>(audioStreamParams.channels);
516 streamInfo.encoding = static_cast<AudioEncodingType>(audioStreamParams.encoding);
517 streamInfo.channelLayout = static_cast<AudioChannelLayout>(audioStreamParams.channelLayout);
518 }
519
520 return result;
521 }
522
SetRendererCallback(const std::shared_ptr<AudioRendererCallback> & callback)523 int32_t AudioRendererPrivate::SetRendererCallback(const std::shared_ptr<AudioRendererCallback> &callback)
524 {
525 std::shared_lock<std::shared_mutex> lockShared(rendererMutex_);
526 std::lock_guard<std::mutex> lock(setStreamCallbackMutex_);
527 // If the client is using the deprecated SetParams API. SetRendererCallback must be invoked, after SetParams.
528 // In general, callbacks can only be set after the renderer state is PREPARED.
529 RendererState state = GetStatus();
530 CHECK_AND_RETURN_RET_LOG(state != RENDERER_NEW && state != RENDERER_RELEASED, ERR_ILLEGAL_STATE,
531 "incorrect state:%{public}d to register cb", state);
532
533 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM,
534 "callback param is null");
535
536 // Save reference for interrupt callback
537 CHECK_AND_RETURN_RET_LOG(audioInterruptCallback_ != nullptr, ERROR,
538 "audioInterruptCallback_ == nullptr");
539 std::shared_ptr<AudioRendererInterruptCallbackImpl> cbInterrupt =
540 std::static_pointer_cast<AudioRendererInterruptCallbackImpl>(audioInterruptCallback_);
541 cbInterrupt->SaveCallback(callback);
542
543 // Save and Set reference for stream callback. Order is important here.
544 if (audioStreamCallback_ == nullptr) {
545 audioStreamCallback_ = std::make_shared<AudioStreamCallbackRenderer>();
546 CHECK_AND_RETURN_RET_LOG(audioStreamCallback_ != nullptr, ERROR,
547 "Failed to allocate memory for audioStreamCallback_");
548 }
549 std::shared_ptr<AudioStreamCallbackRenderer> cbStream =
550 std::static_pointer_cast<AudioStreamCallbackRenderer>(audioStreamCallback_);
551 cbStream->SaveCallback(callback);
552 (void)audioStream_->SetStreamCallback(audioStreamCallback_);
553
554 return SUCCESS;
555 }
556
SetRendererPositionCallback(int64_t markPosition,const std::shared_ptr<RendererPositionCallback> & callback)557 int32_t AudioRendererPrivate::SetRendererPositionCallback(int64_t markPosition,
558 const std::shared_ptr<RendererPositionCallback> &callback)
559 {
560 CHECK_AND_RETURN_RET_LOG((callback != nullptr) && (markPosition > 0), ERR_INVALID_PARAM,
561 "input param is invalid");
562
563 audioStream_->SetRendererPositionCallback(markPosition, callback);
564
565 return SUCCESS;
566 }
567
UnsetRendererPositionCallback()568 void AudioRendererPrivate::UnsetRendererPositionCallback()
569 {
570 audioStream_->UnsetRendererPositionCallback();
571 }
572
SetRendererPeriodPositionCallback(int64_t frameNumber,const std::shared_ptr<RendererPeriodPositionCallback> & callback)573 int32_t AudioRendererPrivate::SetRendererPeriodPositionCallback(int64_t frameNumber,
574 const std::shared_ptr<RendererPeriodPositionCallback> &callback)
575 {
576 CHECK_AND_RETURN_RET_LOG((callback != nullptr) && (frameNumber > 0), ERR_INVALID_PARAM,
577 "input param is invalid");
578
579 audioStream_->SetRendererPeriodPositionCallback(frameNumber, callback);
580
581 return SUCCESS;
582 }
583
UnsetRendererPeriodPositionCallback()584 void AudioRendererPrivate::UnsetRendererPeriodPositionCallback()
585 {
586 audioStream_->UnsetRendererPeriodPositionCallback();
587 }
588
Start(StateChangeCmdType cmdType)589 bool AudioRendererPrivate::Start(StateChangeCmdType cmdType)
590 {
591 Trace trace("AudioRenderer::Start");
592 std::lock_guard<std::shared_mutex> lock(rendererMutex_);
593 AUDIO_INFO_LOG("StreamClientState for Renderer::Start. id: %{public}u, streamType: %{public}d, "\
594 "interruptMode: %{public}d", sessionID_, audioInterrupt_.audioFocusType.streamType, audioInterrupt_.mode);
595
596 RendererState state = GetStatus();
597 CHECK_AND_RETURN_RET_LOG((state == RENDERER_PREPARED) || (state == RENDERER_STOPPED) || (state == RENDERER_PAUSED),
598 false, "Start failed. Illegal state:%{public}u", state);
599
600 CHECK_AND_RETURN_RET_LOG(!isSwitching_, false,
601 "Start failed. Switching state: %{public}d", isSwitching_);
602
603 if (audioInterrupt_.audioFocusType.streamType == STREAM_DEFAULT ||
604 audioInterrupt_.sessionId == INVALID_SESSION_ID) {
605 return false;
606 }
607
608 CHECK_AND_RETURN_RET_LOG(audioStream_ != nullptr, false, "audio stream is null");
609
610 if (GetVolume() == 0 && isStillMuted_) {
611 AUDIO_INFO_LOG("StreamClientState for Renderer::Start. volume=%{public}f, isStillMuted_=%{public}d",
612 GetVolume(), isStillMuted_);
613 audioInterrupt_.sessionStrategy.concurrencyMode = AudioConcurrencyMode::SLIENT;
614 } else {
615 isStillMuted_ = false;
616 }
617
618 {
619 std::lock_guard<std::mutex> lock(silentModeAndMixWithOthersMutex_);
620 if (!audioStream_->GetSilentModeAndMixWithOthers()) {
621 int32_t ret = AudioPolicyManager::GetInstance().ActivateAudioInterrupt(audioInterrupt_);
622 CHECK_AND_RETURN_RET_LOG(ret == 0, false, "ActivateAudioInterrupt Failed");
623 }
624 }
625
626 if (IsNoStreamRenderer()) {
627 // no stream renderer only need to activate audio interrupt
628 state_ = RENDERER_RUNNING;
629 return true;
630 }
631
632 bool result = audioStream_->StartAudioStream(cmdType);
633 if (!result) {
634 AUDIO_ERR_LOG("Start audio stream failed");
635 std::lock_guard<std::mutex> lock(silentModeAndMixWithOthersMutex_);
636 if (!audioStream_->GetSilentModeAndMixWithOthers()) {
637 int32_t ret = AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt_);
638 if (ret != 0) {
639 AUDIO_WARNING_LOG("DeactivateAudioInterrupt Failed");
640 }
641 }
642 }
643
644 state_ = RENDERER_RUNNING;
645
646 return result;
647 }
648
Write(uint8_t * buffer,size_t bufferSize)649 int32_t AudioRendererPrivate::Write(uint8_t *buffer, size_t bufferSize)
650 {
651 Trace trace("AudioRenderer::Write");
652 MockPcmData(buffer, bufferSize);
653 int32_t size = audioStream_->Write(buffer, bufferSize);
654 if (size > 0) {
655 DumpFileUtil::WriteDumpFile(dumpFile_, static_cast<void *>(buffer), size);
656 }
657 return size;
658 }
659
Write(uint8_t * pcmBuffer,size_t pcmSize,uint8_t * metaBuffer,size_t metaSize)660 int32_t AudioRendererPrivate::Write(uint8_t *pcmBuffer, size_t pcmSize, uint8_t *metaBuffer, size_t metaSize)
661 {
662 Trace trace("Write");
663 int32_t size = audioStream_->Write(pcmBuffer, pcmSize, metaBuffer, metaSize);
664 if (size > 0) {
665 DumpFileUtil::WriteDumpFile(dumpFile_, static_cast<void *>(pcmBuffer), size);
666 }
667 return size;
668 }
669
GetStatus() const670 RendererState AudioRendererPrivate::GetStatus() const
671 {
672 if (IsNoStreamRenderer()) {
673 return state_;
674 }
675 return static_cast<RendererState>(audioStream_->GetState());
676 }
677
GetAudioTime(Timestamp & timestamp,Timestamp::Timestampbase base) const678 bool AudioRendererPrivate::GetAudioTime(Timestamp ×tamp, Timestamp::Timestampbase base) const
679 {
680 return audioStream_->GetAudioTime(timestamp, base);
681 }
682
GetAudioPosition(Timestamp & timestamp,Timestamp::Timestampbase base) const683 bool AudioRendererPrivate::GetAudioPosition(Timestamp ×tamp, Timestamp::Timestampbase base) const
684 {
685 return audioStream_->GetAudioPosition(timestamp, base);
686 }
687
Drain() const688 bool AudioRendererPrivate::Drain() const
689 {
690 Trace trace("AudioRenderer::Drain");
691 return audioStream_->DrainAudioStream();
692 }
693
Flush() const694 bool AudioRendererPrivate::Flush() const
695 {
696 Trace trace("AudioRenderer::Flush");
697 return audioStream_->FlushAudioStream();
698 }
699
PauseTransitent(StateChangeCmdType cmdType)700 bool AudioRendererPrivate::PauseTransitent(StateChangeCmdType cmdType)
701 {
702 Trace trace("AudioRenderer::PauseTransitent");
703 std::lock_guard<std::shared_mutex> lock(rendererMutex_);
704 AUDIO_INFO_LOG("StreamClientState for Renderer::PauseTransitent. id: %{public}u", sessionID_);
705 if (isSwitching_) {
706 AUDIO_ERR_LOG("failed. Switching state: %{public}d", isSwitching_);
707 return false;
708 }
709
710 if (IsNoStreamRenderer()) {
711 // no stream renderer don't need to change audio stream state
712 state_ = RENDERER_PAUSED;
713 return true;
714 }
715
716 RendererState state = GetStatus();
717 if (state != RENDERER_RUNNING) {
718 // If the stream is not running, there is no need to pause and deactive audio interrupt
719 AUDIO_ERR_LOG("State of stream is not running. Illegal state:%{public}u", state);
720 return false;
721 }
722 bool result = audioStream_->PauseAudioStream(cmdType);
723 if (result) {
724 state_ = RENDERER_PAUSED;
725 }
726
727 return result;
728 }
729
Pause(StateChangeCmdType cmdType)730 bool AudioRendererPrivate::Pause(StateChangeCmdType cmdType)
731 {
732 Trace trace("AudioRenderer::Pause");
733 AudioXCollie audioXCollie("AudioRenderer::Pause", TIME_OUT_SECONDS);
734 std::lock_guard<std::shared_mutex> lock(rendererMutex_);
735
736 AUDIO_INFO_LOG("StreamClientState for Renderer::Pause. id: %{public}u", sessionID_);
737
738 CHECK_AND_RETURN_RET_LOG(!isSwitching_, false, "Pause failed. Switching state: %{public}d", isSwitching_);
739
740 if (IsNoStreamRenderer()) {
741 // When the cellular call stream is pausing, only need to deactivate audio interrupt.
742 if (AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt_) != 0) {
743 AUDIO_ERR_LOG("DeactivateAudioInterrupt Failed");
744 }
745 state_ = RENDERER_PAUSED;
746 return true;
747 }
748
749 RendererState state = GetStatus();
750 CHECK_AND_RETURN_RET_LOG(state == RENDERER_RUNNING, false,
751 "State of stream is not running. Illegal state:%{public}u", state);
752 bool result = audioStream_->PauseAudioStream(cmdType);
753 if (result) {
754 state_ = RENDERER_PAUSED;
755 }
756
757 // When user is intentionally pausing, deactivate to remove from audioFocusInfoList_
758 int32_t ret = AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt_);
759 if (ret != 0) {
760 AUDIO_ERR_LOG("DeactivateAudioInterrupt Failed");
761 }
762 (void)audioStream_->SetDuckVolume(1.0f);
763
764 return result;
765 }
766
Stop()767 bool AudioRendererPrivate::Stop()
768 {
769 AUDIO_INFO_LOG("StreamClientState for Renderer::Stop. id: %{public}u", sessionID_);
770 std::lock_guard<std::shared_mutex> lock(rendererMutex_);
771 CHECK_AND_RETURN_RET_LOG(!isSwitching_, false,
772 "AudioRenderer::Stop failed. Switching state: %{public}d", isSwitching_);
773 if (IsNoStreamRenderer()) {
774 // When the cellular call stream is stopping, only need to deactivate audio interrupt.
775 if (AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt_) != 0) {
776 AUDIO_WARNING_LOG("DeactivateAudioInterrupt Failed");
777 }
778 state_ = RENDERER_STOPPED;
779 return true;
780 }
781
782 WriteUnderrunEvent();
783 bool result = audioStream_->StopAudioStream();
784 if (result) {
785 state_ = RENDERER_STOPPED;
786 }
787 int32_t ret = AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt_);
788 if (ret != 0) {
789 AUDIO_WARNING_LOG("DeactivateAudioInterrupt Failed");
790 }
791 (void)audioStream_->SetDuckVolume(1.0f);
792
793 return result;
794 }
795
Release()796 bool AudioRendererPrivate::Release()
797 {
798 std::lock_guard<std::shared_mutex> lock(rendererMutex_);
799 AUDIO_INFO_LOG("StreamClientState for Renderer::Release. id: %{public}u", sessionID_);
800
801 bool result = audioStream_->ReleaseAudioStream();
802
803 // If Stop call was skipped, Release to take care of Deactivation
804 (void)AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt_);
805
806 // Unregister the callaback in policy server
807 (void)AudioPolicyManager::GetInstance().UnsetAudioInterruptCallback(sessionID_);
808
809 for (auto id : usedSessionId_) {
810 AudioPolicyManager::GetInstance().UnregisterDeviceChangeWithInfoCallback(id);
811 }
812 RemoveRendererPolicyServiceDiedCallback();
813
814 return result;
815 }
816
GetBufferSize(size_t & bufferSize) const817 int32_t AudioRendererPrivate::GetBufferSize(size_t &bufferSize) const
818 {
819 Trace trace("AudioRenderer::GetBufferSize");
820 return audioStream_->GetBufferSize(bufferSize);
821 }
822
GetAudioStreamId(uint32_t & sessionID) const823 int32_t AudioRendererPrivate::GetAudioStreamId(uint32_t &sessionID) const
824 {
825 return audioStream_->GetAudioSessionID(sessionID);
826 }
827
SetAudioRendererDesc(AudioRendererDesc audioRendererDesc)828 int32_t AudioRendererPrivate::SetAudioRendererDesc(AudioRendererDesc audioRendererDesc)
829 {
830 ContentType contentType = audioRendererDesc.contentType;
831 StreamUsage streamUsage = audioRendererDesc.streamUsage;
832 AudioStreamType audioStreamType = IAudioStream::GetStreamType(contentType, streamUsage);
833 audioInterrupt_.audioFocusType.streamType = audioStreamType;
834 return audioStream_->SetAudioStreamType(audioStreamType);
835 }
836
SetStreamType(AudioStreamType audioStreamType)837 int32_t AudioRendererPrivate::SetStreamType(AudioStreamType audioStreamType)
838 {
839 audioInterrupt_.audioFocusType.streamType = audioStreamType;
840 return audioStream_->SetAudioStreamType(audioStreamType);
841 }
842
SetVolume(float volume) const843 int32_t AudioRendererPrivate::SetVolume(float volume) const
844 {
845 UpdateAudioInterruptStrategy(volume);
846 return audioStream_->SetVolume(volume);
847 }
848
UpdateAudioInterruptStrategy(float volume) const849 void AudioRendererPrivate::UpdateAudioInterruptStrategy(float volume) const
850 {
851 State currentState = audioStream_->GetState();
852 if (currentState == NEW || currentState == PREPARED) {
853 AUDIO_INFO_LOG("UpdateAudioInterruptStrategy for set volume before RUNNING, volume=%{public}f", volume);
854 isStillMuted_ = (volume == 0);
855 } else if (isStillMuted_ && volume > 0) {
856 isStillMuted_ = false;
857 audioInterrupt_.sessionStrategy.concurrencyMode =
858 (originalStrategy_.concurrencyMode == AudioConcurrencyMode::INVALID ?
859 AudioConcurrencyMode::DEFAULT : originalStrategy_.concurrencyMode);
860 if (currentState == RUNNING) {
861 AUDIO_INFO_LOG("UpdateAudioInterruptStrategy for set volume, volume=%{public}f", volume);
862 int ret = AudioPolicyManager::GetInstance().ActivateAudioInterrupt(audioInterrupt_, 0, true);
863 CHECK_AND_RETURN_LOG(ret == 0, "ActivateAudioInterrupt Failed at SetVolume");
864 }
865 }
866 }
867
GetVolume() const868 float AudioRendererPrivate::GetVolume() const
869 {
870 return audioStream_->GetVolume();
871 }
872
SetRenderRate(AudioRendererRate renderRate) const873 int32_t AudioRendererPrivate::SetRenderRate(AudioRendererRate renderRate) const
874 {
875 return audioStream_->SetRenderRate(renderRate);
876 }
877
GetRenderRate() const878 AudioRendererRate AudioRendererPrivate::GetRenderRate() const
879 {
880 return audioStream_->GetRenderRate();
881 }
882
SetRendererSamplingRate(uint32_t sampleRate) const883 int32_t AudioRendererPrivate::SetRendererSamplingRate(uint32_t sampleRate) const
884 {
885 return audioStream_->SetRendererSamplingRate(sampleRate);
886 }
887
GetRendererSamplingRate() const888 uint32_t AudioRendererPrivate::GetRendererSamplingRate() const
889 {
890 return audioStream_->GetRendererSamplingRate();
891 }
892
SetBufferDuration(uint64_t bufferDuration) const893 int32_t AudioRendererPrivate::SetBufferDuration(uint64_t bufferDuration) const
894 {
895 CHECK_AND_RETURN_RET_LOG(bufferDuration >= MINIMUM_BUFFER_SIZE_MSEC && bufferDuration <= MAXIMUM_BUFFER_SIZE_MSEC,
896 ERR_INVALID_PARAM, "Error: Please set the buffer duration between 5ms ~ 20ms");
897
898 return audioStream_->SetBufferSizeInMsec(bufferDuration);
899 }
900
SetChannelBlendMode(ChannelBlendMode blendMode)901 int32_t AudioRendererPrivate::SetChannelBlendMode(ChannelBlendMode blendMode)
902 {
903 return audioStream_->SetChannelBlendMode(blendMode);
904 }
905
AudioRendererInterruptCallbackImpl(const std::shared_ptr<IAudioStream> & audioStream,const AudioInterrupt & audioInterrupt)906 AudioRendererInterruptCallbackImpl::AudioRendererInterruptCallbackImpl(const std::shared_ptr<IAudioStream> &audioStream,
907 const AudioInterrupt &audioInterrupt)
908 : audioStream_(audioStream), audioInterrupt_(audioInterrupt)
909 {
910 AUDIO_DEBUG_LOG("AudioRendererInterruptCallbackImpl constructor");
911 }
912
~AudioRendererInterruptCallbackImpl()913 AudioRendererInterruptCallbackImpl::~AudioRendererInterruptCallbackImpl()
914 {
915 AUDIO_DEBUG_LOG("AudioRendererInterruptCallbackImpl: instance destroy");
916 }
917
SaveCallback(const std::weak_ptr<AudioRendererCallback> & callback)918 void AudioRendererInterruptCallbackImpl::SaveCallback(const std::weak_ptr<AudioRendererCallback> &callback)
919 {
920 callback_ = callback;
921 }
922
UpdateAudioStream(const std::shared_ptr<IAudioStream> & audioStream)923 void AudioRendererInterruptCallbackImpl::UpdateAudioStream(const std::shared_ptr<IAudioStream> &audioStream)
924 {
925 std::lock_guard<std::mutex> lock(mutex_);
926 audioStream_ = audioStream;
927 }
928
NotifyEvent(const InterruptEvent & interruptEvent)929 void AudioRendererInterruptCallbackImpl::NotifyEvent(const InterruptEvent &interruptEvent)
930 {
931 if (cb_ != nullptr && interruptEvent.callbackToApp) {
932 cb_->OnInterrupt(interruptEvent);
933 AUDIO_DEBUG_LOG("Send interruptEvent to app successfully");
934 } else if (cb_ == nullptr) {
935 AUDIO_WARNING_LOG("cb_==nullptr, failed to send interruptEvent");
936 } else {
937 AUDIO_INFO_LOG("callbackToApp is %{public}d", interruptEvent.callbackToApp);
938 }
939 }
940
HandleForceDucking(const InterruptEventInternal & interruptEvent)941 bool AudioRendererInterruptCallbackImpl::HandleForceDucking(const InterruptEventInternal &interruptEvent)
942 {
943 float duckVolumeFactor = interruptEvent.duckVolume;
944 int32_t ret = audioStream_->SetDuckVolume(duckVolumeFactor);
945 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, false, "Failed to set duckVolumeFactor(instance) %{public}f",
946 duckVolumeFactor);
947
948 AUDIO_INFO_LOG("Set duckVolumeFactor %{public}f successfully.", duckVolumeFactor);
949 return true;
950 }
951
NotifyForcePausedToResume(const InterruptEventInternal & interruptEvent)952 void AudioRendererInterruptCallbackImpl::NotifyForcePausedToResume(const InterruptEventInternal &interruptEvent)
953 {
954 // Change InterruptForceType to Share, Since app will take care of resuming
955 InterruptEvent interruptEventResume {interruptEvent.eventType, INTERRUPT_SHARE,
956 interruptEvent.hintType};
957 NotifyEvent(interruptEventResume);
958 }
959
HandleAndNotifyForcedEvent(const InterruptEventInternal & interruptEvent)960 void AudioRendererInterruptCallbackImpl::HandleAndNotifyForcedEvent(const InterruptEventInternal &interruptEvent)
961 {
962 State currentState = audioStream_->GetState();
963 audioStream_->GetAudioSessionID(sessionID_);
964 switch (interruptEvent.hintType) {
965 case INTERRUPT_HINT_PAUSE:
966 if (currentState == RUNNING || currentState == PREPARED) {
967 (void)audioStream_->PauseAudioStream(); // Just Pause, do not deactivate here
968 (void)audioStream_->SetDuckVolume(1.0f);
969 isForcePaused_ = true;
970 } else {
971 AUDIO_WARNING_LOG("sessionId: %{public}u, state: %{public}d. No need to pause",
972 sessionID_, static_cast<int32_t>(currentState));
973 return;
974 }
975 break;
976 case INTERRUPT_HINT_RESUME:
977 if ((currentState != PAUSED && currentState != PREPARED) || !isForcePaused_) {
978 AUDIO_WARNING_LOG("sessionId: %{public}u, State: %{public}d or not force pause before",
979 sessionID_, static_cast<int32_t>(currentState));
980 return;
981 }
982 isForcePaused_ = false;
983 NotifyForcePausedToResume(interruptEvent);
984 return; // return, sending callback is taken care in NotifyForcePausedToResume
985 case INTERRUPT_HINT_STOP:
986 (void)audioStream_->StopAudioStream();
987 (void)audioStream_->SetDuckVolume(1.0f);
988 break;
989 case INTERRUPT_HINT_DUCK:
990 if (!HandleForceDucking(interruptEvent)) {
991 AUDIO_WARNING_LOG("Failed to duck forcely, don't notify app");
992 return;
993 }
994 isForceDucked_ = true;
995 break;
996 case INTERRUPT_HINT_UNDUCK:
997 CHECK_AND_RETURN_LOG(isForceDucked_, "It is not forced ducked, don't unduck or notify app");
998 (void)audioStream_->SetDuckVolume(1.0f);
999 AUDIO_INFO_LOG("Unduck Volume successfully");
1000 isForceDucked_ = false;
1001 break;
1002 default: // If the hintType is NONE, don't need to send callbacks
1003 return;
1004 }
1005 // Notify valid forced event callbacks to app
1006 NotifyForcedEvent(interruptEvent);
1007 }
1008
NotifyForcedEvent(const InterruptEventInternal & interruptEvent)1009 void AudioRendererInterruptCallbackImpl::NotifyForcedEvent(const InterruptEventInternal &interruptEvent)
1010 {
1011 InterruptEvent interruptEventForced {interruptEvent.eventType, interruptEvent.forceType, interruptEvent.hintType,
1012 interruptEvent.callbackToApp};
1013 NotifyEvent(interruptEventForced);
1014 }
1015
OnInterrupt(const InterruptEventInternal & interruptEvent)1016 void AudioRendererInterruptCallbackImpl::OnInterrupt(const InterruptEventInternal &interruptEvent)
1017 {
1018 std::lock_guard<std::mutex> lock(mutex_);
1019
1020 cb_ = callback_.lock();
1021 InterruptForceType forceType = interruptEvent.forceType;
1022
1023 if (audioStream_ != nullptr) {
1024 audioStream_->GetAudioSessionID(sessionID_);
1025 }
1026 AUDIO_INFO_LOG("sessionId: %{public}u, forceType: %{public}d, hintType: %{public}d",
1027 sessionID_, forceType, interruptEvent.hintType);
1028
1029 if (forceType != INTERRUPT_FORCE) { // INTERRUPT_SHARE
1030 AUDIO_DEBUG_LOG("INTERRUPT_SHARE. Let app handle the event");
1031 InterruptEvent interruptEventShared {interruptEvent.eventType, interruptEvent.forceType,
1032 interruptEvent.hintType, interruptEvent.callbackToApp};
1033 NotifyEvent(interruptEventShared);
1034 return;
1035 }
1036
1037 CHECK_AND_RETURN_LOG(audioStream_ != nullptr,
1038 "Stream is not alive. No need to take forced action");
1039
1040 HandleAndNotifyForcedEvent(interruptEvent);
1041 }
1042
AudioRendererConcurrencyCallbackImpl()1043 AudioRendererConcurrencyCallbackImpl::AudioRendererConcurrencyCallbackImpl()
1044 {
1045 AUDIO_INFO_LOG("AudioRendererConcurrencyCallbackImpl ctor");
1046 }
1047
~AudioRendererConcurrencyCallbackImpl()1048 AudioRendererConcurrencyCallbackImpl::~AudioRendererConcurrencyCallbackImpl()
1049 {
1050 AUDIO_INFO_LOG("AudioRendererConcurrencyCallbackImpl dtor");
1051 }
1052
OnConcedeStream()1053 void AudioRendererConcurrencyCallbackImpl::OnConcedeStream()
1054 {
1055 std::lock_guard<std::mutex> lock(mutex_);
1056 CHECK_AND_RETURN_LOG(renderer_ != nullptr, "renderer is nullptr");
1057 renderer_->ConcedeStream();
1058 }
1059
InitAudioConcurrencyCallback()1060 int32_t AudioRendererPrivate::InitAudioConcurrencyCallback()
1061 {
1062 if (audioConcurrencyCallback_ == nullptr) {
1063 audioConcurrencyCallback_ = std::make_shared<AudioRendererConcurrencyCallbackImpl>();
1064 CHECK_AND_RETURN_RET_LOG(audioConcurrencyCallback_ != nullptr, ERROR, "Memory Allocation Failed !!");
1065 }
1066 audioConcurrencyCallback_->SetAudioRendererObj(this);
1067 return AudioPolicyManager::GetInstance().SetAudioConcurrencyCallback(sessionID_, audioConcurrencyCallback_);
1068 }
1069
SaveCallback(const std::weak_ptr<AudioRendererCallback> & callback)1070 void AudioStreamCallbackRenderer::SaveCallback(const std::weak_ptr<AudioRendererCallback> &callback)
1071 {
1072 callback_ = callback;
1073 }
1074
OnStateChange(const State state,const StateChangeCmdType cmdType)1075 void AudioStreamCallbackRenderer::OnStateChange(const State state, const StateChangeCmdType cmdType)
1076 {
1077 std::shared_ptr<AudioRendererCallback> cb = callback_.lock();
1078 CHECK_AND_RETURN_LOG(cb != nullptr, "cb == nullptr.");
1079
1080 cb->OnStateChange(static_cast<RendererState>(state), cmdType);
1081 }
1082
GetSupportedFormats()1083 std::vector<AudioSampleFormat> AudioRenderer::GetSupportedFormats()
1084 {
1085 return AUDIO_SUPPORTED_FORMATS;
1086 }
1087
GetSupportedSamplingRates()1088 std::vector<AudioSamplingRate> AudioRenderer::GetSupportedSamplingRates()
1089 {
1090 return AUDIO_SUPPORTED_SAMPLING_RATES;
1091 }
1092
GetSupportedChannels()1093 std::vector<AudioChannel> AudioRenderer::GetSupportedChannels()
1094 {
1095 return RENDERER_SUPPORTED_CHANNELS;
1096 }
1097
GetSupportedEncodingTypes()1098 std::vector<AudioEncodingType> AudioRenderer::GetSupportedEncodingTypes()
1099 {
1100 return AUDIO_SUPPORTED_ENCODING_TYPES;
1101 }
1102
SetRenderMode(AudioRenderMode renderMode)1103 int32_t AudioRendererPrivate::SetRenderMode(AudioRenderMode renderMode)
1104 {
1105 AUDIO_INFO_LOG("Render mode: %{public}d", renderMode);
1106 audioRenderMode_ = renderMode;
1107 if (renderMode == RENDER_MODE_CALLBACK && rendererInfo_.originalFlag != AUDIO_FLAG_FORCED_NORMAL &&
1108 (rendererInfo_.streamUsage == STREAM_USAGE_VOICE_COMMUNICATION ||
1109 rendererInfo_.streamUsage == STREAM_USAGE_VIDEO_COMMUNICATION)) {
1110 // both fast and direct VoIP renderer can only use RENDER_MODE_CALLBACK;
1111 int32_t flags = AudioPolicyManager::GetInstance().GetPreferredOutputStreamType(rendererInfo_);
1112 uint32_t sessionId = 0;
1113 int32_t ret = audioStream_->GetAudioSessionID(sessionId);
1114 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Get audio session Id failed");
1115 uint32_t newSessionId = 0;
1116 IAudioStream::StreamClass streamClass = IAudioStream::PA_STREAM;
1117 if (flags == AUDIO_FLAG_VOIP_FAST) {
1118 AUDIO_INFO_LOG("Switch to fast voip stream");
1119 streamClass = IAudioStream::VOIP_STREAM;
1120 } else if (flags == AUDIO_FLAG_VOIP_DIRECT && isDirectVoipSupported_) {
1121 AUDIO_INFO_LOG("Switch to direct voip stream");
1122 rendererInfo_.rendererFlags = AUDIO_FLAG_VOIP_DIRECT;
1123 streamClass = IAudioStream::PA_STREAM;
1124 }
1125 if (!SwitchToTargetStream(streamClass, newSessionId, AudioStreamDeviceChangeReasonExt::ExtEnum::UNKNOWN)) {
1126 AUDIO_ERR_LOG("Switch to target stream failed");
1127 return ERROR;
1128 }
1129 usedSessionId_.push_back(newSessionId);
1130 ret = AudioPolicyManager::GetInstance().RegisterDeviceChangeWithInfoCallback(newSessionId,
1131 outputDeviceChangeCallback_);
1132 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Register device change callback for new session failed");
1133 }
1134
1135 return audioStream_->SetRenderMode(renderMode);
1136 }
1137
GetRenderMode() const1138 AudioRenderMode AudioRendererPrivate::GetRenderMode() const
1139 {
1140 return audioStream_->GetRenderMode();
1141 }
1142
GetBufferDesc(BufferDesc & bufDesc) const1143 int32_t AudioRendererPrivate::GetBufferDesc(BufferDesc &bufDesc) const
1144 {
1145 int32_t ret = audioStream_->GetBufferDesc(bufDesc);
1146 return ret;
1147 }
1148
Enqueue(const BufferDesc & bufDesc) const1149 int32_t AudioRendererPrivate::Enqueue(const BufferDesc &bufDesc) const
1150 {
1151 Trace trace("AudioRenderer::Enqueue");
1152 MockPcmData(bufDesc.buffer, bufDesc.bufLength);
1153 DumpFileUtil::WriteDumpFile(dumpFile_, static_cast<void *>(bufDesc.buffer), bufDesc.bufLength);
1154 int32_t ret = audioStream_->Enqueue(bufDesc);
1155 return ret;
1156 }
1157
Clear() const1158 int32_t AudioRendererPrivate::Clear() const
1159 {
1160 return audioStream_->Clear();
1161 }
1162
GetBufQueueState(BufferQueueState & bufState) const1163 int32_t AudioRendererPrivate::GetBufQueueState(BufferQueueState &bufState) const
1164 {
1165 return audioStream_->GetBufQueueState(bufState);
1166 }
1167
SetApplicationCachePath(const std::string cachePath)1168 void AudioRendererPrivate::SetApplicationCachePath(const std::string cachePath)
1169 {
1170 cachePath_ = cachePath;
1171 if (audioStream_ != nullptr) {
1172 audioStream_->SetApplicationCachePath(cachePath);
1173 } else {
1174 AUDIO_WARNING_LOG("while stream is null");
1175 }
1176 }
1177
SetRendererWriteCallback(const std::shared_ptr<AudioRendererWriteCallback> & callback)1178 int32_t AudioRendererPrivate::SetRendererWriteCallback(const std::shared_ptr<AudioRendererWriteCallback> &callback)
1179 {
1180 return audioStream_->SetRendererWriteCallback(callback);
1181 }
1182
SetRendererFirstFrameWritingCallback(const std::shared_ptr<AudioRendererFirstFrameWritingCallback> & callback)1183 int32_t AudioRendererPrivate::SetRendererFirstFrameWritingCallback(
1184 const std::shared_ptr<AudioRendererFirstFrameWritingCallback> &callback)
1185 {
1186 return audioStream_->SetRendererFirstFrameWritingCallback(callback);
1187 }
1188
SetInterruptMode(InterruptMode mode)1189 void AudioRendererPrivate::SetInterruptMode(InterruptMode mode)
1190 {
1191 AUDIO_INFO_LOG("InterruptMode %{public}d", mode);
1192 if (audioInterrupt_.mode == mode) {
1193 return;
1194 } else if (mode != SHARE_MODE && mode != INDEPENDENT_MODE) {
1195 AUDIO_ERR_LOG("Invalid interrupt mode!");
1196 return;
1197 }
1198 audioInterrupt_.mode = mode;
1199 }
1200
SetSilentModeAndMixWithOthers(bool on)1201 void AudioRendererPrivate::SetSilentModeAndMixWithOthers(bool on)
1202 {
1203 Trace trace(std::string("AudioRenderer::SetSilentModeAndMixWithOthers:") + (on ? "on" : "off"));
1204 std::shared_lock<std::shared_mutex> sharedLockSwitch(rendererMutex_);
1205 std::lock_guard<std::mutex> lock(silentModeAndMixWithOthersMutex_);
1206 if (static_cast<RendererState>(audioStream_->GetState()) == RENDERER_RUNNING) {
1207 if (audioStream_->GetSilentModeAndMixWithOthers() && !on) {
1208 int32_t ret = AudioPolicyManager::GetInstance().ActivateAudioInterrupt(audioInterrupt_);
1209 CHECK_AND_RETURN_LOG(ret == 0, "ActivateAudioInterrupt Failed");
1210 audioStream_->SetSilentModeAndMixWithOthers(on);
1211 return;
1212 } else if (!audioStream_->GetSilentModeAndMixWithOthers() && on) {
1213 audioStream_->SetSilentModeAndMixWithOthers(on);
1214 int32_t ret = AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt_);
1215 CHECK_AND_RETURN_LOG(ret == 0, "DeactivateAudioInterrupt Failed");
1216 return;
1217 }
1218 }
1219 audioStream_->SetSilentModeAndMixWithOthers(on);
1220 }
1221
GetSilentModeAndMixWithOthers()1222 bool AudioRendererPrivate::GetSilentModeAndMixWithOthers()
1223 {
1224 std::lock_guard<std::mutex> lock(silentModeAndMixWithOthersMutex_);
1225 return audioStream_->GetSilentModeAndMixWithOthers();
1226 }
1227
SetParallelPlayFlag(bool parallelPlayFlag)1228 int32_t AudioRendererPrivate::SetParallelPlayFlag(bool parallelPlayFlag)
1229 {
1230 AUDIO_PRERELEASE_LOGI("parallelPlayFlag %{public}d", parallelPlayFlag);
1231 audioInterrupt_.parallelPlayFlag = parallelPlayFlag;
1232 return SUCCESS;
1233 }
1234
SetLowPowerVolume(float volume) const1235 int32_t AudioRendererPrivate::SetLowPowerVolume(float volume) const
1236 {
1237 return audioStream_->SetLowPowerVolume(volume);
1238 }
1239
GetLowPowerVolume() const1240 float AudioRendererPrivate::GetLowPowerVolume() const
1241 {
1242 return audioStream_->GetLowPowerVolume();
1243 }
1244
SetOffloadAllowed(bool isAllowed)1245 int32_t AudioRendererPrivate::SetOffloadAllowed(bool isAllowed)
1246 {
1247 AUDIO_PRERELEASE_LOGI("offload allowed: %{public}d", isAllowed);
1248 rendererInfo_.isOffloadAllowed = isAllowed;
1249 audioStream_->SetRendererInfo(rendererInfo_);
1250 return SUCCESS;
1251 }
1252
SetOffloadMode(int32_t state,bool isAppBack) const1253 int32_t AudioRendererPrivate::SetOffloadMode(int32_t state, bool isAppBack) const
1254 {
1255 AUDIO_INFO_LOG("set offload mode for session %{public}u", sessionID_);
1256 return audioStream_->SetOffloadMode(state, isAppBack);
1257 }
1258
UnsetOffloadMode() const1259 int32_t AudioRendererPrivate::UnsetOffloadMode() const
1260 {
1261 AUDIO_INFO_LOG("session %{public}u session unset offload", sessionID_);
1262 int32_t ret = audioStream_->UnsetOffloadMode();
1263 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "unset offload failed");
1264 return SUCCESS;
1265 }
1266
GetSingleStreamVolume() const1267 float AudioRendererPrivate::GetSingleStreamVolume() const
1268 {
1269 return audioStream_->GetSingleStreamVolume();
1270 }
1271
GetMinStreamVolume() const1272 float AudioRendererPrivate::GetMinStreamVolume() const
1273 {
1274 return AudioPolicyManager::GetInstance().GetMinStreamVolume();
1275 }
1276
GetMaxStreamVolume() const1277 float AudioRendererPrivate::GetMaxStreamVolume() const
1278 {
1279 return AudioPolicyManager::GetInstance().GetMaxStreamVolume();
1280 }
1281
GetCurrentOutputDevices(DeviceInfo & deviceInfo) const1282 int32_t AudioRendererPrivate::GetCurrentOutputDevices(DeviceInfo &deviceInfo) const
1283 {
1284 std::vector<std::unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
1285 uint32_t sessionId = static_cast<uint32_t>(-1);
1286 int32_t ret = GetAudioStreamId(sessionId);
1287 CHECK_AND_RETURN_RET_LOG(!ret, ret, " Get sessionId failed");
1288
1289 ret = AudioPolicyManager::GetInstance().GetCurrentRendererChangeInfos(audioRendererChangeInfos);
1290 CHECK_AND_RETURN_RET_LOG(!ret, ret, "Get Current Renderer devices failed");
1291
1292 for (auto it = audioRendererChangeInfos.begin(); it != audioRendererChangeInfos.end(); it++) {
1293 if ((*it)->sessionId == static_cast<int32_t>(sessionId)) {
1294 deviceInfo = (*it)->outputDeviceInfo;
1295 }
1296 }
1297 return SUCCESS;
1298 }
1299
GetUnderflowCount() const1300 uint32_t AudioRendererPrivate::GetUnderflowCount() const
1301 {
1302 return audioStream_->GetUnderflowCount();
1303 }
1304
1305
SetAudioRendererErrorCallback(std::shared_ptr<AudioRendererErrorCallback> errorCallback)1306 void AudioRendererPrivate::SetAudioRendererErrorCallback(std::shared_ptr<AudioRendererErrorCallback> errorCallback)
1307 {
1308 std::shared_lock sharedLock(rendererMutex_);
1309 std::lock_guard lock(audioRendererErrCallbackMutex_);
1310 audioRendererErrorCallback_ = errorCallback;
1311 }
1312
RegisterAudioPolicyServerDiedCb(const int32_t clientPid,const std::shared_ptr<AudioRendererPolicyServiceDiedCallback> & callback)1313 int32_t AudioRendererPrivate::RegisterAudioPolicyServerDiedCb(const int32_t clientPid,
1314 const std::shared_ptr<AudioRendererPolicyServiceDiedCallback> &callback)
1315 {
1316 AUDIO_INFO_LOG("RegisterAudioPolicyServerDiedCb client id: %{public}d", clientPid);
1317 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "callback is null");
1318
1319 std::lock_guard<std::mutex> lock(policyServiceDiedCallbackMutex_);
1320
1321 policyServiceDiedCallback_ = callback;
1322 return AudioPolicyManager::GetInstance().RegisterAudioPolicyServerDiedCb(clientPid, callback);
1323 }
1324
UnregisterAudioPolicyServerDiedCb(const int32_t clientPid)1325 int32_t AudioRendererPrivate::UnregisterAudioPolicyServerDiedCb(const int32_t clientPid)
1326 {
1327 AUDIO_INFO_LOG("UnregisterAudioPolicyServerDiedCb client id: %{public}d", clientPid);
1328 return AudioPolicyManager::GetInstance().UnregisterAudioPolicyServerDiedCb(clientPid);
1329 }
1330
RegisterOutputDeviceChangeWithInfoCallback(const std::shared_ptr<AudioRendererOutputDeviceChangeCallback> & callback)1331 int32_t AudioRendererPrivate::RegisterOutputDeviceChangeWithInfoCallback(
1332 const std::shared_ptr<AudioRendererOutputDeviceChangeCallback> &callback)
1333 {
1334 AUDIO_INFO_LOG("in");
1335 if (callback == nullptr) {
1336 AUDIO_ERR_LOG("callback is null");
1337 return ERR_INVALID_PARAM;
1338 }
1339
1340 outputDeviceChangeCallback_->SaveCallback(callback);
1341 AUDIO_DEBUG_LOG("successful!");
1342 return SUCCESS;
1343 }
1344
UnregisterOutputDeviceChangeWithInfoCallback()1345 int32_t AudioRendererPrivate::UnregisterOutputDeviceChangeWithInfoCallback()
1346 {
1347 AUDIO_INFO_LOG("Unregister all");
1348
1349 outputDeviceChangeCallback_->RemoveCallback();
1350 return SUCCESS;
1351 }
1352
UnregisterOutputDeviceChangeWithInfoCallback(const std::shared_ptr<AudioRendererOutputDeviceChangeCallback> & callback)1353 int32_t AudioRendererPrivate::UnregisterOutputDeviceChangeWithInfoCallback(
1354 const std::shared_ptr<AudioRendererOutputDeviceChangeCallback> &callback)
1355 {
1356 AUDIO_INFO_LOG("in");
1357
1358 outputDeviceChangeCallback_->RemoveCallback(callback);
1359 return SUCCESS;
1360 }
1361
SetSwitchInfo(IAudioStream::SwitchInfo info,std::shared_ptr<IAudioStream> audioStream)1362 void AudioRendererPrivate::SetSwitchInfo(IAudioStream::SwitchInfo info, std::shared_ptr<IAudioStream> audioStream)
1363 {
1364 CHECK_AND_RETURN_LOG(audioStream, "stream is nullptr");
1365
1366 audioStream->SetStreamTrackerState(false);
1367 audioStream->SetApplicationCachePath(info.cachePath);
1368 audioStream->SetClientID(info.clientPid, info.clientUid, appInfo_.appTokenId, appInfo_.appFullTokenId);
1369 audioStream->SetPrivacyType(info.privacyType);
1370 audioStream->SetRendererInfo(info.rendererInfo);
1371 audioStream->SetCapturerInfo(info.capturerInfo);
1372 audioStream->SetAudioStreamInfo(info.params, rendererProxyObj_);
1373 audioStream->SetRenderMode(info.renderMode);
1374 audioStream->SetAudioEffectMode(info.effectMode);
1375 audioStream->SetVolume(info.volume);
1376 audioStream->SetUnderflowCount(info.underFlowCount);
1377
1378 if (info.userSettedPreferredFrameSize.has_value()) {
1379 audioStream->SetPreferredFrameSize(info.userSettedPreferredFrameSize.value());
1380 }
1381
1382 audioStream->SetSilentModeAndMixWithOthers(info.silentModeAndMixWithOthers);
1383
1384 // set callback
1385 if ((info.renderPositionCb != nullptr) && (info.frameMarkPosition > 0)) {
1386 audioStream->SetRendererPositionCallback(info.frameMarkPosition, info.renderPositionCb);
1387 }
1388
1389 if ((info.capturePositionCb != nullptr) && (info.frameMarkPosition > 0)) {
1390 audioStream->SetCapturerPositionCallback(info.frameMarkPosition, info.capturePositionCb);
1391 }
1392
1393 if ((info.renderPeriodPositionCb != nullptr) && (info.framePeriodNumber > 0)) {
1394 audioStream->SetRendererPeriodPositionCallback(info.framePeriodNumber, info.renderPeriodPositionCb);
1395 }
1396
1397 if ((info.capturePeriodPositionCb != nullptr) && (info.framePeriodNumber > 0)) {
1398 audioStream->SetCapturerPeriodPositionCallback(info.framePeriodNumber, info.capturePeriodPositionCb);
1399 }
1400
1401 audioStream->SetStreamCallback(info.audioStreamCallback);
1402 audioStream->SetRendererWriteCallback(info.rendererWriteCallback);
1403
1404 audioStream->SetRendererFirstFrameWritingCallback(info.rendererFirstFrameWritingCallback);
1405 }
1406
UpdateRendererAudioStream(const std::shared_ptr<IAudioStream> & audioStream)1407 void AudioRendererPrivate::UpdateRendererAudioStream(const std::shared_ptr<IAudioStream> &audioStream)
1408 {
1409 if (audioInterruptCallback_ != nullptr) {
1410 std::shared_ptr<AudioRendererInterruptCallbackImpl> interruptCbImpl =
1411 std::static_pointer_cast<AudioRendererInterruptCallbackImpl>(audioInterruptCallback_);
1412 interruptCbImpl->UpdateAudioStream(audioStream_);
1413 }
1414 }
1415
InitSwitchInfo(IAudioStream::StreamClass targetClass,IAudioStream::SwitchInfo & info)1416 void AudioRendererPrivate::InitSwitchInfo(IAudioStream::StreamClass targetClass, IAudioStream::SwitchInfo &info)
1417 {
1418 audioStream_->GetSwitchInfo(info);
1419 if (targetClass == IAudioStream::VOIP_STREAM) {
1420 info.rendererInfo.originalFlag = AUDIO_FLAG_VOIP_FAST;
1421 }
1422
1423 if (rendererInfo_.rendererFlags == AUDIO_FLAG_VOIP_DIRECT) {
1424 info.rendererInfo.originalFlag = AUDIO_FLAG_VOIP_DIRECT;
1425 info.rendererInfo.rendererFlags = AUDIO_FLAG_VOIP_DIRECT;
1426 info.rendererFlags = AUDIO_FLAG_VOIP_DIRECT;
1427 } else if (rendererInfo_.rendererFlags == AUDIO_FLAG_DIRECT) {
1428 info.rendererInfo.pipeType = PIPE_TYPE_DIRECT_MUSIC;
1429 info.rendererFlags = AUDIO_FLAG_DIRECT;
1430 }
1431 info.params.originalSessionId = sessionID_;
1432 return;
1433 }
1434
SwitchToTargetStream(IAudioStream::StreamClass targetClass,uint32_t & newSessionId,const AudioStreamDeviceChangeReasonExt reason)1435 bool AudioRendererPrivate::SwitchToTargetStream(IAudioStream::StreamClass targetClass, uint32_t &newSessionId,
1436 const AudioStreamDeviceChangeReasonExt reason)
1437 {
1438 bool switchResult = false;
1439 if (audioStream_) {
1440 Trace trace("SwitchToTargetStream");
1441 std::shared_ptr<IAudioStream> oldAudioStream = nullptr;
1442 std::lock_guard<std::shared_mutex> lock(rendererMutex_);
1443 isSwitching_ = true;
1444 RendererState previousState = GetStatus();
1445 AUDIO_INFO_LOG("Previous stream state: %{public}d, original sessionId: %{public}u", previousState, sessionID_);
1446 if (previousState == RENDERER_RUNNING) {
1447 CHECK_AND_RETURN_RET_LOG(audioStream_->StopAudioStream(), false, "StopAudioStream failed.");
1448 }
1449 IAudioStream::SwitchInfo info;
1450 InitSwitchInfo(targetClass, info);
1451 int64_t framesWritten = audioStream_->GetFramesWritten();
1452 if (framesWritten > 0) {
1453 framesAlreadyWritten_ += framesWritten;
1454 AUDIO_INFO_LOG("Frames already written: %{public}" PRId64 ", current stream value: %{public}" PRId64 ".",
1455 framesAlreadyWritten_, framesWritten);
1456 }
1457
1458 switchResult = audioStream_->ReleaseAudioStream(true, true);
1459 std::shared_ptr<IAudioStream> newAudioStream = IAudioStream::GetPlaybackStream(targetClass, info.params,
1460 info.eStreamType, appInfo_.appPid);
1461 CHECK_AND_RETURN_RET_LOG(newAudioStream != nullptr, false, "SetParams GetPlayBackStream failed.");
1462 AUDIO_INFO_LOG("Get new stream success!");
1463
1464 // set new stream info
1465 SetSwitchInfo(info, newAudioStream);
1466
1467 CHECK_AND_RETURN_RET_LOG(switchResult, false, "release old stream failed.");
1468
1469 if (previousState == RENDERER_RUNNING) {
1470 // restart audio stream
1471 switchResult = newAudioStream->StartAudioStream(CMD_FROM_CLIENT, reason);
1472 CHECK_AND_RETURN_RET_LOG(switchResult, false, "start new stream failed.");
1473 }
1474 oldAudioStream = audioStream_;
1475 audioStream_ = newAudioStream;
1476 UpdateRendererAudioStream(audioStream_);
1477 isSwitching_ = false;
1478 audioStream_->GetAudioSessionID(newSessionId);
1479 switchResult = true;
1480 SetDefaultOutputDevice(selectedDefaultOutputDevice_);
1481 }
1482 WriteSwitchStreamLogMsg();
1483 return switchResult;
1484 }
1485
WriteSwitchStreamLogMsg()1486 void AudioRendererPrivate::WriteSwitchStreamLogMsg()
1487 {
1488 std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
1489 Media::MediaMonitor::ModuleId::AUDIO, Media::MediaMonitor::EventId::AUDIO_PIPE_CHANGE,
1490 Media::MediaMonitor::EventType::BEHAVIOR_EVENT);
1491 bean->Add("CLIENT_UID", appInfo_.appUid);
1492 bean->Add("IS_PLAYBACK", 1);
1493 bean->Add("STREAM_TYPE", rendererInfo_.streamUsage);
1494 bean->Add("PIPE_TYPE_BEFORE_CHANGE", PIPE_TYPE_LOWLATENCY_OUT);
1495 bean->Add("PIPE_TYPE_AFTER_CHANGE", PIPE_TYPE_NORMAL_OUT);
1496 bean->Add("REASON", Media::MediaMonitor::DEVICE_CHANGE_FROM_FAST);
1497 Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
1498 }
1499
SwitchStream(const uint32_t sessionId,const int32_t streamFlag,const AudioStreamDeviceChangeReasonExt reason)1500 void AudioRendererPrivate::SwitchStream(const uint32_t sessionId, const int32_t streamFlag,
1501 const AudioStreamDeviceChangeReasonExt reason)
1502 {
1503 IAudioStream::StreamClass targetClass = IAudioStream::PA_STREAM;
1504 switch (streamFlag) {
1505 case AUDIO_FLAG_NORMAL:
1506 rendererInfo_.rendererFlags = AUDIO_FLAG_NORMAL;
1507 targetClass = IAudioStream::PA_STREAM;
1508 break;
1509 case AUDIO_FLAG_MMAP:
1510 rendererInfo_.rendererFlags = AUDIO_FLAG_MMAP;
1511 targetClass = IAudioStream::FAST_STREAM;
1512 break;
1513 case AUDIO_FLAG_VOIP_FAST:
1514 rendererInfo_.rendererFlags = AUDIO_FLAG_VOIP_FAST;
1515 targetClass = IAudioStream::VOIP_STREAM;
1516 break;
1517 case AUDIO_FLAG_VOIP_DIRECT:
1518 rendererInfo_.rendererFlags = (isDirectVoipSupported_ && audioRenderMode_ == RENDER_MODE_CALLBACK) ?
1519 AUDIO_FLAG_VOIP_DIRECT : AUDIO_FLAG_NORMAL;
1520 targetClass = IAudioStream::PA_STREAM;
1521 break;
1522 case AUDIO_FLAG_DIRECT:
1523 rendererInfo_.rendererFlags = AUDIO_FLAG_DIRECT;
1524 break;
1525 }
1526 if (rendererInfo_.originalFlag == AUDIO_FLAG_FORCED_NORMAL) {
1527 rendererInfo_.rendererFlags = AUDIO_FLAG_NORMAL;
1528 targetClass = IAudioStream::PA_STREAM;
1529 }
1530
1531 uint32_t newSessionId = 0;
1532 if (!SwitchToTargetStream(targetClass, newSessionId, reason)) {
1533 int32_t ret = AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt_);
1534 CHECK_AND_RETURN_LOG(ret == 0, "DeactivateAudioInterrupt Failed");
1535 if (audioRendererErrorCallback_) {
1536 audioRendererErrorCallback_->OnError(ERROR_SYSTEM);
1537 }
1538 }
1539 usedSessionId_.push_back(newSessionId);
1540 int32_t ret = AudioPolicyManager::GetInstance().RegisterDeviceChangeWithInfoCallback(newSessionId,
1541 outputDeviceChangeCallback_);
1542 CHECK_AND_RETURN_LOG(ret == SUCCESS, "Register device change callback for new session failed");
1543 }
1544
OnDeviceChangeWithInfo(const uint32_t sessionId,const DeviceInfo & deviceInfo,const AudioStreamDeviceChangeReasonExt reason)1545 void OutputDeviceChangeWithInfoCallbackImpl::OnDeviceChangeWithInfo(
1546 const uint32_t sessionId, const DeviceInfo &deviceInfo, const AudioStreamDeviceChangeReasonExt reason)
1547 {
1548 AUDIO_INFO_LOG("OnRendererStateChange");
1549 std::vector<std::shared_ptr<AudioRendererOutputDeviceChangeCallback>> callbacks;
1550
1551 {
1552 std::lock_guard<std::mutex> lock(callbackMutex_);
1553 callbacks = callbacks_;
1554 }
1555
1556 for (auto &cb : callbacks) {
1557 if (cb != nullptr) {
1558 cb->OnOutputDeviceChange(deviceInfo, reason);
1559 }
1560 }
1561
1562 AUDIO_INFO_LOG("sessionId: %{public}u, deviceType: %{public}d reason: %{public}d size: %{public}zu",
1563 sessionId, static_cast<int>(deviceInfo.deviceType), static_cast<int>(reason), callbacks.size());
1564 }
1565
OnRecreateStreamEvent(const uint32_t sessionId,const int32_t streamFlag,const AudioStreamDeviceChangeReasonExt reason)1566 void OutputDeviceChangeWithInfoCallbackImpl::OnRecreateStreamEvent(const uint32_t sessionId, const int32_t streamFlag,
1567 const AudioStreamDeviceChangeReasonExt reason)
1568 {
1569 std::lock_guard<std::mutex> lock(audioRendererObjMutex_);
1570 AUDIO_INFO_LOG("Enter, session id: %{public}d, stream flag: %{public}d", sessionId, streamFlag);
1571 CHECK_AND_RETURN_LOG(renderer_ != nullptr, "renderer_ is nullptr");
1572 renderer_->SwitchStream(sessionId, streamFlag, reason);
1573 }
1574
GetAudioEffectMode() const1575 AudioEffectMode AudioRendererPrivate::GetAudioEffectMode() const
1576 {
1577 return audioStream_->GetAudioEffectMode();
1578 }
1579
GetFramesWritten() const1580 int64_t AudioRendererPrivate::GetFramesWritten() const
1581 {
1582 return framesAlreadyWritten_ + audioStream_->GetFramesWritten();
1583 }
1584
SetAudioEffectMode(AudioEffectMode effectMode) const1585 int32_t AudioRendererPrivate::SetAudioEffectMode(AudioEffectMode effectMode) const
1586 {
1587 return audioStream_->SetAudioEffectMode(effectMode);
1588 }
1589
SetVolumeWithRamp(float volume,int32_t duration)1590 int32_t AudioRendererPrivate::SetVolumeWithRamp(float volume, int32_t duration)
1591 {
1592 AUDIO_INFO_LOG("volume:%{public}f duration:%{public}d", volume, duration);
1593 CHECK_AND_RETURN_RET(audioStream_ != nullptr, ERR_INVALID_PARAM, "Error status");
1594 return audioStream_->SetVolumeWithRamp(volume, duration);
1595 }
1596
SetPreferredFrameSize(int32_t frameSize)1597 void AudioRendererPrivate::SetPreferredFrameSize(int32_t frameSize)
1598 {
1599 std::shared_lock<std::shared_mutex> lock(rendererMutex_);
1600 audioStream_->SetPreferredFrameSize(frameSize);
1601 }
1602
GetAudioInterrupt(AudioInterrupt & audioInterrupt)1603 void AudioRendererPrivate::GetAudioInterrupt(AudioInterrupt &audioInterrupt)
1604 {
1605 audioInterrupt = audioInterrupt_;
1606 }
1607
WriteUnderrunEvent() const1608 void AudioRendererPrivate::WriteUnderrunEvent() const
1609 {
1610 AUDIO_INFO_LOG("AudioRendererPrivate WriteUnderrunEvent!");
1611 if (GetUnderflowCount() < WRITE_UNDERRUN_NUM) {
1612 return;
1613 }
1614 AudioPipeType pipeType = PIPE_TYPE_NORMAL_OUT;
1615 IAudioStream::StreamClass streamClass = audioStream_->GetStreamClass();
1616 if (streamClass == IAudioStream::FAST_STREAM) {
1617 pipeType = PIPE_TYPE_LOWLATENCY_OUT;
1618 } else if (streamClass == IAudioStream::PA_STREAM) {
1619 if (audioStream_->GetOffloadEnable()) {
1620 pipeType = PIPE_TYPE_OFFLOAD;
1621 } else if (audioStream_->GetSpatializationEnabled()) {
1622 pipeType = PIPE_TYPE_SPATIALIZATION;
1623 } else if (audioStream_->GetHighResolutionEnabled()) {
1624 pipeType = PIPE_TYPE_HIGHRESOLUTION;
1625 }
1626 }
1627 std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
1628 Media::MediaMonitor::ModuleId::AUDIO, Media::MediaMonitor::EventId::PERFORMANCE_UNDER_OVERRUN_STATS,
1629 Media::MediaMonitor::EventType::FREQUENCY_AGGREGATION_EVENT);
1630 bean->Add("IS_PLAYBACK", 1);
1631 bean->Add("CLIENT_UID", appInfo_.appUid);
1632 bean->Add("PIPE_TYPE", pipeType);
1633 bean->Add("STREAM_TYPE", rendererInfo_.streamUsage);
1634 Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
1635 }
1636
RegisterRendererPolicyServiceDiedCallback()1637 int32_t AudioRendererPrivate::RegisterRendererPolicyServiceDiedCallback()
1638 {
1639 AUDIO_DEBUG_LOG("RegisterRendererPolicyServiceDiedCallback");
1640 if (!audioPolicyServiceDiedCallback_) {
1641 audioPolicyServiceDiedCallback_ = std::make_shared<RendererPolicyServiceDiedCallback>();
1642 if (!audioPolicyServiceDiedCallback_) {
1643 AUDIO_ERR_LOG("Memory allocation failed!!");
1644 return ERROR;
1645 }
1646 AudioPolicyManager::GetInstance().RegisterAudioStreamPolicyServerDiedCb(audioPolicyServiceDiedCallback_);
1647 audioPolicyServiceDiedCallback_->SetAudioRendererObj(this);
1648 audioPolicyServiceDiedCallback_->SetAudioInterrupt(audioInterrupt_);
1649 }
1650 return SUCCESS;
1651 }
1652
RemoveRendererPolicyServiceDiedCallback()1653 int32_t AudioRendererPrivate::RemoveRendererPolicyServiceDiedCallback()
1654 {
1655 AUDIO_DEBUG_LOG("RemoveRendererPolicyServiceDiedCallback");
1656 if (audioPolicyServiceDiedCallback_) {
1657 int32_t ret = AudioPolicyManager::GetInstance().UnregisterAudioStreamPolicyServerDiedCb(
1658 audioPolicyServiceDiedCallback_);
1659 if (ret != 0) {
1660 AUDIO_ERR_LOG("RemoveRendererPolicyServiceDiedCallback failed");
1661 audioPolicyServiceDiedCallback_ = nullptr;
1662 return ERROR;
1663 }
1664 }
1665 audioPolicyServiceDiedCallback_ = nullptr;
1666 return SUCCESS;
1667 }
1668
RendererPolicyServiceDiedCallback()1669 RendererPolicyServiceDiedCallback::RendererPolicyServiceDiedCallback()
1670 {
1671 AUDIO_DEBUG_LOG("RendererPolicyServiceDiedCallback create");
1672 }
1673
~RendererPolicyServiceDiedCallback()1674 RendererPolicyServiceDiedCallback::~RendererPolicyServiceDiedCallback()
1675 {
1676 AUDIO_DEBUG_LOG("RendererPolicyServiceDiedCallback destroy");
1677 if (restoreThread_ != nullptr && restoreThread_->joinable()) {
1678 restoreThread_->join();
1679 restoreThread_.reset();
1680 restoreThread_ = nullptr;
1681 }
1682 }
1683
SetAudioRendererObj(AudioRendererPrivate * rendererObj)1684 void RendererPolicyServiceDiedCallback::SetAudioRendererObj(AudioRendererPrivate *rendererObj)
1685 {
1686 renderer_ = rendererObj;
1687 }
1688
SetAudioInterrupt(AudioInterrupt & audioInterrupt)1689 void RendererPolicyServiceDiedCallback::SetAudioInterrupt(AudioInterrupt &audioInterrupt)
1690 {
1691 audioInterrupt_ = audioInterrupt;
1692 }
1693
OnAudioPolicyServiceDied()1694 void RendererPolicyServiceDiedCallback::OnAudioPolicyServiceDied()
1695 {
1696 AUDIO_INFO_LOG("RendererPolicyServiceDiedCallback::OnAudioPolicyServiceDied");
1697 if (restoreThread_ != nullptr) {
1698 restoreThread_->detach();
1699 }
1700 restoreThread_ = std::make_unique<std::thread>([this] { this->RestoreTheadLoop(); });
1701 pthread_setname_np(restoreThread_->native_handle(), "OS_ARPSRestore");
1702 }
1703
RestoreTheadLoop()1704 void RendererPolicyServiceDiedCallback::RestoreTheadLoop()
1705 {
1706 int32_t tryCounter = 10;
1707 uint32_t sleepTime = 300000;
1708 bool restoreResult = false;
1709 while (!restoreResult && tryCounter > 0) {
1710 tryCounter--;
1711 usleep(sleepTime);
1712 if (renderer_ == nullptr || renderer_->audioStream_ == nullptr || renderer_->abortRestore_) {
1713 AUDIO_INFO_LOG("abort restore");
1714 break;
1715 }
1716 renderer_->RestoreAudioInLoop(restoreResult, tryCounter);
1717 }
1718 }
1719
RestoreAudioInLoop(bool & restoreResult,int32_t & tryCounter)1720 void AudioRendererPrivate::RestoreAudioInLoop(bool &restoreResult, int32_t &tryCounter)
1721 {
1722 std::lock_guard<std::shared_mutex> lock(rendererMutex_);
1723 if (IsNoStreamRenderer()) {
1724 // no stream renderer don't need to restore stream
1725 restoreResult = audioStream_->RestoreAudioStream(false);
1726 } else {
1727 restoreResult = audioStream_->RestoreAudioStream();
1728 if (!restoreResult) {
1729 AUDIO_ERR_LOG("restore audio stream failed, %{public}d attempts remaining", tryCounter);
1730 return;
1731 }
1732 abortRestore_ = false;
1733 }
1734
1735 if (GetStatus() == RENDERER_RUNNING) {
1736 GetAudioInterrupt(audioInterrupt_);
1737 int32_t ret = AudioPolicyManager::GetInstance().ActivateAudioInterrupt(audioInterrupt_);
1738 if (ret != SUCCESS) {
1739 AUDIO_ERR_LOG("active audio interrupt failed");
1740 }
1741 }
1742 return;
1743 }
1744
SetSpeed(float speed)1745 int32_t AudioRendererPrivate::SetSpeed(float speed)
1746 {
1747 AUDIO_INFO_LOG("set speed %{public}f", speed);
1748 CHECK_AND_RETURN_RET_LOG((speed >= MIN_STREAM_SPEED_LEVEL) && (speed <= MAX_STREAM_SPEED_LEVEL),
1749 ERR_INVALID_PARAM, "invaild speed index");
1750 #ifdef SONIC_ENABLE
1751 audioStream_->SetSpeed(speed);
1752 #endif
1753 speed_ = speed;
1754 return SUCCESS;
1755 }
1756
GetSpeed()1757 float AudioRendererPrivate::GetSpeed()
1758 {
1759 #ifdef SONIC_ENABLE
1760 return audioStream_->GetSpeed();
1761 #endif
1762 return speed_;
1763 }
1764
IsFastRenderer()1765 bool AudioRendererPrivate::IsFastRenderer()
1766 {
1767 return isFastRenderer_;
1768 }
1769
InitLatencyMeasurement(const AudioStreamParams & audioStreamParams)1770 void AudioRendererPrivate::InitLatencyMeasurement(const AudioStreamParams &audioStreamParams)
1771 {
1772 latencyMeasEnabled_ = AudioLatencyMeasurement::CheckIfEnabled();
1773 AUDIO_INFO_LOG("LatencyMeas enabled in renderer:%{public}d", latencyMeasEnabled_);
1774 if (!latencyMeasEnabled_) {
1775 return;
1776 }
1777 std::string bundleName = AudioSystemManager::GetInstance()->GetSelfBundleName(appInfo_.appUid);
1778 uint32_t sessionId = 0;
1779 audioStream_->GetAudioSessionID(sessionId);
1780 latencyMeasurement_ = std::make_shared<AudioLatencyMeasurement>(audioStreamParams.samplingRate,
1781 audioStreamParams.channels, audioStreamParams.format, bundleName, sessionId);
1782 }
1783
MockPcmData(uint8_t * buffer,size_t bufferSize) const1784 void AudioRendererPrivate::MockPcmData(uint8_t *buffer, size_t bufferSize) const
1785 {
1786 if (!latencyMeasEnabled_) {
1787 return;
1788 }
1789 if (latencyMeasurement_->MockPcmData(buffer, bufferSize)) {
1790 std::string timestamp = GetTime();
1791 audioStream_->UpdateLatencyTimestamp(timestamp, true);
1792 }
1793 }
1794
ActivateAudioConcurrency(const AudioStreamParams & audioStreamParams,const AudioStreamType & streamType,IAudioStream::StreamClass & streamClass)1795 void AudioRendererPrivate::ActivateAudioConcurrency(const AudioStreamParams &audioStreamParams,
1796 const AudioStreamType &streamType, IAudioStream::StreamClass &streamClass)
1797 {
1798 rendererInfo_.pipeType = PIPE_TYPE_NORMAL_OUT;
1799 if (rendererInfo_.streamUsage == STREAM_USAGE_VOICE_COMMUNICATION ||
1800 rendererInfo_.streamUsage == STREAM_USAGE_VOICE_MODEM_COMMUNICATION ||
1801 rendererInfo_.streamUsage == STREAM_USAGE_VIDEO_COMMUNICATION) {
1802 rendererInfo_.pipeType = PIPE_TYPE_CALL_OUT;
1803 } else if (streamClass == IAudioStream::FAST_STREAM) {
1804 rendererInfo_.pipeType = PIPE_TYPE_LOWLATENCY_OUT;
1805 } else {
1806 std::vector<sptr<AudioDeviceDescriptor>> deviceDescriptors =
1807 AudioPolicyManager::GetInstance().GetPreferredOutputDeviceDescriptors(rendererInfo_);
1808 if (!deviceDescriptors.empty() && deviceDescriptors[0] != nullptr) {
1809 if ((deviceDescriptors[0]->deviceType_ == DEVICE_TYPE_USB_HEADSET ||
1810 deviceDescriptors[0]->deviceType_ == DEVICE_TYPE_WIRED_HEADSET) &&
1811 streamType == STREAM_MUSIC && audioStreamParams.samplingRate >= SAMPLE_RATE_48000 &&
1812 audioStreamParams.format >= SAMPLE_S24LE) {
1813 rendererInfo_.pipeType = PIPE_TYPE_DIRECT_MUSIC;
1814 }
1815 }
1816 }
1817 int32_t ret = AudioPolicyManager::GetInstance().ActivateAudioConcurrency(rendererInfo_.pipeType);
1818 if (ret != SUCCESS) {
1819 if (streamClass == IAudioStream::FAST_STREAM) {
1820 streamClass = IAudioStream::PA_STREAM;
1821 }
1822 rendererInfo_.pipeType = PIPE_TYPE_NORMAL_OUT;
1823 }
1824 return;
1825 }
1826
ConcedeStream()1827 void AudioRendererPrivate::ConcedeStream()
1828 {
1829 AUDIO_INFO_LOG("session %{public}u concede from pipeType %{public}d", sessionID_, rendererInfo_.pipeType);
1830 uint32_t sessionId = static_cast<uint32_t>(-1);
1831 int32_t ret = GetAudioStreamId(sessionId);
1832 CHECK_AND_RETURN_LOG(!ret, "Get sessionId failed");
1833
1834 AudioPipeType pipeType = PIPE_TYPE_NORMAL_OUT;
1835 audioStream_->GetAudioPipeType(pipeType);
1836 rendererInfo_.pipeType = PIPE_TYPE_NORMAL_OUT;
1837 rendererInfo_.isOffloadAllowed = false;
1838 audioStream_->SetRendererInfo(rendererInfo_);
1839 switch (pipeType) {
1840 case PIPE_TYPE_LOWLATENCY_OUT:
1841 case PIPE_TYPE_DIRECT_MUSIC:
1842 SwitchStream(sessionId, IAudioStream::PA_STREAM, AudioStreamDeviceChangeReasonExt::ExtEnum::UNKNOWN);
1843 break;
1844 case PIPE_TYPE_OFFLOAD:
1845 UnsetOffloadMode();
1846 AudioPolicyManager::GetInstance().MoveToNewPipe(sessionId, PIPE_TYPE_NORMAL_OUT);
1847 break;
1848 default:
1849 break;
1850 }
1851 }
1852
EnableVoiceModemCommunicationStartStream(bool enable)1853 void AudioRendererPrivate::EnableVoiceModemCommunicationStartStream(bool enable)
1854 {
1855 isEnableVoiceModemCommunicationStartStream_ = enable;
1856 }
1857
IsNoStreamRenderer() const1858 bool AudioRendererPrivate::IsNoStreamRenderer() const
1859 {
1860 return rendererInfo_.streamUsage == STREAM_USAGE_VOICE_MODEM_COMMUNICATION &&
1861 !isEnableVoiceModemCommunicationStartStream_;
1862 }
1863
SetDefaultOutputDevice(DeviceType deviceType)1864 int32_t AudioRendererPrivate::SetDefaultOutputDevice(DeviceType deviceType)
1865 {
1866 if (deviceType != DEVICE_TYPE_EARPIECE && deviceType != DEVICE_TYPE_SPEAKER &&
1867 deviceType != DEVICE_TYPE_DEFAULT) {
1868 return ERR_NOT_SUPPORTED;
1869 }
1870 bool isSupportedStreamUsage = (find(AUDIO_DEFAULT_OUTPUT_DEVICE_SUPPORTED_STREAM_USAGES.begin(),
1871 AUDIO_DEFAULT_OUTPUT_DEVICE_SUPPORTED_STREAM_USAGES.end(), rendererInfo_.streamUsage) !=
1872 AUDIO_DEFAULT_OUTPUT_DEVICE_SUPPORTED_STREAM_USAGES.end());
1873 CHECK_AND_RETURN_RET_LOG(isSupportedStreamUsage, ERR_NOT_SUPPORTED, "stream usage not supported");
1874 selectedDefaultOutputDevice_ = deviceType;
1875 uint32_t currentSessionID = 0;
1876 audioStream_->GetAudioSessionID(currentSessionID);
1877 int32_t ret = AudioPolicyManager::GetInstance().SetDefaultOutputDevice(deviceType, currentSessionID,
1878 rendererInfo_.streamUsage, GetStatus() == RENDERER_RUNNING);
1879 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "select default output device failed");
1880 return SUCCESS;
1881 }
1882 } // namespace AudioStandard
1883 } // namespace OHOS
1884