1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <sstream>
17
18 #include "audio_renderer.h"
19 #include "audio_renderer_private.h"
20
21 #include "audio_log.h"
22 #include "audio_errors.h"
23 #include "audio_policy_manager.h"
24 #include "audio_utils.h"
25 #ifdef OHCORE
26 #include "audio_renderer_gateway.h"
27 #endif
28
29 namespace OHOS {
30 namespace AudioStandard {
31
32 static const int32_t MAX_VOLUME_LEVEL = 15;
33 static const int32_t CONST_FACTOR = 100;
34 static const std::vector<StreamUsage> NEED_VERFITY_PERMISSION_STREAMS = {
35 STREAM_USAGE_SYSTEM,
36 STREAM_USAGE_DTMF,
37 STREAM_USAGE_ENFORCED_TONE,
38 STREAM_USAGE_ULTRASONIC,
39 STREAM_USAGE_VOICE_MODEM_COMMUNICATION
40 };
41
VolumeToDb(int32_t volumeLevel)42 static float VolumeToDb(int32_t volumeLevel)
43 {
44 float value = static_cast<float>(volumeLevel) / MAX_VOLUME_LEVEL;
45 float roundValue = static_cast<int>(value * CONST_FACTOR);
46
47 return static_cast<float>(roundValue) / CONST_FACTOR;
48 }
49
isNeedVerfityPermission(const StreamUsage streamUsage)50 static bool isNeedVerfityPermission(const StreamUsage streamUsage)
51 {
52 for (const auto& item : NEED_VERFITY_PERMISSION_STREAMS) {
53 if (streamUsage == item) {
54 return true;
55 }
56 }
57 return false;
58 }
59
60 std::mutex AudioRenderer::createRendererMutex_;
61
62 AudioRenderer::~AudioRenderer() = default;
~AudioRendererPrivate()63 AudioRendererPrivate::~AudioRendererPrivate()
64 {
65 RendererState state = GetStatus();
66 if (state != RENDERER_RELEASED && state != RENDERER_NEW) {
67 Release();
68 }
69
70 if (isFastRenderer_) {
71 // Unregister the renderer event callaback in policy server
72 (void)AudioPolicyManager::GetInstance().UnregisterAudioRendererEventListener(appInfo_.appPid);
73 }
74 #ifdef DUMP_CLIENT_PCM
75 if (dcp_) {
76 fclose(dcp_);
77 dcp_ = nullptr;
78 }
79 #endif
80 }
81
CheckMaxRendererInstances()82 int32_t AudioRenderer::CheckMaxRendererInstances()
83 {
84 std::vector<std::unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
85 AudioPolicyManager::GetInstance().GetCurrentRendererChangeInfos(audioRendererChangeInfos);
86 AUDIO_INFO_LOG("Audio current renderer change infos size: %{public}zu", audioRendererChangeInfos.size());
87 int32_t maxRendererInstances = AudioPolicyManager::GetInstance().GetMaxRendererInstances();
88 CHECK_AND_RETURN_RET_LOG(audioRendererChangeInfos.size() < static_cast<size_t>(maxRendererInstances), ERR_OVERFLOW,
89 "The current number of audio renderer streams is greater than the maximum number of configured instances");
90
91 return SUCCESS;
92 }
93
Create(AudioStreamType audioStreamType)94 std::unique_ptr<AudioRenderer> AudioRenderer::Create(AudioStreamType audioStreamType)
95 {
96 AppInfo appInfo = {};
97 return Create(audioStreamType, appInfo);
98 }
99
Create(AudioStreamType audioStreamType,const AppInfo & appInfo)100 std::unique_ptr<AudioRenderer> AudioRenderer::Create(AudioStreamType audioStreamType, const AppInfo &appInfo)
101 {
102 if (audioStreamType == STREAM_MEDIA) {
103 audioStreamType = STREAM_MUSIC;
104 }
105 #ifdef OHCORE
106 return std::make_unique<AudioRendererGateway>(audioStreamType);
107 #else
108 return std::make_unique<AudioRendererPrivate>(audioStreamType, appInfo, true);
109 #endif
110 }
111
Create(const AudioRendererOptions & rendererOptions)112 std::unique_ptr<AudioRenderer> AudioRenderer::Create(const AudioRendererOptions &rendererOptions)
113 {
114 AppInfo appInfo = {};
115 return Create("", rendererOptions, appInfo);
116 }
117
Create(const AudioRendererOptions & rendererOptions,const AppInfo & appInfo)118 std::unique_ptr<AudioRenderer> AudioRenderer::Create(const AudioRendererOptions &rendererOptions,
119 const AppInfo &appInfo)
120 {
121 return Create("", rendererOptions, appInfo);
122 }
123
Create(const std::string cachePath,const AudioRendererOptions & rendererOptions)124 std::unique_ptr<AudioRenderer> AudioRenderer::Create(const std::string cachePath,
125 const AudioRendererOptions &rendererOptions)
126 {
127 AppInfo appInfo = {};
128 return Create(cachePath, rendererOptions, appInfo);
129 }
130
Create(const std::string cachePath,const AudioRendererOptions & rendererOptions,const AppInfo & appInfo)131 std::unique_ptr<AudioRenderer> AudioRenderer::Create(const std::string cachePath,
132 const AudioRendererOptions &rendererOptions, const AppInfo &appInfo)
133 {
134 Trace trace("AudioRenderer::Create");
135 std::lock_guard<std::mutex> lock(createRendererMutex_);
136 CHECK_AND_RETURN_RET_LOG(AudioRenderer::CheckMaxRendererInstances() == SUCCESS, nullptr,
137 "Too many renderer instances");
138 ContentType contentType = rendererOptions.rendererInfo.contentType;
139 CHECK_AND_RETURN_RET_LOG(contentType >= CONTENT_TYPE_UNKNOWN && contentType <= CONTENT_TYPE_ULTRASONIC, nullptr,
140 "Invalid content type");
141
142 StreamUsage streamUsage = rendererOptions.rendererInfo.streamUsage;
143 CHECK_AND_RETURN_RET_LOG(streamUsage >= STREAM_USAGE_UNKNOWN &&
144 streamUsage <= STREAM_USAGE_VOICE_MODEM_COMMUNICATION, nullptr, "Invalid stream usage");
145 if (contentType == CONTENT_TYPE_ULTRASONIC || isNeedVerfityPermission(streamUsage)) {
146 if (!PermissionUtil::VerifySelfPermission()) {
147 AUDIO_ERR_LOG("CreateAudioRenderer failed! CONTENT_TYPE_ULTRASONIC or STREAM_USAGE_SYSTEM or "\
148 "STREAM_USAGE_VOICE_MODEM_COMMUNICATION: No system permission");
149 return nullptr;
150 }
151 }
152
153 AudioStreamType audioStreamType = IAudioStream::GetStreamType(contentType, streamUsage);
154 #ifdef OHCORE
155 auto audioRenderer = std::make_unique<AudioRendererGateway>(audioStreamType);
156 #else
157 auto audioRenderer = std::make_unique<AudioRendererPrivate>(audioStreamType, appInfo, false);
158 #endif
159 CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, nullptr, "Failed to create renderer object");
160 if (!cachePath.empty()) {
161 AUDIO_DEBUG_LOG("Set application cache path");
162 audioRenderer->cachePath_ = cachePath;
163 }
164
165 int32_t rendererFlags = rendererOptions.rendererInfo.rendererFlags;
166 AUDIO_INFO_LOG("create audiorenderer with usage: %{public}d, content: %{public}d, flags: %{public}d",
167 streamUsage, contentType, rendererFlags);
168
169 audioRenderer->rendererInfo_.contentType = contentType;
170 audioRenderer->rendererInfo_.streamUsage = streamUsage;
171 audioRenderer->rendererInfo_.rendererFlags = rendererFlags;
172
173 audioRenderer->privacyType_ = rendererOptions.privacyType;
174 AudioRendererParams params;
175 params.sampleFormat = rendererOptions.streamInfo.format;
176 params.sampleRate = rendererOptions.streamInfo.samplingRate;
177 params.channelCount = rendererOptions.streamInfo.channels;
178 params.encodingType = rendererOptions.streamInfo.encoding;
179
180 if (audioRenderer->SetParams(params) != SUCCESS) {
181 AUDIO_ERR_LOG("SetParams failed in renderer");
182 audioRenderer = nullptr;
183 return nullptr;
184 }
185
186 return audioRenderer;
187 }
188
AudioRendererPrivate(AudioStreamType audioStreamType,const AppInfo & appInfo,bool createStream)189 AudioRendererPrivate::AudioRendererPrivate(AudioStreamType audioStreamType, const AppInfo &appInfo, bool createStream)
190 {
191 appInfo_ = appInfo;
192 if (!(appInfo_.appPid)) {
193 appInfo_.appPid = getpid();
194 }
195
196 if (appInfo_.appUid < 0) {
197 appInfo_.appUid = static_cast<int32_t>(getuid());
198 }
199
200 if (createStream) {
201 AudioStreamParams tempParams = {};
202 audioStream_ = IAudioStream::GetPlaybackStream(IAudioStream::PA_STREAM, tempParams, audioStreamType,
203 appInfo_.appUid);
204 if (audioStream_) {
205 // Initializing with default values
206 rendererInfo_.contentType = CONTENT_TYPE_MUSIC;
207 rendererInfo_.streamUsage = STREAM_USAGE_MEDIA;
208 }
209 AUDIO_INFO_LOG("AudioRendererPrivate create normal stream for old mode.");
210 }
211
212 rendererProxyObj_ = std::make_shared<AudioRendererProxyObj>();
213 if (!rendererProxyObj_) {
214 AUDIO_ERR_LOG("AudioRendererProxyObj Memory Allocation Failed !!");
215 }
216
217 audioInterrupt_.audioFocusType.streamType = audioStreamType;
218 audioInterrupt_.pid = appInfo_.appPid;
219 audioInterrupt_.mode = SHARE_MODE;
220 audioInterrupt_.parallelPlayFlag = false;
221 }
222
InitAudioInterruptCallback()223 int32_t AudioRendererPrivate::InitAudioInterruptCallback()
224 {
225 AUDIO_DEBUG_LOG("AudioRendererPrivate::InitAudioInterruptCallback in");
226 if (audioInterrupt_.mode != SHARE_MODE && audioInterrupt_.mode != INDEPENDENT_MODE) {
227 AUDIO_ERR_LOG("InitAudioInterruptCallback::Invalid interrupt mode!");
228 return ERR_INVALID_PARAM;
229 }
230 if (audioStream_->GetAudioSessionID(audioInterrupt_.sessionID) != 0) {
231 AUDIO_ERR_LOG("InitAudioInterruptCallback::GetAudioSessionID failed");
232 return ERR_INVALID_INDEX;
233 }
234 sessionID_ = audioInterrupt_.sessionID;
235 audioInterrupt_.streamUsage = rendererInfo_.streamUsage;
236 audioInterrupt_.contentType = rendererInfo_.contentType;
237
238 AUDIO_INFO_LOG("InitAudioInterruptCallback::interruptMode %{public}d, streamType %{public}d, sessionID %{public}d",
239 audioInterrupt_.mode, audioInterrupt_.audioFocusType.streamType, audioInterrupt_.sessionID);
240
241 if (audioInterruptCallback_ == nullptr) {
242 audioInterruptCallback_ = std::make_shared<AudioRendererInterruptCallbackImpl>(audioStream_, audioInterrupt_);
243 if (audioInterruptCallback_ == nullptr) {
244 AUDIO_ERR_LOG("InitAudioInterruptCallback::Failed to allocate memory for audioInterruptCallback_");
245 return ERROR;
246 }
247 }
248 return AudioPolicyManager::GetInstance().SetAudioInterruptCallback(sessionID_, audioInterruptCallback_);
249 }
250
GetFrameCount(uint32_t & frameCount) const251 int32_t AudioRendererPrivate::GetFrameCount(uint32_t &frameCount) const
252 {
253 return audioStream_->GetFrameCount(frameCount);
254 }
255
GetLatency(uint64_t & latency) const256 int32_t AudioRendererPrivate::GetLatency(uint64_t &latency) const
257 {
258 return audioStream_->GetLatency(latency);
259 }
260
SetAudioPrivacyType(AudioPrivacyType privacyType)261 void AudioRendererPrivate::SetAudioPrivacyType(AudioPrivacyType privacyType)
262 {
263 privacyType_ = privacyType;
264 if (audioStream_ == nullptr) {
265 return;
266 }
267 audioStream_->SetPrivacyType(privacyType);
268 }
269
SetParams(const AudioRendererParams params)270 int32_t AudioRendererPrivate::SetParams(const AudioRendererParams params)
271 {
272 Trace trace("AudioRenderer::SetParams");
273 AudioStreamParams audioStreamParams = ConvertToAudioStreamParams(params);
274
275 AudioStreamType audioStreamType = IAudioStream::GetStreamType(rendererInfo_.contentType,
276 rendererInfo_.streamUsage);
277 IAudioStream::StreamClass streamClass = IAudioStream::PA_STREAM;
278 if (rendererInfo_.rendererFlags == STREAM_FLAG_FAST) {
279 if (IAudioStream::IsStreamSupported(rendererInfo_.rendererFlags, audioStreamParams)) {
280 AUDIO_INFO_LOG("Create stream with STREAM_FLAG_FAST");
281 streamClass = IAudioStream::FAST_STREAM;
282 isFastRenderer_ = true;
283 DeviceType deviceType = AudioPolicyManager::GetInstance().GetActiveOutputDevice();
284 if (deviceType == DEVICE_TYPE_BLUETOOTH_A2DP) {
285 streamClass = IAudioStream::PA_STREAM;
286 }
287 } else {
288 AUDIO_ERR_LOG("Unsupported parameter, try to create a normal stream");
289 streamClass = IAudioStream::PA_STREAM;
290 isFastRenderer_ = false;
291 }
292 }
293 // check AudioStreamParams for fast stream
294 // As fast stream only support specified audio format, we should call GetPlaybackStream with audioStreamParams.
295 if (audioStream_ == nullptr) {
296 audioStream_ = IAudioStream::GetPlaybackStream(streamClass, audioStreamParams, audioStreamType,
297 appInfo_.appUid);
298 CHECK_AND_RETURN_RET_LOG(audioStream_ != nullptr, ERR_INVALID_PARAM, "SetParams GetPlayBackStream failed.");
299 AUDIO_INFO_LOG("IAudioStream::GetStream success");
300 audioStream_->SetApplicationCachePath(cachePath_);
301 }
302
303 AudioRenderer *renderer = this;
304 rendererProxyObj_->SaveRendererObj(renderer);
305 audioStream_->SetRendererInfo(rendererInfo_);
306
307 audioStream_->SetClientID(appInfo_.appPid, appInfo_.appUid);
308
309 SetAudioPrivacyType(privacyType_);
310
311 audioStream_->SetStreamTrackerState(false);
312
313 int32_t ret = audioStream_->SetAudioStreamInfo(audioStreamParams, rendererProxyObj_);
314 if (ret) {
315 AUDIO_ERR_LOG("AudioRendererPrivate::SetParams SetAudioStreamInfo Failed");
316 return ret;
317 }
318 AUDIO_INFO_LOG("AudioRendererPrivate::SetParams SetAudioStreamInfo Succeeded");
319
320 if (isFastRenderer_) {
321 SetSelfRendererStateCallback();
322 }
323 InitDumpInfo();
324
325 return InitAudioInterruptCallback();
326 }
327
InitDumpInfo()328 void AudioRendererPrivate::InitDumpInfo()
329 {
330 #ifdef DUMP_CLIENT_PCM
331 uint32_t streamId = 0;
332 GetAudioStreamId(streamId);
333 std::stringstream strStream;
334 std::string dumpPatch;
335 strStream << "/data/storage/el2/base/temp/";
336 strStream << "dump_pid" << appInfo_.appPid << "_stream" << streamId << ".pcm";
337 strStream >> dumpPatch;
338 AUDIO_INFO_LOG("Client dump using path: %{public}s", dumpPatch.c_str());
339
340 dcp_ = fopen(dumpPatch.c_str(), "w+");
341 if (dcp_ == nullptr) {
342 AUDIO_ERR_LOG("Error opening pcm test file!");
343 }
344 #endif
345 }
346
GetParams(AudioRendererParams & params) const347 int32_t AudioRendererPrivate::GetParams(AudioRendererParams ¶ms) const
348 {
349 AudioStreamParams audioStreamParams;
350 int32_t result = audioStream_->GetAudioStreamInfo(audioStreamParams);
351 if (!result) {
352 params.sampleFormat = static_cast<AudioSampleFormat>(audioStreamParams.format);
353 params.sampleRate = static_cast<AudioSamplingRate>(audioStreamParams.samplingRate);
354 params.channelCount = static_cast<AudioChannel>(audioStreamParams.channels);
355 params.encodingType = static_cast<AudioEncodingType>(audioStreamParams.encoding);
356 }
357
358 return result;
359 }
360
GetRendererInfo(AudioRendererInfo & rendererInfo) const361 int32_t AudioRendererPrivate::GetRendererInfo(AudioRendererInfo &rendererInfo) const
362 {
363 rendererInfo = rendererInfo_;
364
365 return SUCCESS;
366 }
367
GetStreamInfo(AudioStreamInfo & streamInfo) const368 int32_t AudioRendererPrivate::GetStreamInfo(AudioStreamInfo &streamInfo) const
369 {
370 AudioStreamParams audioStreamParams;
371 int32_t result = audioStream_->GetAudioStreamInfo(audioStreamParams);
372 if (!result) {
373 streamInfo.format = static_cast<AudioSampleFormat>(audioStreamParams.format);
374 streamInfo.samplingRate = static_cast<AudioSamplingRate>(audioStreamParams.samplingRate);
375 streamInfo.channels = static_cast<AudioChannel>(audioStreamParams.channels);
376 streamInfo.encoding = static_cast<AudioEncodingType>(audioStreamParams.encoding);
377 }
378
379 return result;
380 }
381
SetRendererCallback(const std::shared_ptr<AudioRendererCallback> & callback)382 int32_t AudioRendererPrivate::SetRendererCallback(const std::shared_ptr<AudioRendererCallback> &callback)
383 {
384 // If the client is using the deprecated SetParams API. SetRendererCallback must be invoked, after SetParams.
385 // In general, callbacks can only be set after the renderer state is PREPARED.
386 RendererState state = GetStatus();
387 if (state == RENDERER_NEW || state == RENDERER_RELEASED) {
388 AUDIO_DEBUG_LOG("AudioRendererPrivate::SetRendererCallback incorrect state:%{public}d to register cb", state);
389 return ERR_ILLEGAL_STATE;
390 }
391 if (callback == nullptr) {
392 AUDIO_ERR_LOG("AudioRendererPrivate::SetRendererCallback callback param is null");
393 return ERR_INVALID_PARAM;
394 }
395
396 // Save reference for interrupt callback
397 if (audioInterruptCallback_ == nullptr) {
398 AUDIO_ERR_LOG("AudioRendererPrivate::SetRendererCallback audioInterruptCallback_ == nullptr");
399 return ERROR;
400 }
401 std::shared_ptr<AudioRendererInterruptCallbackImpl> cbInterrupt =
402 std::static_pointer_cast<AudioRendererInterruptCallbackImpl>(audioInterruptCallback_);
403 cbInterrupt->SaveCallback(callback);
404
405 // Save and Set reference for stream callback. Order is important here.
406 if (audioStreamCallback_ == nullptr) {
407 audioStreamCallback_ = std::make_shared<AudioStreamCallbackRenderer>();
408 if (audioStreamCallback_ == nullptr) {
409 AUDIO_ERR_LOG("AudioRendererPrivate::Failed to allocate memory for audioStreamCallback_");
410 return ERROR;
411 }
412 }
413 std::shared_ptr<AudioStreamCallbackRenderer> cbStream =
414 std::static_pointer_cast<AudioStreamCallbackRenderer>(audioStreamCallback_);
415 cbStream->SaveCallback(callback);
416 (void)audioStream_->SetStreamCallback(audioStreamCallback_);
417
418 return SUCCESS;
419 }
420
SetRendererPositionCallback(int64_t markPosition,const std::shared_ptr<RendererPositionCallback> & callback)421 int32_t AudioRendererPrivate::SetRendererPositionCallback(int64_t markPosition,
422 const std::shared_ptr<RendererPositionCallback> &callback)
423 {
424 if ((callback == nullptr) || (markPosition <= 0)) {
425 AUDIO_ERR_LOG("AudioRendererPrivate::SetRendererPositionCallback input param is invalid");
426 return ERR_INVALID_PARAM;
427 }
428
429 audioStream_->SetRendererPositionCallback(markPosition, callback);
430
431 return SUCCESS;
432 }
433
UnsetRendererPositionCallback()434 void AudioRendererPrivate::UnsetRendererPositionCallback()
435 {
436 audioStream_->UnsetRendererPositionCallback();
437 }
438
SetRendererPeriodPositionCallback(int64_t frameNumber,const std::shared_ptr<RendererPeriodPositionCallback> & callback)439 int32_t AudioRendererPrivate::SetRendererPeriodPositionCallback(int64_t frameNumber,
440 const std::shared_ptr<RendererPeriodPositionCallback> &callback)
441 {
442 if ((callback == nullptr) || (frameNumber <= 0)) {
443 AUDIO_ERR_LOG("AudioRendererPrivate::SetRendererPeriodPositionCallback input param is invalid");
444 return ERR_INVALID_PARAM;
445 }
446
447 audioStream_->SetRendererPeriodPositionCallback(frameNumber, callback);
448
449 return SUCCESS;
450 }
451
UnsetRendererPeriodPositionCallback()452 void AudioRendererPrivate::UnsetRendererPeriodPositionCallback()
453 {
454 audioStream_->UnsetRendererPeriodPositionCallback();
455 }
456
Start(StateChangeCmdType cmdType) const457 bool AudioRendererPrivate::Start(StateChangeCmdType cmdType) const
458 {
459 AUDIO_INFO_LOG("AudioRenderer::Start");
460 RendererState state = GetStatus();
461 if ((state != RENDERER_PREPARED) && (state != RENDERER_STOPPED) && (state != RENDERER_PAUSED)) {
462 AUDIO_ERR_LOG("AudioRenderer::Start failed. Illegal state:%{public}u", state);
463 return false;
464 }
465
466 if (isSwitching_) {
467 AUDIO_ERR_LOG("AudioRenderer::Start failed. Switching state: %{public}d", isSwitching_);
468 return false;
469 }
470
471 AUDIO_INFO_LOG("AudioRenderer::Start::interruptMode: %{public}d, streamType: %{public}d, sessionID: %{public}d",
472 audioInterrupt_.mode, audioInterrupt_.audioFocusType.streamType, audioInterrupt_.sessionID);
473
474 if (audioInterrupt_.audioFocusType.streamType == STREAM_DEFAULT ||
475 audioInterrupt_.sessionID == INVALID_SESSION_ID) {
476 return false;
477 }
478
479 int32_t ret = AudioPolicyManager::GetInstance().ActivateAudioInterrupt(audioInterrupt_);
480 if (ret != 0) {
481 AUDIO_ERR_LOG("AudioRenderer::ActivateAudioInterrupt Failed");
482 return false;
483 }
484
485 if (audioInterrupt_.streamUsage == STREAM_USAGE_VOICE_MODEM_COMMUNICATION) {
486 // When the cellular call stream is starting, only need to activate audio interrupt.
487 return true;
488 }
489
490 return audioStream_->StartAudioStream(cmdType);
491 }
492
Write(uint8_t * buffer,size_t bufferSize)493 int32_t AudioRendererPrivate::Write(uint8_t *buffer, size_t bufferSize)
494 {
495 Trace trace("Write");
496 #ifdef DUMP_CLIENT_PCM
497 if (dcp_ != nullptr) {
498 fwrite((void *)buffer, 1, bufferSize, dcp_);
499 }
500 #endif
501 return audioStream_->Write(buffer, bufferSize);
502 }
503
GetStatus() const504 RendererState AudioRendererPrivate::GetStatus() const
505 {
506 return static_cast<RendererState>(audioStream_->GetState());
507 }
508
GetAudioTime(Timestamp & timestamp,Timestamp::Timestampbase base) const509 bool AudioRendererPrivate::GetAudioTime(Timestamp ×tamp, Timestamp::Timestampbase base) const
510 {
511 return audioStream_->GetAudioTime(timestamp, base);
512 }
513
Drain() const514 bool AudioRendererPrivate::Drain() const
515 {
516 return audioStream_->DrainAudioStream();
517 }
518
Flush() const519 bool AudioRendererPrivate::Flush() const
520 {
521 return audioStream_->FlushAudioStream();
522 }
523
Pause(StateChangeCmdType cmdType) const524 bool AudioRendererPrivate::Pause(StateChangeCmdType cmdType) const
525 {
526 AUDIO_INFO_LOG("AudioRenderer::Pause");
527 if (isSwitching_) {
528 AUDIO_ERR_LOG("AudioRenderer::Pause failed. Switching state: %{public}d", isSwitching_);
529 return false;
530 }
531
532 if (audioInterrupt_.streamUsage == STREAM_USAGE_VOICE_MODEM_COMMUNICATION) {
533 // When the cellular call stream is pausing, only need to deactivate audio interrupt.
534 if (AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt_) != 0) {
535 AUDIO_ERR_LOG("AudioRenderer::Pause: DeactivateAudioInterrupt Failed");
536 }
537 return true;
538 }
539
540 RendererState state = GetStatus();
541 if (state != RENDERER_RUNNING) {
542 // If the stream is not running, there is no need to pause and deactive audio interrupt
543 AUDIO_ERR_LOG("AudioRenderer::Pause: State of stream is not running. Illegal state:%{public}u", state);
544 return false;
545 }
546 bool result = audioStream_->PauseAudioStream(cmdType);
547
548 // When user is intentionally pausing, deactivate to remove from audioFocusInfoList_
549 int32_t ret = AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt_);
550 if (ret != 0) {
551 AUDIO_ERR_LOG("AudioRenderer::Pause: DeactivateAudioInterrupt Failed");
552 }
553
554 return result;
555 }
556
Stop() const557 bool AudioRendererPrivate::Stop() const
558 {
559 AUDIO_INFO_LOG("AudioRenderer::Stop");
560 if (isSwitching_) {
561 AUDIO_ERR_LOG("AudioRenderer::Stop failed. Switching state: %{public}d", isSwitching_);
562 return false;
563 }
564 if (audioInterrupt_.streamUsage == STREAM_USAGE_VOICE_MODEM_COMMUNICATION) {
565 // When the cellular call stream is stopping, only need to deactivate audio interrupt.
566 if (AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt_) != 0) {
567 AUDIO_ERR_LOG("AudioRenderer::Stop: DeactivateAudioInterrupt Failed");
568 }
569 return true;
570 }
571
572 bool result = audioStream_->StopAudioStream();
573 int32_t ret = AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt_);
574 if (ret != 0) {
575 AUDIO_ERR_LOG("AudioRenderer::Stop: DeactivateAudioInterrupt Failed");
576 }
577
578 return result;
579 }
580
Release() const581 bool AudioRendererPrivate::Release() const
582 {
583 AUDIO_INFO_LOG("AudioRenderer::Release");
584 // If Stop call was skipped, Release to take care of Deactivation
585 (void)AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt_);
586
587 // Unregister the callaback in policy server
588 (void)AudioPolicyManager::GetInstance().UnsetAudioInterruptCallback(sessionID_);
589
590 return audioStream_->ReleaseAudioStream();
591 }
592
GetBufferSize(size_t & bufferSize) const593 int32_t AudioRendererPrivate::GetBufferSize(size_t &bufferSize) const
594 {
595 return audioStream_->GetBufferSize(bufferSize);
596 }
597
GetAudioStreamId(uint32_t & sessionID) const598 int32_t AudioRendererPrivate::GetAudioStreamId(uint32_t &sessionID) const
599 {
600 return audioStream_->GetAudioSessionID(sessionID);
601 }
602
SetAudioRendererDesc(AudioRendererDesc audioRendererDesc)603 int32_t AudioRendererPrivate::SetAudioRendererDesc(AudioRendererDesc audioRendererDesc)
604 {
605 ContentType contentType = audioRendererDesc.contentType;
606 StreamUsage streamUsage = audioRendererDesc.streamUsage;
607 AudioStreamType audioStreamType = IAudioStream::GetStreamType(contentType, streamUsage);
608 audioInterrupt_.audioFocusType.streamType = audioStreamType;
609 return audioStream_->SetAudioStreamType(audioStreamType);
610 }
611
SetStreamType(AudioStreamType audioStreamType)612 int32_t AudioRendererPrivate::SetStreamType(AudioStreamType audioStreamType)
613 {
614 audioInterrupt_.audioFocusType.streamType = audioStreamType;
615 return audioStream_->SetAudioStreamType(audioStreamType);
616 }
617
SetVolume(float volume) const618 int32_t AudioRendererPrivate::SetVolume(float volume) const
619 {
620 return audioStream_->SetVolume(volume);
621 }
622
GetVolume() const623 float AudioRendererPrivate::GetVolume() const
624 {
625 return audioStream_->GetVolume();
626 }
627
SetRenderRate(AudioRendererRate renderRate) const628 int32_t AudioRendererPrivate::SetRenderRate(AudioRendererRate renderRate) const
629 {
630 return audioStream_->SetRenderRate(renderRate);
631 }
632
GetRenderRate() const633 AudioRendererRate AudioRendererPrivate::GetRenderRate() const
634 {
635 return audioStream_->GetRenderRate();
636 }
637
SetRendererSamplingRate(uint32_t sampleRate) const638 int32_t AudioRendererPrivate::SetRendererSamplingRate(uint32_t sampleRate) const
639 {
640 return audioStream_->SetRendererSamplingRate(sampleRate);
641 }
642
GetRendererSamplingRate() const643 uint32_t AudioRendererPrivate::GetRendererSamplingRate() const
644 {
645 return audioStream_->GetRendererSamplingRate();
646 }
647
SetBufferDuration(uint64_t bufferDuration) const648 int32_t AudioRendererPrivate::SetBufferDuration(uint64_t bufferDuration) const
649 {
650 if (bufferDuration < MINIMUM_BUFFER_SIZE_MSEC || bufferDuration > MAXIMUM_BUFFER_SIZE_MSEC) {
651 AUDIO_ERR_LOG("Error: Please set the buffer duration between 5ms ~ 20ms");
652 return ERR_INVALID_PARAM;
653 }
654
655 return audioStream_->SetBufferSizeInMsec(bufferDuration);
656 }
657
AudioRendererInterruptCallbackImpl(const std::shared_ptr<IAudioStream> & audioStream,const AudioInterrupt & audioInterrupt)658 AudioRendererInterruptCallbackImpl::AudioRendererInterruptCallbackImpl(const std::shared_ptr<IAudioStream> &audioStream,
659 const AudioInterrupt &audioInterrupt)
660 : audioStream_(audioStream), audioInterrupt_(audioInterrupt)
661 {
662 AUDIO_INFO_LOG("AudioRendererInterruptCallbackImpl constructor");
663 }
664
~AudioRendererInterruptCallbackImpl()665 AudioRendererInterruptCallbackImpl::~AudioRendererInterruptCallbackImpl()
666 {
667 AUDIO_DEBUG_LOG("AudioRendererInterruptCallbackImpl: instance destroy");
668 }
669
SaveCallback(const std::weak_ptr<AudioRendererCallback> & callback)670 void AudioRendererInterruptCallbackImpl::SaveCallback(const std::weak_ptr<AudioRendererCallback> &callback)
671 {
672 callback_ = callback;
673 }
674
NotifyEvent(const InterruptEvent & interruptEvent)675 void AudioRendererInterruptCallbackImpl::NotifyEvent(const InterruptEvent &interruptEvent)
676 {
677 if (cb_ != nullptr) {
678 cb_->OnInterrupt(interruptEvent);
679 AUDIO_INFO_LOG("AudioRendererInterruptCallbackImpl::NotifyEvent: Send interruptEvent to app successfully");
680 } else {
681 AUDIO_ERR_LOG("AudioRendererInterruptCallbackImpl::NotifyEvent: cb_==nullptr, failed to send interruptEvent");
682 }
683 }
684
HandleForceDucking(const InterruptEventInternal & interruptEvent)685 bool AudioRendererInterruptCallbackImpl::HandleForceDucking(const InterruptEventInternal &interruptEvent)
686 {
687 int32_t systemVolumeLevel =
688 AudioPolicyManager::GetInstance().GetSystemVolumeLevel(audioInterrupt_.audioFocusType.streamType);
689 float systemVolumeDb = VolumeToDb(systemVolumeLevel);
690 float duckVolumeDb = interruptEvent.duckVolume;
691 int32_t ret = 0;
692
693 if (systemVolumeDb <= duckVolumeDb || FLOAT_COMPARE_EQ(systemVolumeDb, 0.0f)) {
694 AUDIO_INFO_LOG("HandleForceDucking: StreamVolume %{public}f <= duckVolumeDb %{public}f. "
695 "No need to duck further", systemVolumeDb, duckVolumeDb);
696 return false;
697 }
698
699 instanceVolBeforeDucking_ = audioStream_->GetVolume();
700 float duckInstanceVolume = duckVolumeDb / systemVolumeDb;
701 if (FLOAT_COMPARE_EQ(instanceVolBeforeDucking_, 0.0f) || instanceVolBeforeDucking_ < duckInstanceVolume) {
702 AUDIO_INFO_LOG("HandleForceDucking: No need to duck further");
703 return false;
704 }
705
706 ret = audioStream_->SetVolume(duckInstanceVolume);
707 if (ret) {
708 AUDIO_ERR_LOG("HandleForceDucking: Failed to set duckVolumeDb(instance) %{pubic}f", duckInstanceVolume);
709 return false;
710 }
711
712 AUDIO_INFO_LOG("HandleForceDucking: Set duckVolumeDb(instance) %{pubic}f successfully", duckInstanceVolume);
713 return true;
714 }
715
NotifyForcePausedToResume(const InterruptEventInternal & interruptEvent)716 void AudioRendererInterruptCallbackImpl::NotifyForcePausedToResume(const InterruptEventInternal &interruptEvent)
717 {
718 // Change InterruptForceType to Share, Since app will take care of resuming
719 InterruptEvent interruptEventResume {interruptEvent.eventType, INTERRUPT_SHARE,
720 interruptEvent.hintType};
721 NotifyEvent(interruptEventResume);
722 }
723
HandleAndNotifyForcedEvent(const InterruptEventInternal & interruptEvent)724 void AudioRendererInterruptCallbackImpl::HandleAndNotifyForcedEvent(const InterruptEventInternal &interruptEvent)
725 {
726 // ForceType: INTERRUPT_FORCE. Handle the event forcely and notify the app.
727 AUDIO_DEBUG_LOG("HandleAndNotifyForcedEvent in");
728 InterruptHint hintType = interruptEvent.hintType;
729 switch (hintType) {
730 case INTERRUPT_HINT_PAUSE:
731 if (audioStream_->GetState() == PREPARED) {
732 AUDIO_INFO_LOG("HandleAndNotifyForcedEvent: To pause incoming, no need to pause");
733 } else if (audioStream_->GetState() == RUNNING) {
734 (void)audioStream_->PauseAudioStream(); // Just Pause, do not deactivate here
735 } else {
736 AUDIO_WARNING_LOG("HandleAndNotifyForcedEvent: State of stream is not running.No need to pause");
737 return;
738 }
739 isForcePaused_ = true;
740 break;
741 case INTERRUPT_HINT_RESUME:
742 if ((audioStream_->GetState() != PAUSED && audioStream_->GetState() != PREPARED) || !isForcePaused_) {
743 AUDIO_WARNING_LOG("HandleAndNotifyForcedEvent: State of stream is not paused or pause is not forced");
744 return;
745 }
746 isForcePaused_ = false;
747 NotifyForcePausedToResume(interruptEvent);
748 return; // return, sending callback is taken care in NotifyForcePausedToResume
749 case INTERRUPT_HINT_STOP:
750 (void)audioStream_->StopAudioStream();
751 break;
752 case INTERRUPT_HINT_DUCK:
753 if (!HandleForceDucking(interruptEvent)) {
754 AUDIO_WARNING_LOG("HandleAndNotifyForcedEvent: Failed to duck forcely, don't notify app");
755 return;
756 }
757 isForceDucked_ = true;
758 break;
759 case INTERRUPT_HINT_UNDUCK:
760 if (!isForceDucked_) {
761 AUDIO_WARNING_LOG("HandleAndNotifyForcedEvent: It is not forced ducked, don't unduck or notify app");
762 return;
763 }
764 (void)audioStream_->SetVolume(instanceVolBeforeDucking_);
765 AUDIO_INFO_LOG("HandleAndNotifyForcedEvent: Unduck Volume(instance) successfully: %{public}f",
766 instanceVolBeforeDucking_);
767 isForceDucked_ = false;
768 break;
769 default: // If the hintType is NONE, don't need to send callbacks
770 return;
771 }
772 // Notify valid forced event callbacks to app
773 InterruptEvent interruptEventForced {interruptEvent.eventType, interruptEvent.forceType, interruptEvent.hintType};
774 NotifyEvent(interruptEventForced);
775 }
776
OnInterrupt(const InterruptEventInternal & interruptEvent)777 void AudioRendererInterruptCallbackImpl::OnInterrupt(const InterruptEventInternal &interruptEvent)
778 {
779 cb_ = callback_.lock();
780 InterruptForceType forceType = interruptEvent.forceType;
781 AUDIO_INFO_LOG("AudioRendererInterruptCallbackImpl::OnInterrupt: forceType %{public}d, hintType: %{public}d",
782 forceType, interruptEvent.hintType);
783
784 if (forceType != INTERRUPT_FORCE) { // INTERRUPT_SHARE
785 AUDIO_DEBUG_LOG("AudioRendererPrivate ForceType: INTERRUPT_SHARE. Let app handle the event");
786 InterruptEvent interruptEventShared {interruptEvent.eventType, interruptEvent.forceType,
787 interruptEvent.hintType};
788 NotifyEvent(interruptEventShared);
789 return;
790 }
791
792 if (audioStream_ == nullptr) {
793 AUDIO_ERR_LOG("AudioRendererInterruptCallbackImpl::Stream is not alive. No need to take forced action");
794 return;
795 }
796
797 HandleAndNotifyForcedEvent(interruptEvent);
798 }
799
SaveCallback(const std::weak_ptr<AudioRendererCallback> & callback)800 void AudioStreamCallbackRenderer::SaveCallback(const std::weak_ptr<AudioRendererCallback> &callback)
801 {
802 callback_ = callback;
803 }
804
OnStateChange(const State state,const StateChangeCmdType cmdType)805 void AudioStreamCallbackRenderer::OnStateChange(const State state, const StateChangeCmdType cmdType)
806 {
807 std::shared_ptr<AudioRendererCallback> cb = callback_.lock();
808 if (cb == nullptr) {
809 AUDIO_ERR_LOG("AudioStreamCallbackRenderer::OnStateChange cb == nullptr.");
810 return;
811 }
812
813 cb->OnStateChange(static_cast<RendererState>(state), cmdType);
814 }
815
GetSupportedFormats()816 std::vector<AudioSampleFormat> AudioRenderer::GetSupportedFormats()
817 {
818 return AUDIO_SUPPORTED_FORMATS;
819 }
820
GetSupportedSamplingRates()821 std::vector<AudioSamplingRate> AudioRenderer::GetSupportedSamplingRates()
822 {
823 return AUDIO_SUPPORTED_SAMPLING_RATES;
824 }
825
GetSupportedChannels()826 std::vector<AudioChannel> AudioRenderer::GetSupportedChannels()
827 {
828 return RENDERER_SUPPORTED_CHANNELS;
829 }
830
GetSupportedEncodingTypes()831 std::vector<AudioEncodingType> AudioRenderer::GetSupportedEncodingTypes()
832 {
833 return AUDIO_SUPPORTED_ENCODING_TYPES;
834 }
835
SetRenderMode(AudioRenderMode renderMode) const836 int32_t AudioRendererPrivate::SetRenderMode(AudioRenderMode renderMode) const
837 {
838 return audioStream_->SetRenderMode(renderMode);
839 }
840
GetRenderMode() const841 AudioRenderMode AudioRendererPrivate::GetRenderMode() const
842 {
843 return audioStream_->GetRenderMode();
844 }
845
GetBufferDesc(BufferDesc & bufDesc) const846 int32_t AudioRendererPrivate::GetBufferDesc(BufferDesc &bufDesc) const
847 {
848 std::lock_guard<std::mutex> lock(switchStreamMutex_);
849 return audioStream_->GetBufferDesc(bufDesc);
850 }
851
Enqueue(const BufferDesc & bufDesc) const852 int32_t AudioRendererPrivate::Enqueue(const BufferDesc &bufDesc) const
853 {
854 #ifdef DUMP_CLIENT_PCM
855 if (dcp_ != nullptr) {
856 fwrite((void *)(bufDesc.buffer), 1, bufDesc.bufLength, dcp_);
857 }
858 #endif
859 std::lock_guard<std::mutex> lock(switchStreamMutex_);
860 return audioStream_->Enqueue(bufDesc);
861 }
862
Clear() const863 int32_t AudioRendererPrivate::Clear() const
864 {
865 return audioStream_->Clear();
866 }
867
GetBufQueueState(BufferQueueState & bufState) const868 int32_t AudioRendererPrivate::GetBufQueueState(BufferQueueState &bufState) const
869 {
870 return audioStream_->GetBufQueueState(bufState);
871 }
872
SetApplicationCachePath(const std::string cachePath)873 void AudioRendererPrivate::SetApplicationCachePath(const std::string cachePath)
874 {
875 cachePath_ = cachePath;
876 if (audioStream_ != nullptr) {
877 audioStream_->SetApplicationCachePath(cachePath);
878 } else {
879 AUDIO_WARNING_LOG("AudioRenderer SetApplicationCachePath while stream is null");
880 }
881 }
882
SetRendererWriteCallback(const std::shared_ptr<AudioRendererWriteCallback> & callback)883 int32_t AudioRendererPrivate::SetRendererWriteCallback(const std::shared_ptr<AudioRendererWriteCallback> &callback)
884 {
885 return audioStream_->SetRendererWriteCallback(callback);
886 }
887
SetInterruptMode(InterruptMode mode)888 void AudioRendererPrivate::SetInterruptMode(InterruptMode mode)
889 {
890 AUDIO_INFO_LOG("AudioRendererPrivate::SetInterruptMode: InterruptMode %{pubilc}d", mode);
891 if (audioInterrupt_.mode == mode) {
892 return;
893 } else if (mode != SHARE_MODE && mode != INDEPENDENT_MODE) {
894 AUDIO_ERR_LOG("AudioRendererPrivate::SetInterruptMode: Invalid interrupt mode!");
895 return;
896 }
897 audioInterrupt_.mode = mode;
898 }
899
SetParallelPlayFlag(bool parallelPlayFlag)900 int32_t AudioRendererPrivate::SetParallelPlayFlag(bool parallelPlayFlag)
901 {
902 AUDIO_INFO_LOG("AudioRendererPrivate::SetParallelPlayFlag: parallelPlayFlag %{pubilc}d", parallelPlayFlag);
903 audioInterrupt_.parallelPlayFlag = parallelPlayFlag;
904 return SUCCESS;
905 }
906
SetLowPowerVolume(float volume) const907 int32_t AudioRendererPrivate::SetLowPowerVolume(float volume) const
908 {
909 return audioStream_->SetLowPowerVolume(volume);
910 }
911
GetLowPowerVolume() const912 float AudioRendererPrivate::GetLowPowerVolume() const
913 {
914 return audioStream_->GetLowPowerVolume();
915 }
916
GetSingleStreamVolume() const917 float AudioRendererPrivate::GetSingleStreamVolume() const
918 {
919 return audioStream_->GetSingleStreamVolume();
920 }
921
GetMinStreamVolume() const922 float AudioRendererPrivate::GetMinStreamVolume() const
923 {
924 return AudioPolicyManager::GetInstance().GetMinStreamVolume();
925 }
926
GetMaxStreamVolume() const927 float AudioRendererPrivate::GetMaxStreamVolume() const
928 {
929 return AudioPolicyManager::GetInstance().GetMaxStreamVolume();
930 }
931
GetCurrentOutputDevices(DeviceInfo & deviceInfo) const932 int32_t AudioRendererPrivate::GetCurrentOutputDevices(DeviceInfo &deviceInfo) const
933 {
934 std::vector<std::unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
935 uint32_t sessionId = static_cast<uint32_t>(-1);
936 int32_t ret = GetAudioStreamId(sessionId);
937 if (ret) {
938 AUDIO_ERR_LOG("AudioRendererPrivate::GetCurrentOutputDevices Get sessionId failed");
939 return ret;
940 }
941
942 ret = AudioPolicyManager::GetInstance().GetCurrentRendererChangeInfos(audioRendererChangeInfos);
943 if (ret) {
944 AUDIO_ERR_LOG("AudioRendererPrivate::GetCurrentOutputDevices Get Current Renderer devices failed");
945 return ret;
946 }
947
948 for (auto it = audioRendererChangeInfos.begin(); it != audioRendererChangeInfos.end(); it++) {
949 if ((*it)->sessionId == static_cast<int32_t>(sessionId)) {
950 deviceInfo = (*it)->outputDeviceInfo;
951 }
952 }
953 return SUCCESS;
954 }
955
GetUnderflowCount() const956 uint32_t AudioRendererPrivate::GetUnderflowCount() const
957 {
958 return audioStream_->GetUnderflowCount();
959 }
960
961
SetAudioRendererErrorCallback(std::shared_ptr<AudioRendererErrorCallback> errorCallback)962 void AudioRendererPrivate::SetAudioRendererErrorCallback(std::shared_ptr<AudioRendererErrorCallback> errorCallback)
963 {
964 audioRendererErrorCallback_ = errorCallback;
965 }
966
RegisterAudioRendererEventListener(const int32_t clientPid,const std::shared_ptr<AudioRendererDeviceChangeCallback> & callback)967 int32_t AudioRendererPrivate::RegisterAudioRendererEventListener(const int32_t clientPid,
968 const std::shared_ptr<AudioRendererDeviceChangeCallback> &callback)
969 {
970 AUDIO_INFO_LOG("RegisterAudioRendererEventListener client id: %{public}d", clientPid);
971 if (callback == nullptr) {
972 AUDIO_ERR_LOG("callback is null");
973 return ERR_INVALID_PARAM;
974 }
975
976 if (GetCurrentOutputDevices(currentDeviceInfo) != SUCCESS) {
977 AUDIO_ERR_LOG("get current device info failed");
978 return ERROR;
979 }
980
981 if (!audioDeviceChangeCallback_) {
982 audioDeviceChangeCallback_ = std::make_shared<AudioRendererStateChangeCallbackImpl>();
983 if (!audioDeviceChangeCallback_) {
984 AUDIO_ERR_LOG("AudioRendererPrivate: Memory Allocation Failed !!");
985 return ERROR;
986 }
987 }
988
989 int32_t ret =
990 AudioPolicyManager::GetInstance().RegisterAudioRendererEventListener(clientPid, audioDeviceChangeCallback_);
991 if (ret != 0) {
992 AUDIO_ERR_LOG("AudioRendererPrivate::RegisterAudioRendererEventListener failed");
993 return ERROR;
994 }
995
996 audioDeviceChangeCallback_->setAudioRendererObj(this);
997 audioDeviceChangeCallback_->SaveCallback(callback);
998 AUDIO_DEBUG_LOG("AudioRendererPrivate::RegisterAudioRendererEventListener successful!");
999 return SUCCESS;
1000 }
1001
RegisterAudioPolicyServerDiedCb(const int32_t clientPid,const std::shared_ptr<AudioRendererPolicyServiceDiedCallback> & callback)1002 int32_t AudioRendererPrivate::RegisterAudioPolicyServerDiedCb(const int32_t clientPid,
1003 const std::shared_ptr<AudioRendererPolicyServiceDiedCallback> &callback)
1004 {
1005 AUDIO_INFO_LOG("RegisterAudioPolicyServerDiedCb client id: %{public}d", clientPid);
1006 if (callback == nullptr) {
1007 AUDIO_ERR_LOG("callback is null");
1008 return ERR_INVALID_PARAM;
1009 }
1010
1011 return AudioPolicyManager::GetInstance().RegisterAudioPolicyServerDiedCb(clientPid, callback);
1012 }
1013
UnregisterAudioPolicyServerDiedCb(const int32_t clientPid)1014 int32_t AudioRendererPrivate::UnregisterAudioPolicyServerDiedCb(const int32_t clientPid)
1015 {
1016 AUDIO_INFO_LOG("AudioRendererPrivate:: UnregisterAudioPolicyServerDiedCb client id: %{public}d", clientPid);
1017 return AudioPolicyManager::GetInstance().UnregisterAudioPolicyServerDiedCb(clientPid);
1018 }
1019
DestroyAudioRendererStateCallback()1020 void AudioRendererPrivate::DestroyAudioRendererStateCallback()
1021 {
1022 if (audioDeviceChangeCallback_ != nullptr) {
1023 audioDeviceChangeCallback_.reset();
1024 audioDeviceChangeCallback_ = nullptr;
1025 }
1026 }
1027
UnregisterAudioRendererEventListener(const int32_t clientPid)1028 int32_t AudioRendererPrivate::UnregisterAudioRendererEventListener(const int32_t clientPid)
1029 {
1030 AUDIO_INFO_LOG("AudioRendererPrivate::UnregisterAudioCapturerEventListener client id: %{public}d", clientPid);
1031 int32_t ret = AudioPolicyManager::GetInstance().UnregisterAudioRendererEventListener(clientPid);
1032 if (ret != 0) {
1033 AUDIO_ERR_LOG("AudioRendererPrivate::UnregisterAudioRendererEventListener failed");
1034 return ERROR;
1035 }
1036
1037 DestroyAudioRendererStateCallback();
1038 return SUCCESS;
1039 }
1040
AudioRendererStateChangeCallbackImpl()1041 AudioRendererStateChangeCallbackImpl::AudioRendererStateChangeCallbackImpl()
1042 {
1043 AUDIO_INFO_LOG("AudioRendererStateChangeCallbackImpl instance create");
1044 }
1045
~AudioRendererStateChangeCallbackImpl()1046 AudioRendererStateChangeCallbackImpl::~AudioRendererStateChangeCallbackImpl()
1047 {
1048 AUDIO_INFO_LOG("AudioRendererStateChangeCallbackImpl instance destory");
1049 }
1050
SaveCallback(const std::weak_ptr<AudioRendererDeviceChangeCallback> & callback)1051 void AudioRendererStateChangeCallbackImpl::SaveCallback(
1052 const std::weak_ptr<AudioRendererDeviceChangeCallback> &callback)
1053 {
1054 callback_ = callback;
1055 }
1056
setAudioRendererObj(AudioRendererPrivate * rendererObj)1057 void AudioRendererStateChangeCallbackImpl::setAudioRendererObj(AudioRendererPrivate *rendererObj)
1058 {
1059 renderer = rendererObj;
1060 }
1061
SetSwitchInfo(IAudioStream::SwitchInfo info,std::shared_ptr<IAudioStream> audioStream)1062 void AudioRendererPrivate::SetSwitchInfo(IAudioStream::SwitchInfo info, std::shared_ptr<IAudioStream> audioStream)
1063 {
1064 if (!audioStream) {
1065 AUDIO_ERR_LOG("stream is nullptr");
1066 return;
1067 }
1068 audioStream->SetStreamTrackerState(info.streamTrackerRegistered);
1069 audioStream->SetApplicationCachePath(info.cachePath);
1070 audioStream->SetClientID(info.clientPid, info.clientUid);
1071 audioStream->SetPrivacyType(info.privacyType);
1072 audioStream->SetRendererInfo(info.rendererInfo);
1073 audioStream->SetCapturerInfo(info.capturerInfo);
1074 audioStream->SetAudioStreamInfo(info.params, rendererProxyObj_);
1075 audioStream->SetRenderMode(info.renderMode);
1076 audioStream->SetAudioEffectMode(info.effectMode);
1077 audioStream->SetVolume(info.volume);
1078
1079 // set callback
1080 if ((info.renderPositionCb != nullptr) && (info.frameMarkPosition > 0)) {
1081 audioStream->SetRendererPositionCallback(info.frameMarkPosition, info.renderPositionCb);
1082 }
1083
1084 if ((info.capturePositionCb != nullptr) && (info.frameMarkPosition > 0)) {
1085 audioStream->SetCapturerPositionCallback(info.frameMarkPosition, info.capturePositionCb);
1086 }
1087
1088 if ((info.renderPeriodPositionCb != nullptr) && (info.framePeriodNumber > 0)) {
1089 audioStream->SetRendererPeriodPositionCallback(info.framePeriodNumber, info.renderPeriodPositionCb);
1090 }
1091
1092 if ((info.capturePeriodPositionCb != nullptr) && (info.framePeriodNumber > 0)) {
1093 audioStream->SetCapturerPeriodPositionCallback(info.framePeriodNumber, info.capturePeriodPositionCb);
1094 }
1095
1096 audioStream->SetStreamCallback(info.audioStreamCallback);
1097 audioStream->SetRendererWriteCallback(info.rendererWriteCallback);
1098 }
1099
SwitchToTargetStream(IAudioStream::StreamClass targetClass)1100 bool AudioRendererPrivate::SwitchToTargetStream(IAudioStream::StreamClass targetClass)
1101 {
1102 std::lock_guard<std::mutex> lock(switchStreamMutex_);
1103 bool switchResult = false;
1104 if (audioStream_) {
1105 Trace trace("SwitchToTargetStream");
1106 isSwitching_ = true;
1107 RendererState previousState = GetStatus();
1108 if (previousState == RENDERER_RUNNING) {
1109 // stop old stream
1110 switchResult = audioStream_->StopAudioStream();
1111 CHECK_AND_RETURN_RET_LOG(switchResult, false, "StopAudioStream failed.");
1112 }
1113 // switch new stream
1114 IAudioStream::SwitchInfo info;
1115 audioStream_->GetSwitchInfo(info);
1116 std::shared_ptr<IAudioStream> newAudioStream = IAudioStream::GetPlaybackStream(targetClass, info.params,
1117 info.eStreamType, appInfo_.appPid);
1118 CHECK_AND_RETURN_RET_LOG(newAudioStream != nullptr, false, "SetParams GetPlayBackStream failed.");
1119 AUDIO_INFO_LOG("Get new stream success!");
1120
1121 // set new stream info
1122 SetSwitchInfo(info, newAudioStream);
1123
1124 // release old stream and restart audio stream
1125 switchResult = audioStream_->ReleaseAudioStream();
1126 CHECK_AND_RETURN_RET_LOG(switchResult, false, "release old stream failed.");
1127
1128 if (previousState == RENDERER_RUNNING) {
1129 // restart audio stream
1130 switchResult = newAudioStream->StartAudioStream();
1131 CHECK_AND_RETURN_RET_LOG(switchResult, false, "start new stream failed.");
1132 }
1133 audioStream_ = newAudioStream;
1134 isSwitching_ = false;
1135 switchResult= true;
1136 }
1137 return switchResult;
1138 }
1139
SwitchStream(bool isLowLatencyDevice)1140 void AudioRendererPrivate::SwitchStream(bool isLowLatencyDevice)
1141 {
1142 // switch stream for fast renderer only
1143 if (audioStream_ != nullptr && isFastRenderer_ && !isSwitching_) {
1144 bool needSwitch = false;
1145 IAudioStream::StreamClass currentClass = audioStream_->GetStreamClass();
1146 IAudioStream::StreamClass targetClass = IAudioStream::PA_STREAM;
1147 if (currentClass == IAudioStream::FAST_STREAM && !isLowLatencyDevice) {
1148 needSwitch = true;
1149 rendererInfo_.rendererFlags = 0; // Normal renderer type
1150 targetClass = IAudioStream::PA_STREAM;
1151 }
1152 if (currentClass == IAudioStream::PA_STREAM && isLowLatencyDevice) {
1153 needSwitch = true;
1154 rendererInfo_.rendererFlags = STREAM_FLAG_FAST;
1155 targetClass = IAudioStream::FAST_STREAM;
1156 }
1157 if (needSwitch) {
1158 if (!SwitchToTargetStream(targetClass) && !audioRendererErrorCallback_) {
1159 audioRendererErrorCallback_->OnError(ERROR_SYSTEM);
1160 }
1161 } else {
1162 AUDIO_ERR_LOG("need not SwitchStream!");
1163 }
1164 } else {
1165 AUDIO_INFO_LOG("Do not SwitchStream , is low latency renderer: %{public}d!", isFastRenderer_);
1166 }
1167 }
1168
IsDeviceChanged(DeviceInfo & newDeviceInfo)1169 bool AudioRendererPrivate::IsDeviceChanged(DeviceInfo &newDeviceInfo)
1170 {
1171 bool deviceUpdated = false;
1172 DeviceInfo deviceInfo = {};
1173
1174 if (GetCurrentOutputDevices(deviceInfo) != SUCCESS) {
1175 AUDIO_ERR_LOG("AudioRendererPrivate::GetCurrentOutputDevices failed");
1176 return deviceUpdated;
1177 }
1178
1179 AUDIO_INFO_LOG("newDeviceInfo type: %{public}d, currentDeviceInfo type: %{public}d ",
1180 deviceInfo.deviceType, currentDeviceInfo.deviceType);
1181 if (currentDeviceInfo.deviceType != deviceInfo.deviceType) {
1182 currentDeviceInfo = deviceInfo;
1183 newDeviceInfo = currentDeviceInfo;
1184 deviceUpdated = true;
1185 }
1186 return deviceUpdated;
1187 }
1188
OnRendererStateChange(const std::vector<std::unique_ptr<AudioRendererChangeInfo>> & audioRendererChangeInfos)1189 void AudioRendererStateChangeCallbackImpl::OnRendererStateChange(
1190 const std::vector<std::unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos)
1191 {
1192 std::shared_ptr<AudioRendererDeviceChangeCallback> cb = callback_.lock();
1193 AUDIO_INFO_LOG("AudioRendererStateChangeCallbackImpl OnRendererStateChange");
1194 DeviceInfo deviceInfo = {};
1195 if (renderer->IsDeviceChanged(deviceInfo)) {
1196 if (deviceInfo.deviceType != DEVICE_TYPE_NONE && deviceInfo.deviceType != DEVICE_TYPE_INVALID) {
1197 // switch audio channel
1198 renderer->SwitchStream(deviceInfo.isLowLatencyDevice);
1199 }
1200 if (cb == nullptr) {
1201 AUDIO_ERR_LOG("AudioRendererStateChangeCallbackImpl::OnStateChange cb == nullptr.");
1202 return;
1203 }
1204 cb->OnStateChange(deviceInfo);
1205 }
1206 }
1207
GetAudioEffectMode() const1208 AudioEffectMode AudioRendererPrivate::GetAudioEffectMode() const
1209 {
1210 return audioStream_->GetAudioEffectMode();
1211 }
1212
GetFramesWritten() const1213 int64_t AudioRendererPrivate::GetFramesWritten() const
1214 {
1215 return audioStream_->GetFramesWritten();
1216 }
1217
SetAudioEffectMode(AudioEffectMode effectMode) const1218 int32_t AudioRendererPrivate::SetAudioEffectMode(AudioEffectMode effectMode) const
1219 {
1220 return audioStream_->SetAudioEffectMode(effectMode);
1221 }
1222
SetSelfRendererStateCallback()1223 void AudioRendererPrivate::SetSelfRendererStateCallback()
1224 {
1225 if (GetCurrentOutputDevices(currentDeviceInfo) != SUCCESS) {
1226 AUDIO_ERR_LOG("get current device info failed");
1227 return;
1228 }
1229
1230 int32_t clientPid = getpid();
1231 if (!audioDeviceChangeCallback_) {
1232 audioDeviceChangeCallback_ = std::make_shared<AudioRendererStateChangeCallbackImpl>();
1233 if (!audioDeviceChangeCallback_) {
1234 AUDIO_ERR_LOG("AudioRendererPrivate: Memory Allocation Failed !!");
1235 return;
1236 }
1237 }
1238
1239 int32_t ret = AudioPolicyManager::GetInstance().RegisterAudioRendererEventListener(clientPid,
1240 audioDeviceChangeCallback_);
1241 if (ret != 0) {
1242 AUDIO_ERR_LOG("AudioRendererPrivate::RegisterAudioRendererEventListener failed");
1243 return;
1244 }
1245
1246 audioDeviceChangeCallback_->setAudioRendererObj(this);
1247 AUDIO_INFO_LOG("AudioRendererPrivate::RegisterAudioRendererEventListener successful!");
1248 }
1249 } // namespace AudioStandard
1250 } // namespace OHOS
1251