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