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 #ifdef SONIC_ENABLE
33 static const int32_t MAX_BUFFER_SIZE = 100000;
34 #endif
35 static const std::vector<StreamUsage> NEED_VERIFY_PERMISSION_STREAMS = {
36 STREAM_USAGE_SYSTEM,
37 STREAM_USAGE_DTMF,
38 STREAM_USAGE_ENFORCED_TONE,
39 STREAM_USAGE_ULTRASONIC,
40 STREAM_USAGE_VOICE_MODEM_COMMUNICATION
41 };
42 static constexpr uid_t UID_MSDP_SA = 6699;
43 static const std::map<AudioStreamType, StreamUsage> STREAM_TYPE_USAGE_MAP = {
44 {STREAM_MUSIC, STREAM_USAGE_MUSIC},
45 {STREAM_VOICE_CALL, STREAM_USAGE_VOICE_COMMUNICATION},
46 {STREAM_VOICE_ASSISTANT, STREAM_USAGE_VOICE_ASSISTANT},
47 {STREAM_ALARM, STREAM_USAGE_ALARM},
48 {STREAM_VOICE_MESSAGE, STREAM_USAGE_VOICE_MESSAGE},
49 {STREAM_RING, STREAM_USAGE_RINGTONE},
50 {STREAM_NOTIFICATION, STREAM_USAGE_NOTIFICATION},
51 {STREAM_ACCESSIBILITY, STREAM_USAGE_ACCESSIBILITY},
52 {STREAM_SYSTEM, STREAM_USAGE_SYSTEM},
53 {STREAM_MOVIE, STREAM_USAGE_MOVIE},
54 {STREAM_GAME, STREAM_USAGE_GAME},
55 {STREAM_SPEECH, STREAM_USAGE_AUDIOBOOK},
56 {STREAM_NAVIGATION, STREAM_USAGE_NAVIGATION},
57 {STREAM_DTMF, STREAM_USAGE_DTMF},
58 {STREAM_SYSTEM_ENFORCED, STREAM_USAGE_ENFORCED_TONE},
59 {STREAM_ULTRASONIC, STREAM_USAGE_ULTRASONIC}
60 };
61
SetStreamInfoToParams(const AudioStreamInfo & streamInfo)62 static AudioRendererParams SetStreamInfoToParams(const AudioStreamInfo &streamInfo)
63 {
64 AudioRendererParams params;
65 params.sampleFormat = streamInfo.format;
66 params.sampleRate = streamInfo.samplingRate;
67 params.channelCount = streamInfo.channels;
68 params.encodingType = streamInfo.encoding;
69 params.channelLayout = streamInfo.channelLayout;
70 return params;
71 }
72
IsNeedVerifyPermission(const StreamUsage streamUsage)73 static bool IsNeedVerifyPermission(const StreamUsage streamUsage)
74 {
75 for (const auto& item : NEED_VERIFY_PERMISSION_STREAMS) {
76 if (streamUsage == item) {
77 return true;
78 }
79 }
80 return false;
81 }
82
83 std::mutex AudioRenderer::createRendererMutex_;
84
85 AudioRenderer::~AudioRenderer() = default;
~AudioRendererPrivate()86 AudioRendererPrivate::~AudioRendererPrivate()
87 {
88 abortRestore_ = true;
89 std::shared_ptr<AudioRendererStateChangeCallbackImpl> audioDeviceChangeCallback = audioDeviceChangeCallback_;
90 if (audioDeviceChangeCallback != nullptr) {
91 audioDeviceChangeCallback->UnsetAudioRendererObj();
92 }
93
94 (void)AudioPolicyManager::GetInstance().UnregisterAudioRendererEventListener(appInfo_.appPid);
95
96 std::shared_ptr<OutputDeviceChangeWithInfoCallbackImpl> outputDeviceChangeCallback = outputDeviceChangeCallback_;
97 if (outputDeviceChangeCallback != nullptr) {
98 outputDeviceChangeCallback->UnsetAudioRendererObj();
99 }
100 AudioPolicyManager::GetInstance().UnregisterOutputDeviceChangeWithInfoCallback(sessionID_);
101
102 RendererState state = GetStatus();
103 if (state != RENDERER_RELEASED && state != RENDERER_NEW) {
104 Release();
105 }
106
107 RemoveRendererPolicyServiceDiedCallback();
108 DumpFileUtil::CloseDumpFile(&dumpFile_);
109 }
110
CheckMaxRendererInstances()111 int32_t AudioRenderer::CheckMaxRendererInstances()
112 {
113 std::vector<std::unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
114 AudioPolicyManager::GetInstance().GetCurrentRendererChangeInfos(audioRendererChangeInfos);
115 AUDIO_INFO_LOG("Audio current renderer change infos size: %{public}zu", audioRendererChangeInfos.size());
116 int32_t maxRendererInstances = AudioPolicyManager::GetInstance().GetMaxRendererInstances();
117 CHECK_AND_RETURN_RET_LOG(audioRendererChangeInfos.size() < static_cast<size_t>(maxRendererInstances), ERR_OVERFLOW,
118 "The current number of audio renderer streams is greater than the maximum number of configured instances");
119
120 return SUCCESS;
121 }
122
GetFormatSize(const AudioStreamParams & info)123 size_t GetFormatSize(const AudioStreamParams& info)
124 {
125 size_t bitWidthSize = 0;
126 switch (info.format) {
127 case SAMPLE_U8:
128 bitWidthSize = 1; // size is 1
129 break;
130 case SAMPLE_S16LE:
131 bitWidthSize = 2; // size is 2
132 break;
133 case SAMPLE_S24LE:
134 bitWidthSize = 3; // size is 3
135 break;
136 case SAMPLE_S32LE:
137 bitWidthSize = 4; // size is 4
138 break;
139 default:
140 bitWidthSize = 2; // size is 2
141 break;
142 }
143 return bitWidthSize;
144 }
145
Create(AudioStreamType audioStreamType)146 std::unique_ptr<AudioRenderer> AudioRenderer::Create(AudioStreamType audioStreamType)
147 {
148 AppInfo appInfo = {};
149 return Create(audioStreamType, appInfo);
150 }
151
Create(AudioStreamType audioStreamType,const AppInfo & appInfo)152 std::unique_ptr<AudioRenderer> AudioRenderer::Create(AudioStreamType audioStreamType, const AppInfo &appInfo)
153 {
154 if (audioStreamType == STREAM_MEDIA) {
155 audioStreamType = STREAM_MUSIC;
156 }
157 #ifdef OHCORE
158 return std::make_unique<AudioRendererGateway>(audioStreamType);
159 #else
160 return std::make_unique<AudioRendererPrivate>(audioStreamType, appInfo, true);
161 #endif
162 }
163
Create(const AudioRendererOptions & rendererOptions)164 std::unique_ptr<AudioRenderer> AudioRenderer::Create(const AudioRendererOptions &rendererOptions)
165 {
166 AppInfo appInfo = {};
167 return Create("", rendererOptions, appInfo);
168 }
169
Create(const AudioRendererOptions & rendererOptions,const AppInfo & appInfo)170 std::unique_ptr<AudioRenderer> AudioRenderer::Create(const AudioRendererOptions &rendererOptions,
171 const AppInfo &appInfo)
172 {
173 return Create("", rendererOptions, appInfo);
174 }
175
Create(const std::string cachePath,const AudioRendererOptions & rendererOptions)176 std::unique_ptr<AudioRenderer> AudioRenderer::Create(const std::string cachePath,
177 const AudioRendererOptions &rendererOptions)
178 {
179 AppInfo appInfo = {};
180 return Create(cachePath, rendererOptions, appInfo);
181 }
182
Create(const std::string cachePath,const AudioRendererOptions & rendererOptions,const AppInfo & appInfo)183 std::unique_ptr<AudioRenderer> AudioRenderer::Create(const std::string cachePath,
184 const AudioRendererOptions &rendererOptions, const AppInfo &appInfo)
185 {
186 Trace trace("AudioRenderer::Create");
187 std::lock_guard<std::mutex> lock(createRendererMutex_);
188 CHECK_AND_RETURN_RET_LOG(AudioRenderer::CheckMaxRendererInstances() == SUCCESS, nullptr,
189 "Too many renderer instances");
190 ContentType contentType = rendererOptions.rendererInfo.contentType;
191 CHECK_AND_RETURN_RET_LOG(contentType >= CONTENT_TYPE_UNKNOWN && contentType <= CONTENT_TYPE_ULTRASONIC, nullptr,
192 "Invalid content type");
193
194 StreamUsage streamUsage = rendererOptions.rendererInfo.streamUsage;
195 CHECK_AND_RETURN_RET_LOG(streamUsage >= STREAM_USAGE_UNKNOWN &&
196 streamUsage <= STREAM_USAGE_VOICE_MODEM_COMMUNICATION, nullptr, "Invalid stream usage");
197 if (contentType == CONTENT_TYPE_ULTRASONIC || IsNeedVerifyPermission(streamUsage)) {
198 if (!PermissionUtil::VerifySelfPermission()) {
199 AUDIO_ERR_LOG("CreateAudioRenderer failed! CONTENT_TYPE_ULTRASONIC or STREAM_USAGE_SYSTEM or "\
200 "STREAM_USAGE_VOICE_MODEM_COMMUNICATION: No system permission");
201 return nullptr;
202 }
203 }
204
205 AudioStreamType audioStreamType = IAudioStream::GetStreamType(contentType, streamUsage);
206 CHECK_AND_RETURN_RET_LOG((audioStreamType != STREAM_ULTRASONIC || getuid() == UID_MSDP_SA),
207 nullptr, "ULTRASONIC can only create by MSDP");
208
209 #ifdef OHCORE
210 auto audioRenderer = std::make_unique<AudioRendererGateway>(audioStreamType);
211 #else
212 auto audioRenderer = std::make_unique<AudioRendererPrivate>(audioStreamType, appInfo, false);
213 #endif
214 CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, nullptr, "Failed to create renderer object");
215 if (!cachePath.empty()) {
216 AUDIO_DEBUG_LOG("Set application cache path");
217 audioRenderer->cachePath_ = cachePath;
218 }
219
220 int32_t rendererFlags = rendererOptions.rendererInfo.rendererFlags;
221 AUDIO_INFO_LOG("create audiorenderer with usage: %{public}d, content: %{public}d, flags: %{public}d",
222 streamUsage, contentType, rendererFlags);
223
224 audioRenderer->rendererInfo_.contentType = contentType;
225 audioRenderer->rendererInfo_.streamUsage = streamUsage;
226 audioRenderer->rendererInfo_.rendererFlags = rendererFlags;
227 audioRenderer->privacyType_ = rendererOptions.privacyType;
228 AudioRendererParams params = SetStreamInfoToParams(rendererOptions.streamInfo);
229 if (audioRenderer->SetParams(params) != SUCCESS) {
230 AUDIO_ERR_LOG("SetParams failed in renderer");
231 audioRenderer = nullptr;
232 }
233
234 return audioRenderer;
235 }
236
AudioRendererPrivate(AudioStreamType audioStreamType,const AppInfo & appInfo,bool createStream)237 AudioRendererPrivate::AudioRendererPrivate(AudioStreamType audioStreamType, const AppInfo &appInfo, bool createStream)
238 {
239 appInfo_ = appInfo;
240 if (!(appInfo_.appPid)) {
241 appInfo_.appPid = getpid();
242 }
243
244 if (appInfo_.appUid < 0) {
245 appInfo_.appUid = static_cast<int32_t>(getuid());
246 }
247
248 if (createStream) {
249 AudioStreamParams tempParams = {};
250 audioStream_ = IAudioStream::GetPlaybackStream(IAudioStream::PA_STREAM, tempParams, audioStreamType,
251 appInfo_.appUid);
252 if (audioStream_ && STREAM_TYPE_USAGE_MAP.count(audioStreamType) != 0) {
253 // Initialize the streamUsage based on the streamType
254 rendererInfo_.streamUsage = STREAM_TYPE_USAGE_MAP.at(audioStreamType);
255 }
256 AUDIO_INFO_LOG("AudioRendererPrivate create normal stream for old mode.");
257 }
258
259 rendererProxyObj_ = std::make_shared<AudioRendererProxyObj>();
260 if (!rendererProxyObj_) {
261 AUDIO_WARNING_LOG("AudioRendererProxyObj Memory Allocation Failed !!");
262 }
263
264 audioInterrupt_.audioFocusType.streamType = audioStreamType;
265 audioInterrupt_.pid = appInfo_.appPid;
266 audioInterrupt_.mode = SHARE_MODE;
267 audioInterrupt_.parallelPlayFlag = false;
268 }
269
InitAudioInterruptCallback()270 int32_t AudioRendererPrivate::InitAudioInterruptCallback()
271 {
272 AUDIO_DEBUG_LOG("InitAudioInterruptCallback in");
273 CHECK_AND_RETURN_RET_LOG(audioInterrupt_.mode == SHARE_MODE || audioInterrupt_.mode == INDEPENDENT_MODE,
274 ERR_INVALID_PARAM, "Invalid interrupt mode!");
275 CHECK_AND_RETURN_RET_LOG(audioStream_->GetAudioSessionID(audioInterrupt_.sessionID) == 0, ERR_INVALID_INDEX,
276 "GetAudioSessionID failed");
277 sessionID_ = audioInterrupt_.sessionID;
278 audioInterrupt_.streamUsage = rendererInfo_.streamUsage;
279 audioInterrupt_.contentType = rendererInfo_.contentType;
280
281 AUDIO_INFO_LOG("interruptMode %{public}d, streamType %{public}d, sessionID %{public}d",
282 audioInterrupt_.mode, audioInterrupt_.audioFocusType.streamType, audioInterrupt_.sessionID);
283
284 if (audioInterruptCallback_ == nullptr) {
285 audioInterruptCallback_ = std::make_shared<AudioRendererInterruptCallbackImpl>(audioStream_, audioInterrupt_);
286 CHECK_AND_RETURN_RET_LOG(audioInterruptCallback_ != nullptr, ERROR,
287 "Failed to allocate memory for audioInterruptCallback_");
288 }
289 return AudioPolicyManager::GetInstance().SetAudioInterruptCallback(sessionID_, audioInterruptCallback_);
290 }
291
InitOutputDeviceChangeCallback()292 int32_t AudioRendererPrivate::InitOutputDeviceChangeCallback()
293 {
294 uint32_t sessionId;
295 int32_t ret = GetAudioStreamId(sessionId);
296 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Get sessionId failed");
297
298 ret = AudioPolicyManager::GetInstance().RegisterOutputDeviceChangeWithInfoCallback(sessionId,
299 outputDeviceChangeCallback_);
300 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Register failed");
301
302 return SUCCESS;
303 }
304
InitAudioStream(AudioStreamParams audioStreamParams)305 int32_t AudioRendererPrivate::InitAudioStream(AudioStreamParams audioStreamParams)
306 {
307 AudioRenderer *renderer = this;
308 rendererProxyObj_->SaveRendererObj(renderer);
309 audioStream_->SetRendererInfo(rendererInfo_);
310 audioStream_->SetClientID(appInfo_.appPid, appInfo_.appUid, appInfo_.appTokenId);
311
312 SetAudioPrivacyType(privacyType_);
313 audioStream_->SetStreamTrackerState(false);
314
315 int32_t ret = audioStream_->SetAudioStreamInfo(audioStreamParams, rendererProxyObj_);
316 CHECK_AND_RETURN_RET_LOG(!ret, ret, "SetParams SetAudioStreamInfo Failed");
317
318 if (isFastRenderer_) {
319 SetSelfRendererStateCallback();
320 }
321
322 return SUCCESS;
323 }
324
GetFrameCount(uint32_t & frameCount) const325 int32_t AudioRendererPrivate::GetFrameCount(uint32_t &frameCount) const
326 {
327 return audioStream_->GetFrameCount(frameCount);
328 }
329
GetLatency(uint64_t & latency) const330 int32_t AudioRendererPrivate::GetLatency(uint64_t &latency) const
331 {
332 return audioStream_->GetLatency(latency);
333 }
334
SetAudioPrivacyType(AudioPrivacyType privacyType)335 void AudioRendererPrivate::SetAudioPrivacyType(AudioPrivacyType privacyType)
336 {
337 privacyType_ = privacyType;
338 if (audioStream_ == nullptr) {
339 return;
340 }
341 audioStream_->SetPrivacyType(privacyType);
342 }
343
SetParams(const AudioRendererParams params)344 int32_t AudioRendererPrivate::SetParams(const AudioRendererParams params)
345 {
346 Trace trace("AudioRenderer::SetParams");
347 AudioStreamParams audioStreamParams = ConvertToAudioStreamParams(params);
348
349 AudioStreamType audioStreamType = IAudioStream::GetStreamType(rendererInfo_.contentType, rendererInfo_.streamUsage);
350 IAudioStream::StreamClass streamClass = IAudioStream::PA_STREAM;
351 if (rendererInfo_.rendererFlags == STREAM_FLAG_FORCED_NORMAL) {
352 AUDIO_INFO_LOG("Create stream with STREAM_FLAG_FORCED_NORMAL");
353 streamClass = IAudioStream::FORCED_PA_STREAM;
354 } else if (rendererInfo_.rendererFlags == STREAM_FLAG_FAST &&
355 IAudioStream::IsStreamSupported(rendererInfo_.rendererFlags, audioStreamParams) &&
356 AudioPolicyManager::GetInstance().GetActiveOutputDevice() != DEVICE_TYPE_BLUETOOTH_A2DP) {
357 AUDIO_INFO_LOG("Create stream with STREAM_FLAG_FAST");
358 isFastRenderer_ = true;
359 streamClass = IAudioStream::FAST_STREAM;
360 }
361
362 // check AudioStreamParams for fast stream
363 // As fast stream only support specified audio format, we should call GetPlaybackStream with audioStreamParams.
364 if (audioStream_ == nullptr) {
365 audioStream_ = IAudioStream::GetPlaybackStream(streamClass, audioStreamParams, audioStreamType,
366 appInfo_.appUid);
367 CHECK_AND_RETURN_RET_LOG(audioStream_ != nullptr, ERR_INVALID_PARAM, "SetParams GetPlayBackStream failed.");
368 AUDIO_INFO_LOG("IAudioStream::GetStream success");
369 audioStream_->SetApplicationCachePath(cachePath_);
370 }
371
372 int32_t ret = InitAudioStream(audioStreamParams);
373 // When the fast stream creation fails, a normal stream is created
374 if (ret != SUCCESS && streamClass == IAudioStream::FAST_STREAM) {
375 AUDIO_INFO_LOG("Create fast Stream fail, play by normal stream.");
376 streamClass = IAudioStream::PA_STREAM;
377 isFastRenderer_ = false;
378 audioStream_ = IAudioStream::GetPlaybackStream(streamClass, audioStreamParams, audioStreamType,
379 appInfo_.appUid);
380 CHECK_AND_RETURN_RET_LOG(audioStream_ != nullptr,
381 ERR_INVALID_PARAM, "SetParams GetPlayBackStream failed when create normal stream.");
382 ret = InitAudioStream(audioStreamParams);
383 audioStream_->SetRenderMode(RENDER_MODE_CALLBACK);
384 }
385
386 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "SetAudioStreamInfo Failed");
387 AUDIO_INFO_LOG("SetAudioStreamInfo Succeeded");
388
389 RegisterRendererPolicyServiceDiedCallback();
390
391 DumpFileUtil::OpenDumpFile(DUMP_CLIENT_PARA, DUMP_AUDIO_RENDERER_FILENAME, &dumpFile_);
392
393 if (outputDeviceChangeCallback_ != nullptr) {
394 ret = InitOutputDeviceChangeCallback();
395 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "InitOutputDeviceChangeCallback Failed");
396 }
397
398 return InitAudioInterruptCallback();
399 }
400
GetParams(AudioRendererParams & params) const401 int32_t AudioRendererPrivate::GetParams(AudioRendererParams ¶ms) const
402 {
403 AudioStreamParams audioStreamParams;
404 int32_t result = audioStream_->GetAudioStreamInfo(audioStreamParams);
405 if (!result) {
406 params.sampleFormat = static_cast<AudioSampleFormat>(audioStreamParams.format);
407 params.sampleRate = static_cast<AudioSamplingRate>(audioStreamParams.samplingRate);
408 params.channelCount = static_cast<AudioChannel>(audioStreamParams.channels);
409 params.encodingType = static_cast<AudioEncodingType>(audioStreamParams.encoding);
410 params.channelLayout = static_cast<AudioChannelLayout>(audioStreamParams.channelLayout);
411 }
412
413 return result;
414 }
415
GetRendererInfo(AudioRendererInfo & rendererInfo) const416 int32_t AudioRendererPrivate::GetRendererInfo(AudioRendererInfo &rendererInfo) const
417 {
418 rendererInfo = rendererInfo_;
419
420 return SUCCESS;
421 }
422
GetStreamInfo(AudioStreamInfo & streamInfo) const423 int32_t AudioRendererPrivate::GetStreamInfo(AudioStreamInfo &streamInfo) const
424 {
425 AudioStreamParams audioStreamParams;
426 int32_t result = audioStream_->GetAudioStreamInfo(audioStreamParams);
427 if (!result) {
428 streamInfo.format = static_cast<AudioSampleFormat>(audioStreamParams.format);
429 streamInfo.samplingRate = static_cast<AudioSamplingRate>(audioStreamParams.samplingRate);
430 streamInfo.channels = static_cast<AudioChannel>(audioStreamParams.channels);
431 streamInfo.encoding = static_cast<AudioEncodingType>(audioStreamParams.encoding);
432 streamInfo.channelLayout = static_cast<AudioChannelLayout>(audioStreamParams.channelLayout);
433 }
434
435 return result;
436 }
437
SetRendererCallback(const std::shared_ptr<AudioRendererCallback> & callback)438 int32_t AudioRendererPrivate::SetRendererCallback(const std::shared_ptr<AudioRendererCallback> &callback)
439 {
440 // If the client is using the deprecated SetParams API. SetRendererCallback must be invoked, after SetParams.
441 // In general, callbacks can only be set after the renderer state is PREPARED.
442 RendererState state = GetStatus();
443 CHECK_AND_RETURN_RET_LOG(state != RENDERER_NEW && state != RENDERER_RELEASED, ERR_ILLEGAL_STATE,
444 "incorrect state:%{public}d to register cb", state);
445
446 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM,
447 "callback param is null");
448
449 // Save reference for interrupt callback
450 CHECK_AND_RETURN_RET_LOG(audioInterruptCallback_ != nullptr, ERROR,
451 "audioInterruptCallback_ == nullptr");
452 std::shared_ptr<AudioRendererInterruptCallbackImpl> cbInterrupt =
453 std::static_pointer_cast<AudioRendererInterruptCallbackImpl>(audioInterruptCallback_);
454 cbInterrupt->SaveCallback(callback);
455
456 // Save and Set reference for stream callback. Order is important here.
457 if (audioStreamCallback_ == nullptr) {
458 audioStreamCallback_ = std::make_shared<AudioStreamCallbackRenderer>();
459 CHECK_AND_RETURN_RET_LOG(audioStreamCallback_ != nullptr, ERROR,
460 "Failed to allocate memory for audioStreamCallback_");
461 }
462 std::shared_ptr<AudioStreamCallbackRenderer> cbStream =
463 std::static_pointer_cast<AudioStreamCallbackRenderer>(audioStreamCallback_);
464 cbStream->SaveCallback(callback);
465 (void)audioStream_->SetStreamCallback(audioStreamCallback_);
466
467 return SUCCESS;
468 }
469
SetRendererPositionCallback(int64_t markPosition,const std::shared_ptr<RendererPositionCallback> & callback)470 int32_t AudioRendererPrivate::SetRendererPositionCallback(int64_t markPosition,
471 const std::shared_ptr<RendererPositionCallback> &callback)
472 {
473 CHECK_AND_RETURN_RET_LOG((callback != nullptr) && (markPosition > 0), ERR_INVALID_PARAM,
474 "input param is invalid");
475
476 audioStream_->SetRendererPositionCallback(markPosition, callback);
477
478 return SUCCESS;
479 }
480
UnsetRendererPositionCallback()481 void AudioRendererPrivate::UnsetRendererPositionCallback()
482 {
483 audioStream_->UnsetRendererPositionCallback();
484 }
485
SetRendererPeriodPositionCallback(int64_t frameNumber,const std::shared_ptr<RendererPeriodPositionCallback> & callback)486 int32_t AudioRendererPrivate::SetRendererPeriodPositionCallback(int64_t frameNumber,
487 const std::shared_ptr<RendererPeriodPositionCallback> &callback)
488 {
489 CHECK_AND_RETURN_RET_LOG((callback != nullptr) && (frameNumber > 0), ERR_INVALID_PARAM,
490 "input param is invalid");
491
492 audioStream_->SetRendererPeriodPositionCallback(frameNumber, callback);
493
494 return SUCCESS;
495 }
496
UnsetRendererPeriodPositionCallback()497 void AudioRendererPrivate::UnsetRendererPeriodPositionCallback()
498 {
499 audioStream_->UnsetRendererPeriodPositionCallback();
500 }
501
Start(StateChangeCmdType cmdType) const502 bool AudioRendererPrivate::Start(StateChangeCmdType cmdType) const
503 {
504 Trace trace("AudioRenderer::Start");
505
506 AUDIO_INFO_LOG("AudioRenderer::Start id: %{public}u", sessionID_);
507
508 RendererState state = GetStatus();
509 CHECK_AND_RETURN_RET_LOG((state == RENDERER_PREPARED) || (state == RENDERER_STOPPED) || (state == RENDERER_PAUSED),
510 false, "Start failed. Illegal state:%{public}u", state);
511
512 CHECK_AND_RETURN_RET_LOG(!isSwitching_, false,
513 "Start failed. Switching state: %{public}d", isSwitching_);
514
515 AUDIO_INFO_LOG("interruptMode: %{public}d, streamType: %{public}d, sessionID: %{public}d",
516 audioInterrupt_.mode, audioInterrupt_.audioFocusType.streamType, audioInterrupt_.sessionID);
517
518 if (audioInterrupt_.audioFocusType.streamType == STREAM_DEFAULT ||
519 audioInterrupt_.sessionID == INVALID_SESSION_ID) {
520 return false;
521 }
522
523 int32_t ret = AudioPolicyManager::GetInstance().ActivateAudioInterrupt(audioInterrupt_);
524 CHECK_AND_RETURN_RET_LOG(ret == 0, false, "ActivateAudioInterrupt Failed");
525
526 // When the cellular call stream is starting, only need to activate audio interrupt.
527 CHECK_AND_RETURN_RET(audioInterrupt_.streamUsage != STREAM_USAGE_VOICE_MODEM_COMMUNICATION, true);
528
529 return audioStream_->StartAudioStream(cmdType);
530 }
531
Write(uint8_t * buffer,size_t bufferSize)532 int32_t AudioRendererPrivate::Write(uint8_t *buffer, size_t bufferSize)
533 {
534 Trace trace("Write");
535 #ifdef SONIC_ENABLE
536 if (!isEqual(speed_, 1.0f)) {
537 auto outBuffer = std::make_unique<uint8_t[]>(MAX_BUFFER_SIZE);
538 int32_t outBufferSize = 0;
539 int32_t ret = audioStream_->ChangeSpeed(buffer, bufferSize, outBuffer, outBufferSize);
540 if (ret == 0) return ret; // Sonic write error
541 if (outBufferSize == 0) return bufferSize; // Continue writing when the sonic is not full
542 DumpFileUtil::WriteDumpFile(dumpFile_, static_cast<void *>(outBuffer.get()), outBufferSize);
543 return audioStream_->WriteSpeedBuffer(bufferSize, outBuffer.get(), outBufferSize);
544 }
545 #endif
546 int32_t size = audioStream_->Write(buffer, bufferSize);
547 if (size > 0) {
548 DumpFileUtil::WriteDumpFile(dumpFile_, static_cast<void *>(buffer), size);
549 }
550 return size;
551 }
552
Write(uint8_t * pcmBuffer,size_t pcmSize,uint8_t * metaBuffer,size_t metaSize)553 int32_t AudioRendererPrivate::Write(uint8_t *pcmBuffer, size_t pcmSize, uint8_t *metaBuffer, size_t metaSize)
554 {
555 Trace trace("Write");
556 int32_t size = audioStream_->Write(pcmBuffer, pcmSize, metaBuffer, metaSize);
557 return size;
558 }
559
GetStatus() const560 RendererState AudioRendererPrivate::GetStatus() const
561 {
562 return static_cast<RendererState>(audioStream_->GetState());
563 }
564
GetAudioTime(Timestamp & timestamp,Timestamp::Timestampbase base) const565 bool AudioRendererPrivate::GetAudioTime(Timestamp ×tamp, Timestamp::Timestampbase base) const
566 {
567 return audioStream_->GetAudioTime(timestamp, base);
568 }
569
GetAudioPosition(Timestamp & timestamp,Timestamp::Timestampbase base) const570 bool AudioRendererPrivate::GetAudioPosition(Timestamp ×tamp, Timestamp::Timestampbase base) const
571 {
572 return audioStream_->GetAudioPosition(timestamp, base);
573 }
574
Drain() const575 bool AudioRendererPrivate::Drain() const
576 {
577 return audioStream_->DrainAudioStream();
578 }
579
Flush() const580 bool AudioRendererPrivate::Flush() const
581 {
582 return audioStream_->FlushAudioStream();
583 }
584
PauseTransitent(StateChangeCmdType cmdType) const585 bool AudioRendererPrivate::PauseTransitent(StateChangeCmdType cmdType) const
586 {
587 Trace trace("AudioRenderer::PauseTransitent");
588 AUDIO_INFO_LOG("AudioRenderer::PauseTransitent");
589 if (isSwitching_) {
590 AUDIO_ERR_LOG("failed. Switching state: %{public}d", isSwitching_);
591 return false;
592 }
593
594 if (audioInterrupt_.streamUsage == STREAM_USAGE_VOICE_MODEM_COMMUNICATION) {
595 return true;
596 }
597
598 RendererState state = GetStatus();
599 if (state != RENDERER_RUNNING) {
600 // If the stream is not running, there is no need to pause and deactive audio interrupt
601 AUDIO_ERR_LOG("State of stream is not running. Illegal state:%{public}u", state);
602 return false;
603 }
604 bool result = audioStream_->PauseAudioStream(cmdType);
605 return result;
606 }
607
Pause(StateChangeCmdType cmdType) const608 bool AudioRendererPrivate::Pause(StateChangeCmdType cmdType) const
609 {
610 Trace trace("AudioRenderer::Pause");
611
612 AUDIO_INFO_LOG("AudioRenderer::Pause id: %{public}u", sessionID_);
613
614 CHECK_AND_RETURN_RET_LOG(!isSwitching_, false, "Pause failed. Switching state: %{public}d", isSwitching_);
615
616 if (audioInterrupt_.streamUsage == STREAM_USAGE_VOICE_MODEM_COMMUNICATION) {
617 // When the cellular call stream is pausing, only need to deactivate audio interrupt.
618 if (AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt_) != 0) {
619 AUDIO_ERR_LOG("DeactivateAudioInterrupt Failed");
620 }
621 return true;
622 }
623
624 RendererState state = GetStatus();
625 CHECK_AND_RETURN_RET_LOG(state == RENDERER_RUNNING, false,
626 "State of stream is not running. Illegal state:%{public}u", state);
627 bool result = audioStream_->PauseAudioStream(cmdType);
628
629 // When user is intentionally pausing, deactivate to remove from audioFocusInfoList_
630 int32_t ret = AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt_);
631 if (ret != 0) {
632 AUDIO_ERR_LOG("DeactivateAudioInterrupt Failed");
633 }
634
635 return result;
636 }
637
Stop() const638 bool AudioRendererPrivate::Stop() const
639 {
640 AUDIO_INFO_LOG("AudioRenderer::Stop id: %{public}u", sessionID_);
641 CHECK_AND_RETURN_RET_LOG(!isSwitching_, false,
642 "AudioRenderer::Stop failed. Switching state: %{public}d", isSwitching_);
643 if (audioInterrupt_.streamUsage == STREAM_USAGE_VOICE_MODEM_COMMUNICATION) {
644 // When the cellular call stream is stopping, only need to deactivate audio interrupt.
645 if (AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt_) != 0) {
646 AUDIO_WARNING_LOG("DeactivateAudioInterrupt Failed");
647 }
648 return true;
649 }
650
651 bool result = audioStream_->StopAudioStream();
652 int32_t ret = AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt_);
653 if (ret != 0) {
654 AUDIO_WARNING_LOG("DeactivateAudioInterrupt Failed");
655 }
656
657 return result;
658 }
659
Release() const660 bool AudioRendererPrivate::Release() const
661 {
662 AUDIO_INFO_LOG("AudioRenderer::Release id: %{public}u", sessionID_);
663
664 // If Stop call was skipped, Release to take care of Deactivation
665 (void)AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt_);
666
667 // Unregister the callaback in policy server
668 (void)AudioPolicyManager::GetInstance().UnsetAudioInterruptCallback(sessionID_);
669
670 AudioPolicyManager::GetInstance().UnregisterOutputDeviceChangeWithInfoCallback(sessionID_);
671
672 return audioStream_->ReleaseAudioStream();
673 }
674
GetBufferSize(size_t & bufferSize) const675 int32_t AudioRendererPrivate::GetBufferSize(size_t &bufferSize) const
676 {
677 return audioStream_->GetBufferSize(bufferSize);
678 }
679
GetAudioStreamId(uint32_t & sessionID) const680 int32_t AudioRendererPrivate::GetAudioStreamId(uint32_t &sessionID) const
681 {
682 return audioStream_->GetAudioSessionID(sessionID);
683 }
684
SetAudioRendererDesc(AudioRendererDesc audioRendererDesc)685 int32_t AudioRendererPrivate::SetAudioRendererDesc(AudioRendererDesc audioRendererDesc)
686 {
687 ContentType contentType = audioRendererDesc.contentType;
688 StreamUsage streamUsage = audioRendererDesc.streamUsage;
689 AudioStreamType audioStreamType = IAudioStream::GetStreamType(contentType, streamUsage);
690 audioInterrupt_.audioFocusType.streamType = audioStreamType;
691 return audioStream_->SetAudioStreamType(audioStreamType);
692 }
693
SetStreamType(AudioStreamType audioStreamType)694 int32_t AudioRendererPrivate::SetStreamType(AudioStreamType audioStreamType)
695 {
696 audioInterrupt_.audioFocusType.streamType = audioStreamType;
697 return audioStream_->SetAudioStreamType(audioStreamType);
698 }
699
SetVolume(float volume) const700 int32_t AudioRendererPrivate::SetVolume(float volume) const
701 {
702 return audioStream_->SetVolume(volume);
703 }
704
GetVolume() const705 float AudioRendererPrivate::GetVolume() const
706 {
707 return audioStream_->GetVolume();
708 }
709
SetRenderRate(AudioRendererRate renderRate) const710 int32_t AudioRendererPrivate::SetRenderRate(AudioRendererRate renderRate) const
711 {
712 return audioStream_->SetRenderRate(renderRate);
713 }
714
GetRenderRate() const715 AudioRendererRate AudioRendererPrivate::GetRenderRate() const
716 {
717 return audioStream_->GetRenderRate();
718 }
719
SetRendererSamplingRate(uint32_t sampleRate) const720 int32_t AudioRendererPrivate::SetRendererSamplingRate(uint32_t sampleRate) const
721 {
722 return audioStream_->SetRendererSamplingRate(sampleRate);
723 }
724
GetRendererSamplingRate() const725 uint32_t AudioRendererPrivate::GetRendererSamplingRate() const
726 {
727 return audioStream_->GetRendererSamplingRate();
728 }
729
SetBufferDuration(uint64_t bufferDuration) const730 int32_t AudioRendererPrivate::SetBufferDuration(uint64_t bufferDuration) const
731 {
732 CHECK_AND_RETURN_RET_LOG(bufferDuration >= MINIMUM_BUFFER_SIZE_MSEC && bufferDuration <= MAXIMUM_BUFFER_SIZE_MSEC,
733 ERR_INVALID_PARAM, "Error: Please set the buffer duration between 5ms ~ 20ms");
734
735 return audioStream_->SetBufferSizeInMsec(bufferDuration);
736 }
737
SetChannelBlendMode(ChannelBlendMode blendMode)738 int32_t AudioRendererPrivate::SetChannelBlendMode(ChannelBlendMode blendMode)
739 {
740 return audioStream_->SetChannelBlendMode(blendMode);
741 }
742
AudioRendererInterruptCallbackImpl(const std::shared_ptr<IAudioStream> & audioStream,const AudioInterrupt & audioInterrupt)743 AudioRendererInterruptCallbackImpl::AudioRendererInterruptCallbackImpl(const std::shared_ptr<IAudioStream> &audioStream,
744 const AudioInterrupt &audioInterrupt)
745 : audioStream_(audioStream), audioInterrupt_(audioInterrupt)
746 {
747 AUDIO_DEBUG_LOG("AudioRendererInterruptCallbackImpl constructor");
748 }
749
~AudioRendererInterruptCallbackImpl()750 AudioRendererInterruptCallbackImpl::~AudioRendererInterruptCallbackImpl()
751 {
752 AUDIO_DEBUG_LOG("AudioRendererInterruptCallbackImpl: instance destroy");
753 }
754
SaveCallback(const std::weak_ptr<AudioRendererCallback> & callback)755 void AudioRendererInterruptCallbackImpl::SaveCallback(const std::weak_ptr<AudioRendererCallback> &callback)
756 {
757 callback_ = callback;
758 }
759
NotifyEvent(const InterruptEvent & interruptEvent)760 void AudioRendererInterruptCallbackImpl::NotifyEvent(const InterruptEvent &interruptEvent)
761 {
762 if (cb_ != nullptr) {
763 cb_->OnInterrupt(interruptEvent);
764 AUDIO_DEBUG_LOG("Send interruptEvent to app successfully");
765 } else {
766 AUDIO_WARNING_LOG("cb_==nullptr, failed to send interruptEvent");
767 }
768 }
769
HandleForceDucking(const InterruptEventInternal & interruptEvent)770 bool AudioRendererInterruptCallbackImpl::HandleForceDucking(const InterruptEventInternal &interruptEvent)
771 {
772 if (!isForceDucked_) {
773 // This stream need to be ducked. Update instanceVolBeforeDucking_
774 instanceVolBeforeDucking_ = audioStream_->GetVolume();
775 }
776
777 float duckVolumeFactor = interruptEvent.duckVolume;
778 int32_t ret = audioStream_->SetVolume(instanceVolBeforeDucking_ * duckVolumeFactor);
779 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, false, "Failed to set duckVolumeFactor(instance) %{public}f",
780 duckVolumeFactor);
781
782 AUDIO_INFO_LOG("Set duckVolumeFactor %{public}f successfully. instanceVolBeforeDucking: %{public}f",
783 duckVolumeFactor, instanceVolBeforeDucking_);
784 return true;
785 }
786
NotifyForcePausedToResume(const InterruptEventInternal & interruptEvent)787 void AudioRendererInterruptCallbackImpl::NotifyForcePausedToResume(const InterruptEventInternal &interruptEvent)
788 {
789 // Change InterruptForceType to Share, Since app will take care of resuming
790 InterruptEvent interruptEventResume {interruptEvent.eventType, INTERRUPT_SHARE,
791 interruptEvent.hintType};
792 NotifyEvent(interruptEventResume);
793 }
794
HandleAndNotifyForcedEvent(const InterruptEventInternal & interruptEvent)795 void AudioRendererInterruptCallbackImpl::HandleAndNotifyForcedEvent(const InterruptEventInternal &interruptEvent)
796 {
797 // ForceType: INTERRUPT_FORCE. Handle the event forcely and notify the app.
798 AUDIO_DEBUG_LOG("AudioRendererInterruptCallbackImpl::HandleAndNotifyForcedEvent");
799 InterruptHint hintType = interruptEvent.hintType;
800 switch (hintType) {
801 case INTERRUPT_HINT_PAUSE:
802 if (audioStream_->GetState() == PREPARED) {
803 AUDIO_DEBUG_LOG("To pause incoming, no need to pause");
804 } else if (audioStream_->GetState() == RUNNING) {
805 (void)audioStream_->PauseAudioStream(); // Just Pause, do not deactivate here
806 } else {
807 AUDIO_WARNING_LOG("State of stream is not running.No need to pause");
808 return;
809 }
810 isForcePaused_ = true;
811 break;
812 case INTERRUPT_HINT_RESUME:
813 if ((audioStream_->GetState() != PAUSED && audioStream_->GetState() != PREPARED) || !isForcePaused_) {
814 AUDIO_WARNING_LOG("State of stream is not paused or pause is not forced");
815 return;
816 }
817 isForcePaused_ = false;
818 NotifyForcePausedToResume(interruptEvent);
819 return; // return, sending callback is taken care in NotifyForcePausedToResume
820 case INTERRUPT_HINT_STOP:
821 (void)audioStream_->StopAudioStream();
822 break;
823 case INTERRUPT_HINT_DUCK:
824 if (!HandleForceDucking(interruptEvent)) {
825 AUDIO_WARNING_LOG("Failed to duck forcely, don't notify app");
826 return;
827 }
828 isForceDucked_ = true;
829 break;
830 case INTERRUPT_HINT_UNDUCK:
831 if (!isForceDucked_) {
832 AUDIO_WARNING_LOG("It is not forced ducked, don't unduck or notify app");
833 return;
834 }
835 (void)audioStream_->SetVolume(instanceVolBeforeDucking_);
836 AUDIO_INFO_LOG("Unduck Volume(instance) successfully: instanceVolBeforeDucking_ %{public}f",
837 instanceVolBeforeDucking_);
838 isForceDucked_ = false;
839 instanceVolBeforeDucking_ = 1.0f;
840 break;
841 default: // If the hintType is NONE, don't need to send callbacks
842 return;
843 }
844 // Notify valid forced event callbacks to app
845 InterruptEvent interruptEventForced {interruptEvent.eventType, interruptEvent.forceType, interruptEvent.hintType};
846 NotifyEvent(interruptEventForced);
847 }
848
OnInterrupt(const InterruptEventInternal & interruptEvent)849 void AudioRendererInterruptCallbackImpl::OnInterrupt(const InterruptEventInternal &interruptEvent)
850 {
851 cb_ = callback_.lock();
852 InterruptForceType forceType = interruptEvent.forceType;
853 AUDIO_INFO_LOG("forceType %{public}d, hintType: %{public}d",
854 forceType, interruptEvent.hintType);
855
856 if (forceType != INTERRUPT_FORCE) { // INTERRUPT_SHARE
857 AUDIO_DEBUG_LOG("INTERRUPT_SHARE. Let app handle the event");
858 InterruptEvent interruptEventShared {interruptEvent.eventType, interruptEvent.forceType,
859 interruptEvent.hintType};
860 NotifyEvent(interruptEventShared);
861 return;
862 }
863
864 CHECK_AND_RETURN_LOG(audioStream_ != nullptr,
865 "Stream is not alive. No need to take forced action");
866
867 HandleAndNotifyForcedEvent(interruptEvent);
868 }
869
SaveCallback(const std::weak_ptr<AudioRendererCallback> & callback)870 void AudioStreamCallbackRenderer::SaveCallback(const std::weak_ptr<AudioRendererCallback> &callback)
871 {
872 callback_ = callback;
873 }
874
OnStateChange(const State state,const StateChangeCmdType cmdType)875 void AudioStreamCallbackRenderer::OnStateChange(const State state, const StateChangeCmdType cmdType)
876 {
877 std::shared_ptr<AudioRendererCallback> cb = callback_.lock();
878 CHECK_AND_RETURN_LOG(cb != nullptr, "cb == nullptr.");
879
880 cb->OnStateChange(static_cast<RendererState>(state), cmdType);
881 }
882
GetSupportedFormats()883 std::vector<AudioSampleFormat> AudioRenderer::GetSupportedFormats()
884 {
885 return AUDIO_SUPPORTED_FORMATS;
886 }
887
GetSupportedSamplingRates()888 std::vector<AudioSamplingRate> AudioRenderer::GetSupportedSamplingRates()
889 {
890 return AUDIO_SUPPORTED_SAMPLING_RATES;
891 }
892
GetSupportedChannels()893 std::vector<AudioChannel> AudioRenderer::GetSupportedChannels()
894 {
895 return RENDERER_SUPPORTED_CHANNELS;
896 }
897
GetSupportedEncodingTypes()898 std::vector<AudioEncodingType> AudioRenderer::GetSupportedEncodingTypes()
899 {
900 return AUDIO_SUPPORTED_ENCODING_TYPES;
901 }
902
SetRenderMode(AudioRenderMode renderMode) const903 int32_t AudioRendererPrivate::SetRenderMode(AudioRenderMode renderMode) const
904 {
905 return audioStream_->SetRenderMode(renderMode);
906 }
907
GetRenderMode() const908 AudioRenderMode AudioRendererPrivate::GetRenderMode() const
909 {
910 return audioStream_->GetRenderMode();
911 }
912
GetBufferDesc(BufferDesc & bufDesc) const913 int32_t AudioRendererPrivate::GetBufferDesc(BufferDesc &bufDesc) const
914 {
915 std::lock_guard<std::mutex> lock(switchStreamMutex_);
916 return audioStream_->GetBufferDesc(bufDesc);
917 }
918
Enqueue(const BufferDesc & bufDesc) const919 int32_t AudioRendererPrivate::Enqueue(const BufferDesc &bufDesc) const
920 {
921 DumpFileUtil::WriteDumpFile(dumpFile_, static_cast<void *>(bufDesc.buffer), bufDesc.bufLength);
922 std::lock_guard<std::mutex> lock(switchStreamMutex_);
923 return audioStream_->Enqueue(bufDesc);
924 }
925
Clear() const926 int32_t AudioRendererPrivate::Clear() const
927 {
928 return audioStream_->Clear();
929 }
930
GetBufQueueState(BufferQueueState & bufState) const931 int32_t AudioRendererPrivate::GetBufQueueState(BufferQueueState &bufState) const
932 {
933 return audioStream_->GetBufQueueState(bufState);
934 }
935
SetApplicationCachePath(const std::string cachePath)936 void AudioRendererPrivate::SetApplicationCachePath(const std::string cachePath)
937 {
938 cachePath_ = cachePath;
939 if (audioStream_ != nullptr) {
940 audioStream_->SetApplicationCachePath(cachePath);
941 } else {
942 AUDIO_WARNING_LOG("while stream is null");
943 }
944 }
945
SetRendererWriteCallback(const std::shared_ptr<AudioRendererWriteCallback> & callback)946 int32_t AudioRendererPrivate::SetRendererWriteCallback(const std::shared_ptr<AudioRendererWriteCallback> &callback)
947 {
948 return audioStream_->SetRendererWriteCallback(callback);
949 }
950
SetRendererFirstFrameWritingCallback(const std::shared_ptr<AudioRendererFirstFrameWritingCallback> & callback)951 int32_t AudioRendererPrivate::SetRendererFirstFrameWritingCallback(
952 const std::shared_ptr<AudioRendererFirstFrameWritingCallback> &callback)
953 {
954 return audioStream_->SetRendererFirstFrameWritingCallback(callback);
955 }
956
SetInterruptMode(InterruptMode mode)957 void AudioRendererPrivate::SetInterruptMode(InterruptMode mode)
958 {
959 AUDIO_INFO_LOG("InterruptMode %{pubilc}d", mode);
960 if (audioInterrupt_.mode == mode) {
961 return;
962 } else if (mode != SHARE_MODE && mode != INDEPENDENT_MODE) {
963 AUDIO_ERR_LOG("Invalid interrupt mode!");
964 return;
965 }
966 audioInterrupt_.mode = mode;
967 }
968
SetParallelPlayFlag(bool parallelPlayFlag)969 int32_t AudioRendererPrivate::SetParallelPlayFlag(bool parallelPlayFlag)
970 {
971 AUDIO_INFO_LOG("parallelPlayFlag %{pubilc}d", parallelPlayFlag);
972 audioInterrupt_.parallelPlayFlag = parallelPlayFlag;
973 return SUCCESS;
974 }
975
SetLowPowerVolume(float volume) const976 int32_t AudioRendererPrivate::SetLowPowerVolume(float volume) const
977 {
978 return audioStream_->SetLowPowerVolume(volume);
979 }
980
GetLowPowerVolume() const981 float AudioRendererPrivate::GetLowPowerVolume() const
982 {
983 return audioStream_->GetLowPowerVolume();
984 }
985
SetOffloadMode(int32_t state,bool isAppBack) const986 int32_t AudioRendererPrivate::SetOffloadMode(int32_t state, bool isAppBack) const
987 {
988 return audioStream_->SetOffloadMode(state, isAppBack);
989 }
990
UnsetOffloadMode() const991 int32_t AudioRendererPrivate::UnsetOffloadMode() const
992 {
993 return audioStream_->UnsetOffloadMode();
994 }
995
GetSingleStreamVolume() const996 float AudioRendererPrivate::GetSingleStreamVolume() const
997 {
998 return audioStream_->GetSingleStreamVolume();
999 }
1000
GetMinStreamVolume() const1001 float AudioRendererPrivate::GetMinStreamVolume() const
1002 {
1003 return AudioPolicyManager::GetInstance().GetMinStreamVolume();
1004 }
1005
GetMaxStreamVolume() const1006 float AudioRendererPrivate::GetMaxStreamVolume() const
1007 {
1008 return AudioPolicyManager::GetInstance().GetMaxStreamVolume();
1009 }
1010
GetCurrentOutputDevices(DeviceInfo & deviceInfo) const1011 int32_t AudioRendererPrivate::GetCurrentOutputDevices(DeviceInfo &deviceInfo) const
1012 {
1013 std::vector<std::unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
1014 uint32_t sessionId = static_cast<uint32_t>(-1);
1015 int32_t ret = GetAudioStreamId(sessionId);
1016 CHECK_AND_RETURN_RET_LOG(!ret, ret, " Get sessionId failed");
1017
1018 ret = AudioPolicyManager::GetInstance().GetCurrentRendererChangeInfos(audioRendererChangeInfos);
1019 CHECK_AND_RETURN_RET_LOG(!ret, ret, "Get Current Renderer devices failed");
1020
1021 for (auto it = audioRendererChangeInfos.begin(); it != audioRendererChangeInfos.end(); it++) {
1022 if ((*it)->sessionId == static_cast<int32_t>(sessionId)) {
1023 deviceInfo = (*it)->outputDeviceInfo;
1024 }
1025 }
1026 return SUCCESS;
1027 }
1028
GetUnderflowCount() const1029 uint32_t AudioRendererPrivate::GetUnderflowCount() const
1030 {
1031 return audioStream_->GetUnderflowCount();
1032 }
1033
1034
SetAudioRendererErrorCallback(std::shared_ptr<AudioRendererErrorCallback> errorCallback)1035 void AudioRendererPrivate::SetAudioRendererErrorCallback(std::shared_ptr<AudioRendererErrorCallback> errorCallback)
1036 {
1037 audioRendererErrorCallback_ = errorCallback;
1038 }
1039
RegisterAudioRendererEventListener(const int32_t clientPid,const std::shared_ptr<AudioRendererDeviceChangeCallback> & callback)1040 int32_t AudioRendererPrivate::RegisterAudioRendererEventListener(const int32_t clientPid,
1041 const std::shared_ptr<AudioRendererDeviceChangeCallback> &callback)
1042 {
1043 AUDIO_INFO_LOG("RegisterAudioRendererEventListener client id: %{public}d", clientPid);
1044 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "callback is null");
1045
1046 CHECK_AND_RETURN_RET_LOG(GetCurrentOutputDevices(currentDeviceInfo_) == SUCCESS, ERROR,
1047 "get current device info failed");
1048
1049 if (!audioDeviceChangeCallback_) {
1050 audioDeviceChangeCallback_ = std::make_shared<AudioRendererStateChangeCallbackImpl>();
1051 CHECK_AND_RETURN_RET_LOG(audioDeviceChangeCallback_, ERROR,
1052 "Memory Allocation Failed !!");
1053 }
1054
1055 int32_t ret =
1056 AudioPolicyManager::GetInstance().RegisterAudioRendererEventListener(clientPid, audioDeviceChangeCallback_);
1057 CHECK_AND_RETURN_RET_LOG(ret == 0, ERROR,
1058 "RegisterAudioRendererEventListener failed");
1059
1060 audioDeviceChangeCallback_->setAudioRendererObj(this);
1061 audioDeviceChangeCallback_->SaveCallback(callback);
1062 AUDIO_DEBUG_LOG("RegisterAudioRendererEventListener successful!");
1063 return SUCCESS;
1064 }
1065
RegisterAudioPolicyServerDiedCb(const int32_t clientPid,const std::shared_ptr<AudioRendererPolicyServiceDiedCallback> & callback)1066 int32_t AudioRendererPrivate::RegisterAudioPolicyServerDiedCb(const int32_t clientPid,
1067 const std::shared_ptr<AudioRendererPolicyServiceDiedCallback> &callback)
1068 {
1069 AUDIO_INFO_LOG("RegisterAudioPolicyServerDiedCb client id: %{public}d", clientPid);
1070 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "callback is null");
1071
1072 return AudioPolicyManager::GetInstance().RegisterAudioPolicyServerDiedCb(clientPid, callback);
1073 }
1074
UnregisterAudioPolicyServerDiedCb(const int32_t clientPid)1075 int32_t AudioRendererPrivate::UnregisterAudioPolicyServerDiedCb(const int32_t clientPid)
1076 {
1077 AUDIO_INFO_LOG("UnregisterAudioPolicyServerDiedCb client id: %{public}d", clientPid);
1078 return AudioPolicyManager::GetInstance().UnregisterAudioPolicyServerDiedCb(clientPid);
1079 }
1080
DestroyAudioRendererStateCallback()1081 void AudioRendererPrivate::DestroyAudioRendererStateCallback()
1082 {
1083 if (audioDeviceChangeCallback_ != nullptr) {
1084 audioDeviceChangeCallback_.reset();
1085 audioDeviceChangeCallback_ = nullptr;
1086 }
1087 }
1088
UnregisterAudioRendererEventListener(const int32_t clientPid)1089 int32_t AudioRendererPrivate::UnregisterAudioRendererEventListener(const int32_t clientPid)
1090 {
1091 AUDIO_INFO_LOG("client id: %{public}d", clientPid);
1092 int32_t ret = AudioPolicyManager::GetInstance().UnregisterAudioRendererEventListener(clientPid);
1093 CHECK_AND_RETURN_RET_LOG(ret == 0, ERROR,
1094 "UnregisterAudioRendererEventListener failed");
1095
1096 DestroyAudioRendererStateCallback();
1097 return SUCCESS;
1098 }
1099
RegisterOutputDeviceChangeWithInfoCallback(const std::shared_ptr<AudioRendererOutputDeviceChangeCallback> & callback)1100 int32_t AudioRendererPrivate::RegisterOutputDeviceChangeWithInfoCallback(
1101 const std::shared_ptr<AudioRendererOutputDeviceChangeCallback> &callback)
1102 {
1103 AUDIO_INFO_LOG("RegisterOutputDeviceChangeWithInfoCallback");
1104 if (callback == nullptr) {
1105 AUDIO_ERR_LOG("callback is null");
1106 return ERR_INVALID_PARAM;
1107 }
1108
1109 if (GetCurrentOutputDevices(currentDeviceInfo_) != SUCCESS) {
1110 AUDIO_ERR_LOG("get current device info failed");
1111 return ERROR;
1112 }
1113
1114 if (!outputDeviceChangeCallback_) {
1115 outputDeviceChangeCallback_ = std::make_shared<OutputDeviceChangeWithInfoCallbackImpl>();
1116 if (!outputDeviceChangeCallback_) {
1117 AUDIO_ERR_LOG("Memory Allocation Failed !!");
1118 return ERROR;
1119 }
1120 }
1121
1122 int32_t ret = InitOutputDeviceChangeCallback();
1123 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "InitOutputDeviceChangeCallback Failed");
1124
1125 outputDeviceChangeCallback_->SetAudioRendererObj(this);
1126 outputDeviceChangeCallback_->SaveCallback(callback);
1127 AUDIO_DEBUG_LOG("RegisterOutputDeviceChangeWithInfoCallback successful!");
1128 return SUCCESS;
1129 }
1130
DestroyOutputDeviceChangeWithInfoCallback()1131 void AudioRendererPrivate::DestroyOutputDeviceChangeWithInfoCallback()
1132 {
1133 outputDeviceChangeCallback_ = nullptr;
1134 }
1135
UnregisterOutputDeviceChangeWithInfoCallback()1136 int32_t AudioRendererPrivate::UnregisterOutputDeviceChangeWithInfoCallback()
1137 {
1138 AUDIO_INFO_LOG("UnregisterAudioCapturerEventListener");
1139
1140 uint32_t sessionId;
1141 int32_t ret = GetAudioStreamId(sessionId);
1142 if (ret) {
1143 AUDIO_ERR_LOG("UnregisterOutputDeviceChangeWithInfoCallback Get sessionId failed");
1144 return ret;
1145 }
1146
1147 ret = AudioPolicyManager::GetInstance().UnregisterOutputDeviceChangeWithInfoCallback(sessionId);
1148 if (ret != 0) {
1149 AUDIO_ERR_LOG("UnregisterAudioRendererEventListener failed");
1150 return ERROR;
1151 }
1152
1153 DestroyOutputDeviceChangeWithInfoCallback();
1154 return SUCCESS;
1155 }
1156
AudioRendererStateChangeCallbackImpl()1157 AudioRendererStateChangeCallbackImpl::AudioRendererStateChangeCallbackImpl()
1158 {
1159 AUDIO_INFO_LOG("AudioRendererStateChangeCallbackImpl instance create");
1160 }
1161
~AudioRendererStateChangeCallbackImpl()1162 AudioRendererStateChangeCallbackImpl::~AudioRendererStateChangeCallbackImpl()
1163 {
1164 AUDIO_INFO_LOG("AudioRendererStateChangeCallbackImpl instance destory");
1165 }
1166
SaveCallback(const std::weak_ptr<AudioRendererDeviceChangeCallback> & callback)1167 void AudioRendererStateChangeCallbackImpl::SaveCallback(
1168 const std::weak_ptr<AudioRendererDeviceChangeCallback> &callback)
1169 {
1170 callback_ = callback;
1171 }
1172
setAudioRendererObj(AudioRendererPrivate * rendererObj)1173 void AudioRendererStateChangeCallbackImpl::setAudioRendererObj(AudioRendererPrivate *rendererObj)
1174 {
1175 std::lock_guard<std::mutex> lock(mutex_);
1176 renderer_ = rendererObj;
1177 }
1178
UnsetAudioRendererObj()1179 void AudioRendererStateChangeCallbackImpl::UnsetAudioRendererObj()
1180 {
1181 std::lock_guard<std::mutex> lock(mutex_);
1182 renderer_ = nullptr;
1183 }
1184
SetSwitchInfo(IAudioStream::SwitchInfo info,std::shared_ptr<IAudioStream> audioStream)1185 void AudioRendererPrivate::SetSwitchInfo(IAudioStream::SwitchInfo info, std::shared_ptr<IAudioStream> audioStream)
1186 {
1187 CHECK_AND_RETURN_LOG(audioStream, "stream is nullptr");
1188
1189 audioStream->SetStreamTrackerState(info.streamTrackerRegistered);
1190 audioStream->SetApplicationCachePath(info.cachePath);
1191 audioStream->SetClientID(info.clientPid, info.clientUid, appInfo_.appTokenId);
1192 audioStream->SetPrivacyType(info.privacyType);
1193 audioStream->SetRendererInfo(info.rendererInfo);
1194 audioStream->SetCapturerInfo(info.capturerInfo);
1195 audioStream->SetAudioStreamInfo(info.params, rendererProxyObj_);
1196 audioStream->SetRenderMode(info.renderMode);
1197 audioStream->SetAudioEffectMode(info.effectMode);
1198 audioStream->SetVolume(info.volume);
1199
1200 // set callback
1201 if ((info.renderPositionCb != nullptr) && (info.frameMarkPosition > 0)) {
1202 audioStream->SetRendererPositionCallback(info.frameMarkPosition, info.renderPositionCb);
1203 }
1204
1205 if ((info.capturePositionCb != nullptr) && (info.frameMarkPosition > 0)) {
1206 audioStream->SetCapturerPositionCallback(info.frameMarkPosition, info.capturePositionCb);
1207 }
1208
1209 if ((info.renderPeriodPositionCb != nullptr) && (info.framePeriodNumber > 0)) {
1210 audioStream->SetRendererPeriodPositionCallback(info.framePeriodNumber, info.renderPeriodPositionCb);
1211 }
1212
1213 if ((info.capturePeriodPositionCb != nullptr) && (info.framePeriodNumber > 0)) {
1214 audioStream->SetCapturerPeriodPositionCallback(info.framePeriodNumber, info.capturePeriodPositionCb);
1215 }
1216
1217 audioStream->SetStreamCallback(info.audioStreamCallback);
1218 audioStream->SetRendererWriteCallback(info.rendererWriteCallback);
1219
1220 audioStream->SetRendererFirstFrameWritingCallback(info.rendererFirstFrameWritingCallback);
1221 }
1222
SwitchToTargetStream(IAudioStream::StreamClass targetClass)1223 bool AudioRendererPrivate::SwitchToTargetStream(IAudioStream::StreamClass targetClass)
1224 {
1225 std::lock_guard<std::mutex> lock(switchStreamMutex_);
1226 bool switchResult = false;
1227 if (audioStream_) {
1228 Trace trace("SwitchToTargetStream");
1229 isSwitching_ = true;
1230 RendererState previousState = GetStatus();
1231 if (previousState == RENDERER_RUNNING) {
1232 // stop old stream
1233 switchResult = audioStream_->StopAudioStream();
1234 CHECK_AND_RETURN_RET_LOG(switchResult, false, "StopAudioStream failed.");
1235 }
1236 // switch new stream
1237 IAudioStream::SwitchInfo info;
1238 audioStream_->GetSwitchInfo(info);
1239 std::shared_ptr<IAudioStream> newAudioStream = IAudioStream::GetPlaybackStream(targetClass, info.params,
1240 info.eStreamType, appInfo_.appPid);
1241 CHECK_AND_RETURN_RET_LOG(newAudioStream != nullptr, false, "SetParams GetPlayBackStream failed.");
1242 AUDIO_INFO_LOG("Get new stream success!");
1243
1244 // set new stream info
1245 SetSwitchInfo(info, newAudioStream);
1246
1247 // release old stream and restart audio stream
1248 switchResult = audioStream_->ReleaseAudioStream();
1249 CHECK_AND_RETURN_RET_LOG(switchResult, false, "release old stream failed.");
1250
1251 if (previousState == RENDERER_RUNNING) {
1252 // restart audio stream
1253 switchResult = newAudioStream->StartAudioStream();
1254 CHECK_AND_RETURN_RET_LOG(switchResult, false, "start new stream failed.");
1255 }
1256 audioStream_ = newAudioStream;
1257 isSwitching_ = false;
1258 switchResult= true;
1259 }
1260 return switchResult;
1261 }
1262
SwitchStream(bool isLowLatencyDevice)1263 void AudioRendererPrivate::SwitchStream(bool isLowLatencyDevice)
1264 {
1265 // switch stream for fast renderer only
1266 if (audioStream_ != nullptr && isFastRenderer_ && !isSwitching_) {
1267 bool needSwitch = false;
1268 IAudioStream::StreamClass currentClass = audioStream_->GetStreamClass();
1269 IAudioStream::StreamClass targetClass = IAudioStream::PA_STREAM;
1270 if (currentClass == IAudioStream::FAST_STREAM && !isLowLatencyDevice) {
1271 needSwitch = true;
1272 rendererInfo_.rendererFlags = 0; // Normal renderer type
1273 targetClass = IAudioStream::PA_STREAM;
1274 }
1275 if (currentClass == IAudioStream::PA_STREAM && isLowLatencyDevice) {
1276 needSwitch = true;
1277 rendererInfo_.rendererFlags = STREAM_FLAG_FAST;
1278 targetClass = IAudioStream::FAST_STREAM;
1279 }
1280 if (needSwitch) {
1281 if (!SwitchToTargetStream(targetClass) && audioRendererErrorCallback_) {
1282 audioRendererErrorCallback_->OnError(ERROR_SYSTEM);
1283 }
1284 } else {
1285 AUDIO_WARNING_LOG("need not SwitchStream!");
1286 }
1287 } else {
1288 AUDIO_DEBUG_LOG("Do not SwitchStream , is low latency renderer: %{public}d!", isFastRenderer_);
1289 }
1290 }
1291
IsDeviceChanged(DeviceInfo & newDeviceInfo)1292 bool AudioRendererPrivate::IsDeviceChanged(DeviceInfo &newDeviceInfo)
1293 {
1294 bool deviceUpdated = false;
1295 DeviceInfo deviceInfo = {};
1296
1297 int32_t ret = GetCurrentOutputDevices(deviceInfo);
1298 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, deviceUpdated,
1299 "GetCurrentOutputDevices failed");
1300
1301 AUDIO_INFO_LOG("newDeviceInfo type: %{public}d, currentDeviceInfo_ type: %{public}d ",
1302 deviceInfo.deviceType, currentDeviceInfo_.deviceType);
1303 if (currentDeviceInfo_.deviceType != deviceInfo.deviceType) {
1304 currentDeviceInfo_ = deviceInfo;
1305 newDeviceInfo = currentDeviceInfo_;
1306 deviceUpdated = true;
1307 }
1308 return deviceUpdated;
1309 }
1310
OnRendererStateChange(const std::vector<std::unique_ptr<AudioRendererChangeInfo>> & audioRendererChangeInfos)1311 void AudioRendererStateChangeCallbackImpl::OnRendererStateChange(
1312 const std::vector<std::unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos)
1313 {
1314 std::shared_ptr<AudioRendererDeviceChangeCallback> cb = callback_.lock();
1315 AUDIO_DEBUG_LOG("AudioRendererStateChangeCallbackImpl OnRendererStateChange");
1316 DeviceInfo deviceInfo = {};
1317 bool isDevicedChanged = false;
1318 {
1319 std::lock_guard<std::mutex> lock(mutex_);
1320 if (renderer_ == nullptr) {
1321 return;
1322 }
1323 isDevicedChanged = renderer_->IsDeviceChanged(deviceInfo);
1324 if (isDevicedChanged) {
1325 if (deviceInfo.deviceType != DEVICE_TYPE_NONE && deviceInfo.deviceType != DEVICE_TYPE_INVALID) {
1326 // switch audio channel
1327 renderer_->SwitchStream(deviceInfo.isLowLatencyDevice);
1328 }
1329 CHECK_AND_RETURN_LOG(cb != nullptr, "OnStateChange cb == nullptr.");
1330 }
1331 }
1332
1333 if (isDevicedChanged) {
1334 cb->OnStateChange(deviceInfo);
1335 }
1336 }
1337
OnOutputDeviceChangeWithInfo(const uint32_t sessionId,const DeviceInfo & deviceInfo,const AudioStreamDeviceChangeReason reason)1338 void OutputDeviceChangeWithInfoCallbackImpl::OnOutputDeviceChangeWithInfo(
1339 const uint32_t sessionId, const DeviceInfo &deviceInfo, const AudioStreamDeviceChangeReason reason)
1340 {
1341 AUDIO_INFO_LOG("OnRendererStateChange");
1342 std::shared_ptr<AudioRendererOutputDeviceChangeCallback> cb = callback_.lock();
1343
1344 if (cb != nullptr) {
1345 cb->OnOutputDeviceChange(deviceInfo, reason);
1346 }
1347 }
1348
GetAudioEffectMode() const1349 AudioEffectMode AudioRendererPrivate::GetAudioEffectMode() const
1350 {
1351 return audioStream_->GetAudioEffectMode();
1352 }
1353
GetFramesWritten() const1354 int64_t AudioRendererPrivate::GetFramesWritten() const
1355 {
1356 return audioStream_->GetFramesWritten();
1357 }
1358
SetAudioEffectMode(AudioEffectMode effectMode) const1359 int32_t AudioRendererPrivate::SetAudioEffectMode(AudioEffectMode effectMode) const
1360 {
1361 return audioStream_->SetAudioEffectMode(effectMode);
1362 }
1363
SetSelfRendererStateCallback()1364 void AudioRendererPrivate::SetSelfRendererStateCallback()
1365 {
1366 int32_t tmp = GetCurrentOutputDevices(currentDeviceInfo_);
1367 CHECK_AND_RETURN_LOG(tmp == SUCCESS, "get current device info failed");
1368
1369 int32_t clientPid = getpid();
1370 if (!audioDeviceChangeCallback_) {
1371 audioDeviceChangeCallback_ = std::make_shared<AudioRendererStateChangeCallbackImpl>();
1372 CHECK_AND_RETURN_LOG(audioDeviceChangeCallback_, "Memory Allocation Failed !!");
1373 }
1374
1375 int32_t ret = AudioPolicyManager::GetInstance().RegisterAudioRendererEventListener(clientPid,
1376 audioDeviceChangeCallback_);
1377 CHECK_AND_RETURN_LOG(ret == 0, "RegisterAudioRendererEventListener failed");
1378
1379 audioDeviceChangeCallback_->setAudioRendererObj(this);
1380 AUDIO_INFO_LOG("RegisterAudioRendererEventListener successful!");
1381 }
1382
SetVolumeWithRamp(float volume,int32_t duration)1383 int32_t AudioRendererPrivate::SetVolumeWithRamp(float volume, int32_t duration)
1384 {
1385 return audioStream_->SetVolumeWithRamp(volume, duration);
1386 }
1387
SetPreferredFrameSize(int32_t frameSize)1388 void AudioRendererPrivate::SetPreferredFrameSize(int32_t frameSize)
1389 {
1390 audioStream_->SetPreferredFrameSize(frameSize);
1391 }
1392
GetAudioInterrupt(AudioInterrupt & audioInterrupt)1393 void AudioRendererPrivate::GetAudioInterrupt(AudioInterrupt &audioInterrupt)
1394 {
1395 audioInterrupt = audioInterrupt_;
1396 }
1397
1398
RegisterRendererPolicyServiceDiedCallback()1399 int32_t AudioRendererPrivate::RegisterRendererPolicyServiceDiedCallback()
1400 {
1401 AUDIO_DEBUG_LOG("RegisterRendererPolicyServiceDiedCallback");
1402 if (!audioPolicyServiceDiedCallback_) {
1403 audioPolicyServiceDiedCallback_ = std::make_shared<RendererPolicyServiceDiedCallback>();
1404 if (!audioPolicyServiceDiedCallback_) {
1405 AUDIO_ERR_LOG("Memory allocation failed!!");
1406 return ERROR;
1407 }
1408 audioStream_->RegisterRendererOrCapturerPolicyServiceDiedCB(audioPolicyServiceDiedCallback_);
1409 audioPolicyServiceDiedCallback_->SetAudioRendererObj(this);
1410 audioPolicyServiceDiedCallback_->SetAudioInterrupt(audioInterrupt_);
1411 }
1412 return SUCCESS;
1413 }
1414
RemoveRendererPolicyServiceDiedCallback() const1415 int32_t AudioRendererPrivate::RemoveRendererPolicyServiceDiedCallback() const
1416 {
1417 AUDIO_DEBUG_LOG("RemoveRendererPolicyServiceDiedCallback");
1418 if (audioPolicyServiceDiedCallback_) {
1419 int32_t ret = audioStream_->RemoveRendererOrCapturerPolicyServiceDiedCB();
1420 if (ret != 0) {
1421 AUDIO_ERR_LOG("RemoveRendererPolicyServiceDiedCallback failed");
1422 return ERROR;
1423 }
1424 }
1425 return SUCCESS;
1426 }
1427
RendererPolicyServiceDiedCallback()1428 RendererPolicyServiceDiedCallback::RendererPolicyServiceDiedCallback()
1429 {
1430 AUDIO_DEBUG_LOG("RendererPolicyServiceDiedCallback create");
1431 }
1432
~RendererPolicyServiceDiedCallback()1433 RendererPolicyServiceDiedCallback::~RendererPolicyServiceDiedCallback()
1434 {
1435 AUDIO_DEBUG_LOG("RendererPolicyServiceDiedCallback destroy");
1436 if (restoreThread_ != nullptr && restoreThread_->joinable()) {
1437 restoreThread_->join();
1438 restoreThread_.reset();
1439 restoreThread_ = nullptr;
1440 }
1441 }
1442
SetAudioRendererObj(AudioRendererPrivate * rendererObj)1443 void RendererPolicyServiceDiedCallback::SetAudioRendererObj(AudioRendererPrivate *rendererObj)
1444 {
1445 renderer_ = rendererObj;
1446 }
1447
SetAudioInterrupt(AudioInterrupt & audioInterrupt)1448 void RendererPolicyServiceDiedCallback::SetAudioInterrupt(AudioInterrupt &audioInterrupt)
1449 {
1450 audioInterrupt_ = audioInterrupt;
1451 }
1452
OnAudioPolicyServiceDied()1453 void RendererPolicyServiceDiedCallback::OnAudioPolicyServiceDied()
1454 {
1455 AUDIO_INFO_LOG("RendererPolicyServiceDiedCallback::OnAudioPolicyServiceDied");
1456 if (restoreThread_ != nullptr) {
1457 restoreThread_->detach();
1458 }
1459 restoreThread_ = std::make_unique<std::thread>(&RendererPolicyServiceDiedCallback::RestoreTheadLoop, this);
1460 pthread_setname_np(restoreThread_->native_handle(), "OS_ARPSRestore");
1461 }
1462
RestoreTheadLoop()1463 void RendererPolicyServiceDiedCallback::RestoreTheadLoop()
1464 {
1465 int32_t tryCounter = 5;
1466 uint32_t sleepTime = 300000;
1467 bool result = false;
1468 int32_t ret = -1;
1469 while (!result && tryCounter-- > 0) {
1470 usleep(sleepTime);
1471 if (renderer_ == nullptr || renderer_->audioStream_ == nullptr ||
1472 renderer_->abortRestore_) {
1473 AUDIO_INFO_LOG("RendererPolicyServiceDiedCallback RestoreTheadLoop abort restore");
1474 break;
1475 }
1476 result = renderer_->audioStream_->RestoreAudioStream();
1477 if (!result) {
1478 AUDIO_ERR_LOG("RestoreAudioStream Failed, %{public}d attempts remaining", tryCounter);
1479 continue;
1480 } else {
1481 renderer_->abortRestore_ = false;
1482 }
1483 if (renderer_->GetStatus() == RENDERER_RUNNING) {
1484 renderer_->GetAudioInterrupt(audioInterrupt_);
1485 ret = AudioPolicyManager::GetInstance().ActivateAudioInterrupt(audioInterrupt_);
1486 if (ret != SUCCESS) {
1487 AUDIO_ERR_LOG("AudioRenderer::ActivateAudioInterrupt Failed");
1488 }
1489 }
1490 }
1491 }
1492
SetSpeed(float speed)1493 int32_t AudioRendererPrivate::SetSpeed(float speed)
1494 {
1495 AUDIO_INFO_LOG("set speed %{public}f", speed);
1496 CHECK_AND_RETURN_RET_LOG((speed >= MIN_STREAM_SPEED_LEVEL) && (speed <= MAX_STREAM_SPEED_LEVEL),
1497 ERR_INVALID_PARAM, "invaild speed index");
1498 #ifdef SONIC_ENABLE
1499 audioStream_->SetSpeed(speed);
1500 #endif
1501 speed_ = speed;
1502 return SUCCESS;
1503 }
1504
GetSpeed()1505 float AudioRendererPrivate::GetSpeed()
1506 {
1507 #ifdef SONIC_ENABLE
1508 return audioStream_->GetSpeed();
1509 #endif
1510 return speed_;
1511 }
1512
IsFastRenderer()1513 bool AudioRendererPrivate::IsFastRenderer()
1514 {
1515 return isFastRenderer_;
1516 }
1517 } // namespace AudioStandard
1518 } // namespace OHOS
1519