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 #ifndef AUDIO_RENDERER_PRIVATE_H 17 #define AUDIO_RENDERER_PRIVATE_H 18 19 #include <shared_mutex> 20 #include <optional> 21 22 #include "securec.h" 23 24 #include "audio_interrupt_callback.h" 25 #include "audio_concurrency_callback.h" 26 #include "audio_renderer.h" 27 #include "audio_renderer_proxy_obj.h" 28 #include "audio_utils.h" 29 #include "i_audio_stream.h" 30 31 namespace OHOS { 32 namespace AudioStandard { 33 constexpr uint32_t INVALID_SESSION_ID = static_cast<uint32_t>(-1); 34 class RendererPolicyServiceDiedCallback; 35 class OutputDeviceChangeWithInfoCallbackImpl; 36 class AudioRendererConcurrencyCallbackImpl; 37 38 class AudioRendererPrivate : public AudioRenderer, public std::enable_shared_from_this<AudioRendererPrivate> { 39 public: 40 int32_t GetFrameCount(uint32_t &frameCount) const override; 41 int32_t GetLatency(uint64_t &latency) const override; 42 void SetAudioPrivacyType(AudioPrivacyType privacyType) override; 43 AudioPrivacyType GetAudioPrivacyType() override; 44 int32_t SetParams(const AudioRendererParams params) override; 45 int32_t GetParams(AudioRendererParams ¶ms) const override; 46 int32_t GetRendererInfo(AudioRendererInfo &rendererInfo) const override; 47 int32_t GetStreamInfo(AudioStreamInfo &streamInfo) const override; 48 bool Start(StateChangeCmdType cmdType = CMD_FROM_CLIENT) override; 49 int32_t Write(uint8_t *buffer, size_t bufferSize) override; 50 int32_t Write(uint8_t *pcmBuffer, size_t pcmSize, uint8_t *metaBuffer, size_t metaSize) override; 51 RendererState GetStatus() const override; 52 bool GetAudioTime(Timestamp ×tamp, Timestamp::Timestampbase base) const override; 53 bool GetAudioPosition(Timestamp ×tamp, Timestamp::Timestampbase base) override; 54 bool Drain() const override; 55 bool PauseTransitent(StateChangeCmdType cmdType = CMD_FROM_CLIENT) override; 56 bool Pause(StateChangeCmdType cmdType = CMD_FROM_CLIENT) override; 57 bool Mute(StateChangeCmdType cmdType = CMD_FROM_CLIENT) const override; 58 bool Unmute(StateChangeCmdType cmdType = CMD_FROM_CLIENT) const override; 59 bool Stop() override; 60 bool Flush() const override; 61 bool Release() override; 62 int32_t GetBufferSize(size_t &bufferSize) const override; 63 int32_t GetAudioStreamId(uint32_t &sessionID) const override; 64 int32_t SetAudioRendererDesc(AudioRendererDesc audioRendererDesc) override; 65 int32_t SetStreamType(AudioStreamType audioStreamType) override; 66 int32_t SetVolume(float volume) const override; 67 int32_t SetVolumeMode(int32_t mode) override; 68 float GetVolume() const override; 69 int32_t SetRenderRate(AudioRendererRate renderRate) const override; 70 AudioRendererRate GetRenderRate() const override; 71 int32_t SetRendererSamplingRate(uint32_t sampleRate) const override; 72 uint32_t GetRendererSamplingRate() const override; 73 int32_t SetRendererCallback(const std::shared_ptr<AudioRendererCallback> &callback) override; 74 int32_t SetRendererPositionCallback(int64_t markPosition, 75 const std::shared_ptr<RendererPositionCallback> &callback) override; 76 void UnsetRendererPositionCallback() override; 77 int32_t SetRendererPeriodPositionCallback(int64_t frameNumber, 78 const std::shared_ptr<RendererPeriodPositionCallback> &callback) override; 79 void UnsetRendererPeriodPositionCallback() override; 80 int32_t SetBufferDuration(uint64_t bufferDuration) const override; 81 int32_t SetRenderMode(AudioRenderMode renderMode) override; 82 AudioRenderMode GetRenderMode() const override; 83 int32_t SetRendererWriteCallback(const std::shared_ptr<AudioRendererWriteCallback> &callback) override; 84 int32_t SetRendererFirstFrameWritingCallback( 85 const std::shared_ptr<AudioRendererFirstFrameWritingCallback> &callback) override; 86 void SetPreferredFrameSize(int32_t frameSize) override; 87 int32_t GetBufferDesc(BufferDesc &bufDesc) override; 88 int32_t Enqueue(const BufferDesc &bufDesc) override; 89 int32_t Clear() const override; 90 int32_t GetBufQueueState(BufferQueueState &bufState) const override; 91 void SetInterruptMode(InterruptMode mode) override; 92 int32_t SetParallelPlayFlag(bool parallelPlayFlag) override; 93 int32_t SetLowPowerVolume(float volume) const override; 94 float GetLowPowerVolume() const override; 95 int32_t SetOffloadAllowed(bool isAllowed) override; 96 int32_t SetOffloadMode(int32_t state, bool isAppBack) const override; 97 int32_t UnsetOffloadMode() const override; 98 float GetSingleStreamVolume() const override; 99 float GetMinStreamVolume() const override; 100 float GetMaxStreamVolume() const override; 101 int32_t GetCurrentOutputDevices(AudioDeviceDescriptor &deviceInfo) const override; 102 uint32_t GetUnderflowCount() const override; 103 IAudioStream::StreamClass GetTargetStreamClass(int32_t streamFlag); 104 105 int32_t RegisterOutputDeviceChangeWithInfoCallback( 106 const std::shared_ptr<AudioRendererOutputDeviceChangeCallback> &callback) override; 107 int32_t UnregisterOutputDeviceChangeWithInfoCallback() override; 108 int32_t UnregisterOutputDeviceChangeWithInfoCallback( 109 const std::shared_ptr<AudioRendererOutputDeviceChangeCallback> &callback) override; 110 int32_t RegisterAudioPolicyServerDiedCb(const int32_t clientPid, 111 const std::shared_ptr<AudioRendererPolicyServiceDiedCallback> &callback) override; 112 int32_t UnregisterAudioPolicyServerDiedCb(const int32_t clientPid) override; 113 AudioEffectMode GetAudioEffectMode() const override; 114 int64_t GetFramesWritten() const override; 115 int32_t SetAudioEffectMode(AudioEffectMode effectMode) const override; 116 int32_t SetChannelBlendMode(ChannelBlendMode blendMode) override; 117 void SetAudioRendererErrorCallback(std::shared_ptr<AudioRendererErrorCallback> errorCallback) override; 118 int32_t SetVolumeWithRamp(float volume, int32_t duration) override; 119 120 int32_t RegisterRendererPolicyServiceDiedCallback(); 121 int32_t RemoveRendererPolicyServiceDiedCallback(); 122 123 void GetAudioInterrupt(AudioInterrupt &audioInterrupt); 124 void SetAudioInterrupt(const AudioInterrupt &audioInterrupt); 125 126 bool IsOffloadEnable() override; 127 128 int32_t SetSpeed(float speed) override; 129 float GetSpeed() override; 130 bool IsFastRenderer() override; 131 void ConcedeStream(); 132 133 void SetSilentModeAndMixWithOthers(bool on) override; 134 bool GetSilentModeAndMixWithOthers() override; 135 136 void EnableVoiceModemCommunicationStartStream(bool enable) override; 137 138 bool IsNoStreamRenderer() const override; 139 void RestoreAudioInLoop(bool &restoreResult, int32_t &tryCounter); 140 141 int64_t GetSourceDuration() const override; 142 void SetSourceDuration(int64_t duration) override; 143 144 int32_t SetDefaultOutputDevice(DeviceType deviceType) override; 145 int32_t GetAudioTimestampInfo(Timestamp ×tamp, Timestamp::Timestampbase base) const override; 146 ConvertToAudioStreamParams(const AudioRendererParams params)147 static inline AudioStreamParams ConvertToAudioStreamParams(const AudioRendererParams params) 148 { 149 AudioStreamParams audioStreamParams; 150 151 audioStreamParams.format = params.sampleFormat; 152 audioStreamParams.samplingRate = params.sampleRate; 153 audioStreamParams.channels = params.channelCount; 154 audioStreamParams.encoding = params.encodingType; 155 audioStreamParams.channelLayout = params.channelLayout; 156 157 return audioStreamParams; 158 } 159 160 AudioPrivacyType privacyType_ = PRIVACY_TYPE_PUBLIC; 161 AudioRendererInfo rendererInfo_ = {CONTENT_TYPE_UNKNOWN, STREAM_USAGE_MUSIC, 0}; 162 AudioSessionStrategy strategy_ = { AudioConcurrencyMode::INVALID }; 163 AudioSessionStrategy originalStrategy_ = { AudioConcurrencyMode::INVALID }; 164 std::shared_ptr<IAudioStream> audioStream_; 165 bool abortRestore_ = false; 166 mutable bool isStillMuted_ = false; 167 168 explicit AudioRendererPrivate(AudioStreamType audioStreamType, const AppInfo &appInfo, bool createStream = true); 169 170 ~AudioRendererPrivate(); 171 172 AudioRendererPrivate(const AudioRendererPrivate &) = delete; 173 AudioRendererPrivate &operator=(const AudioRendererPrivate &) = delete; 174 AudioRendererPrivate(AudioRendererPrivate &&) = delete; 175 AudioRendererPrivate &operator=(AudioRendererPrivate &&) = delete; 176 protected: 177 178 private: 179 int32_t CheckAndRestoreAudioRenderer(std::string callingFunc); 180 int32_t PrepareAudioStream(const AudioStreamParams &audioStreamParams, 181 const AudioStreamType &audioStreamType, IAudioStream::StreamClass &streamClass); 182 int32_t InitAudioInterruptCallback(bool isRestoreAudio = false); 183 int32_t InitOutputDeviceChangeCallback(); 184 int32_t InitAudioStream(AudioStreamParams audioStreamParams); 185 bool SetSwitchInfo(IAudioStream::SwitchInfo info, std::shared_ptr<IAudioStream> audioStream); 186 void UpdateRendererAudioStream(const std::shared_ptr<IAudioStream> &newAudioStream); 187 void InitSwitchInfo(IAudioStream::StreamClass targetClass, IAudioStream::SwitchInfo &info); 188 bool SwitchToTargetStream(IAudioStream::StreamClass targetClass, RestoreInfo restoreInfo); 189 bool FinishOldStream(IAudioStream::StreamClass targetClass, RestoreInfo restoreInfo, RendererState previousState, 190 IAudioStream::SwitchInfo &info); 191 bool GenerateNewStream(IAudioStream::StreamClass targetClass, RestoreInfo restoreInfo, RendererState previousState, 192 IAudioStream::SwitchInfo &info); 193 bool ContinueAfterConcede(IAudioStream::StreamClass &targetClass, RestoreInfo restoreInfo); 194 bool ContinueAfterSplit(RestoreInfo restoreInfo); 195 bool InitTargetStream(IAudioStream::SwitchInfo &info, std::shared_ptr<IAudioStream> &audioStream); 196 void HandleAudioInterruptWhenServerDied(); 197 void WriteSwitchStreamLogMsg(); 198 void InitLatencyMeasurement(const AudioStreamParams &audioStreamParams); 199 void MockPcmData(uint8_t *buffer, size_t bufferSize) const; 200 void ActivateAudioConcurrency(const AudioStreamParams &audioStreamParams, 201 const AudioStreamType &audioStreamType, IAudioStream::StreamClass &streamClass); 202 void WriteUnderrunEvent() const; 203 IAudioStream::StreamClass GetPreferredStreamClass(AudioStreamParams audioStreamParams); 204 bool IsDirectVoipParams(const AudioStreamParams &audioStreamParams); 205 void UpdateAudioInterruptStrategy(float volume) const; 206 bool IsAllowedStartBackgroud(); 207 bool GetStartStreamResult(StateChangeCmdType cmdType); 208 void UpdateFramesWritten(); 209 RendererState GetStatusInner(); 210 void SetAudioPrivacyTypeInner(AudioPrivacyType privacyType); 211 int32_t GetAudioStreamIdInner(uint32_t &sessionID) const; 212 float GetVolumeInner() const; 213 uint32_t GetUnderflowCountInner() const; 214 int32_t UnsetOffloadModeInner() const; 215 std::shared_ptr<IAudioStream> GetInnerStream() const; 216 217 std::shared_ptr<AudioInterruptCallback> audioInterruptCallback_ = nullptr; 218 std::shared_ptr<AudioStreamCallback> audioStreamCallback_ = nullptr; 219 AppInfo appInfo_ = {}; 220 AudioInterrupt audioInterrupt_ = {STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, 221 {AudioStreamType::STREAM_DEFAULT, SourceType::SOURCE_TYPE_INVALID, true}, 0}; 222 uint32_t sessionID_ = INVALID_SESSION_ID; 223 std::shared_ptr<AudioRendererProxyObj> rendererProxyObj_; 224 FILE *dumpFile_ = nullptr; 225 std::shared_ptr<AudioRendererErrorCallback> audioRendererErrorCallback_ = nullptr; 226 std::mutex audioRendererErrCallbackMutex_; 227 std::shared_ptr<OutputDeviceChangeWithInfoCallbackImpl> outputDeviceChangeCallback_ = nullptr; 228 mutable std::shared_ptr<RendererPolicyServiceDiedCallback> audioPolicyServiceDiedCallback_ = nullptr; 229 std::atomic<bool> isFastRenderer_ = false; 230 bool latencyMeasEnabled_ = false; 231 std::shared_ptr<AudioLatencyMeasurement> latencyMeasurement_ = nullptr; 232 bool isSwitching_ = false; 233 mutable std::shared_mutex rendererMutex_; 234 mutable std::shared_mutex streamMutex_; 235 mutable AudioRenderMode audioRenderMode_ = RENDER_MODE_NORMAL; 236 bool isFastVoipSupported_ = false; 237 bool isDirectVoipSupported_ = false; 238 bool isEnableVoiceModemCommunicationStartStream_ = false; 239 RendererState state_ = RENDERER_INVALID; 240 241 std::optional<float> speed_ = std::nullopt; 242 243 std::shared_ptr<AudioRendererPolicyServiceDiedCallback> policyServiceDiedCallback_ = nullptr; 244 std::mutex policyServiceDiedCallbackMutex_; 245 246 std::vector<uint32_t> usedSessionId_ = {}; 247 std::mutex silentModeAndMixWithOthersMutex_; 248 std::mutex setStreamCallbackMutex_; 249 std::mutex setParamsMutex_; 250 std::mutex rendererPolicyServiceDiedCbMutex_; 251 int64_t framesAlreadyWritten_ = 0; 252 int64_t sourceDuration_ = -1; 253 }; 254 255 class AudioRendererInterruptCallbackImpl : public AudioInterruptCallback { 256 public: 257 explicit AudioRendererInterruptCallbackImpl(const std::shared_ptr<IAudioStream> &audioStream, 258 const AudioInterrupt &audioInterrupt); 259 virtual ~AudioRendererInterruptCallbackImpl(); 260 261 void OnInterrupt(const InterruptEventInternal &interruptEvent) override; 262 void SaveCallback(const std::weak_ptr<AudioRendererCallback> &callback); 263 void UpdateAudioStream(const std::shared_ptr<IAudioStream> &audioStream); 264 void StartSwitch(); 265 void FinishSwitch(); 266 private: 267 void NotifyEvent(const InterruptEvent &interruptEvent); 268 InterruptCallbackEvent HandleAndNotifyForcedEvent(const InterruptEventInternal &interruptEvent); 269 void NotifyForcedEvent(const InterruptEventInternal &interruptEvent); 270 void NotifyForcePausedToResume(const InterruptEventInternal &interruptEvent); 271 bool HandleForceDucking(const InterruptEventInternal &interruptEvent); 272 std::shared_ptr<IAudioStream> audioStream_; 273 std::weak_ptr<AudioRendererCallback> callback_; 274 std::shared_ptr<AudioRendererCallback> cb_; 275 AudioInterrupt audioInterrupt_ {}; 276 bool isForcePaused_ = false; 277 bool isForceDucked_ = false; 278 uint32_t sessionID_ = INVALID_SESSION_ID; 279 std::mutex mutex_; 280 bool switching_ = false; 281 std::condition_variable switchStreamCv_; 282 }; 283 284 class AudioStreamCallbackRenderer : public AudioStreamCallback { 285 public: 286 AudioStreamCallbackRenderer(std::weak_ptr<AudioRendererPrivate> renderer); 287 virtual ~AudioStreamCallbackRenderer() = default; 288 289 void OnStateChange(const State state, const StateChangeCmdType cmdType = CMD_FROM_CLIENT) override; 290 void SaveCallback(const std::weak_ptr<AudioRendererCallback> &callback); 291 private: 292 std::weak_ptr<AudioRendererCallback> callback_; 293 std::weak_ptr<AudioRendererPrivate> renderer_; 294 }; 295 296 class OutputDeviceChangeWithInfoCallbackImpl : public DeviceChangeWithInfoCallback { 297 public: 298 OutputDeviceChangeWithInfoCallbackImpl() = default; 299 virtual ~OutputDeviceChangeWithInfoCallbackImpl() = default; 300 301 void OnDeviceChangeWithInfo(const uint32_t sessionId, const AudioDeviceDescriptor &deviceInfo, 302 const AudioStreamDeviceChangeReasonExt reason) override; 303 304 void OnRecreateStreamEvent(const uint32_t sessionId, const int32_t streamFlag, 305 const AudioStreamDeviceChangeReasonExt reason) override; 306 SaveCallback(const std::shared_ptr<AudioRendererOutputDeviceChangeCallback> & callback)307 void SaveCallback(const std::shared_ptr<AudioRendererOutputDeviceChangeCallback> &callback) 308 { 309 std::lock_guard<std::mutex> lock(callbackMutex_); 310 callbacks_.push_back(callback); 311 } 312 RemoveCallback()313 void RemoveCallback() 314 { 315 std::lock_guard<std::mutex> lock(callbackMutex_); 316 callbacks_.clear(); 317 } 318 RemoveCallback(const std::shared_ptr<AudioRendererOutputDeviceChangeCallback> & callback)319 void RemoveCallback(const std::shared_ptr<AudioRendererOutputDeviceChangeCallback> &callback) 320 { 321 std::lock_guard<std::mutex> lock(callbackMutex_); 322 callbacks_.erase(std::remove(callbacks_.begin(), callbacks_.end(), callback), callbacks_.end()); 323 } 324 SetAudioRendererObj(std::weak_ptr<AudioRendererPrivate> rendererObj)325 void SetAudioRendererObj(std::weak_ptr<AudioRendererPrivate> rendererObj) 326 { 327 std::lock_guard<std::mutex> lock(audioRendererObjMutex_); 328 renderer_ = rendererObj; 329 } 330 UnsetAudioRendererObj()331 void UnsetAudioRendererObj() 332 { 333 std::lock_guard<std::mutex> lock(audioRendererObjMutex_); 334 renderer_.reset(); 335 } 336 private: 337 std::vector<std::shared_ptr<AudioRendererOutputDeviceChangeCallback>> callbacks_; 338 std::weak_ptr<AudioRendererPrivate> renderer_; 339 std::mutex audioRendererObjMutex_; 340 std::mutex callbackMutex_; 341 }; 342 343 class RendererPolicyServiceDiedCallback : public AudioStreamPolicyServiceDiedCallback, 344 public std::enable_shared_from_this<RendererPolicyServiceDiedCallback> { 345 public: 346 RendererPolicyServiceDiedCallback(); 347 virtual ~RendererPolicyServiceDiedCallback(); 348 void SetAudioRendererObj(std::weak_ptr<AudioRendererPrivate> rendererObj); 349 void SetAudioInterrupt(AudioInterrupt &audioInterrupt); 350 void OnAudioPolicyServiceDied() override; 351 352 private: 353 std::weak_ptr<AudioRendererPrivate> renderer_; 354 AudioInterrupt audioInterrupt_; 355 void RestoreTheadLoop(); 356 357 std::atomic<int32_t> taskCount_ = 0; 358 }; 359 360 class AudioRendererConcurrencyCallbackImpl : public AudioConcurrencyCallback { 361 public: 362 explicit AudioRendererConcurrencyCallbackImpl(); 363 virtual ~AudioRendererConcurrencyCallbackImpl(); 364 void OnConcedeStream() override; SetAudioRendererObj(AudioRendererPrivate * rendererObj)365 void SetAudioRendererObj(AudioRendererPrivate *rendererObj) 366 { 367 std::lock_guard<std::mutex> lock(mutex_); 368 renderer_ = rendererObj; 369 } UnsetAudioRendererObj()370 void UnsetAudioRendererObj() 371 { 372 std::lock_guard<std::mutex> lock(mutex_); 373 renderer_ = nullptr; 374 } 375 private: 376 AudioRendererPrivate *renderer_ = nullptr; 377 std::mutex mutex_; 378 }; 379 } // namespace AudioStandard 380 } // namespace OHOS 381 #endif // AUDIO_RENDERER_PRIVATE_H 382