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