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