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(AudioDeviceDescriptor &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 bool IsOffloadEnable() override; 124 125 int32_t SetSpeed(float speed) override; 126 float GetSpeed() override; 127 #ifdef SONIC_ENABLE 128 int32_t ChangeSpeed(uint8_t *buffer, int32_t bufferSize); 129 int32_t ChangeSpeedFor8Bit(uint8_t *buffer, int32_t bufferSize, 130 std::unique_ptr<uint8_t []> &outBuffer, int32_t &outBufferSize); 131 int32_t ChangeSpeedFor16Bit(uint8_t *buffer, int32_t bufferSize, 132 std::unique_ptr<uint8_t []> &outBuffer, int32_t &outBufferSize); 133 int32_t ChangeSpeedFor24Bit(uint8_t *buffer, int32_t bufferSize, 134 std::unique_ptr<uint8_t []> &outBuffer, int32_t &outBufferSize); 135 int32_t ChangeSpeedFor32Bit(uint8_t *buffer, int32_t bufferSize, 136 std::unique_ptr<uint8_t []> &outBuffer, int32_t &outBufferSize); 137 int32_t ChangeSpeedForFloat(float *buffer, int32_t bufferSize, float* outBuffer, int32_t &outBufferSize); 138 int32_t WriteSpeedBuffer(int32_t bufferSize, uint8_t *speedBuffer, size_t speedBufferSize); 139 #endif 140 void ConcedeStream(); 141 142 void SetSilentModeAndMixWithOthers(bool on) override; 143 bool GetSilentModeAndMixWithOthers() override; 144 145 void EnableVoiceModemCommunicationStartStream(bool enable) override; 146 147 bool IsNoStreamRenderer() const override; 148 void RestoreAudioInLoop(bool &restoreResult, int32_t &tryCounter); 149 150 int32_t SetDefaultOutputDevice(DeviceType deviceType) override; 151 int32_t GetAudioTimestampInfo(Timestamp ×tamp, Timestamp::Timestampbase base) const override; 152 ConvertToAudioStreamParams(const AudioRendererParams params)153 static inline AudioStreamParams ConvertToAudioStreamParams(const AudioRendererParams params) 154 { 155 AudioStreamParams audioStreamParams; 156 157 audioStreamParams.format = params.sampleFormat; 158 audioStreamParams.samplingRate = params.sampleRate; 159 audioStreamParams.channels = params.channelCount; 160 audioStreamParams.encoding = params.encodingType; 161 audioStreamParams.channelLayout = params.channelLayout; 162 163 return audioStreamParams; 164 } 165 166 AudioPrivacyType privacyType_ = PRIVACY_TYPE_PUBLIC; 167 AudioRendererInfo rendererInfo_ = {CONTENT_TYPE_UNKNOWN, STREAM_USAGE_MUSIC, 0}; 168 AudioSessionStrategy strategy_ = { AudioConcurrencyMode::INVALID }; 169 AudioSessionStrategy originalStrategy_ = { AudioConcurrencyMode::INVALID }; 170 std::string cachePath_; 171 std::shared_ptr<IAudioStream> audioStream_; 172 bool abortRestore_ = false; 173 mutable bool isStillMuted_ = false; 174 175 explicit AudioRendererPrivate(AudioStreamType audioStreamType, const AppInfo &appInfo, bool createStream = true); 176 177 ~AudioRendererPrivate(); 178 179 protected: 180 // Method for switching between normal and low latency paths 181 void SwitchStream(bool isLowLatencyDevice, bool isHalNeedChange); 182 183 private: 184 int32_t PrepareAudioStream(const AudioStreamParams &audioStreamParams, 185 const AudioStreamType &audioStreamType, IAudioStream::StreamClass &streamClass); 186 int32_t InitAudioInterruptCallback(); 187 int32_t InitOutputDeviceChangeCallback(); 188 int32_t InitAudioStream(AudioStreamParams audioStreamParams); 189 int32_t InitAudioConcurrencyCallback(); 190 void SetSwitchInfo(IAudioStream::SwitchInfo info, std::shared_ptr<IAudioStream> audioStream); 191 void UpdateRendererAudioStream(const std::shared_ptr<IAudioStream> &audioStream); 192 void InitSwitchInfo(IAudioStream::StreamClass targetClass, IAudioStream::SwitchInfo &info); 193 bool SwitchToTargetStream(IAudioStream::StreamClass targetClass, uint32_t &newSessionId, 194 const AudioStreamDeviceChangeReasonExt reason); 195 void InitLatencyMeasurement(const AudioStreamParams &audioStreamParams); 196 void MockPcmData(uint8_t *buffer, size_t bufferSize) const; 197 void ActivateAudioConcurrency(const AudioStreamParams &audioStreamParams, 198 const AudioStreamType &audioStreamType, IAudioStream::StreamClass &streamClass); 199 void WriteUnderrunEvent() const; 200 IAudioStream::StreamClass GetPreferredStreamClass(AudioStreamParams audioStreamParams); 201 bool IsDirectVoipParams(const AudioStreamParams &audioStreamParams); 202 void UpdateAudioInterruptStrategy(float volume) const; 203 void WriteSwitchStreamLogMsg(); 204 205 std::shared_ptr<AudioInterruptCallback> audioInterruptCallback_ = nullptr; 206 std::shared_ptr<AudioStreamCallback> audioStreamCallback_ = nullptr; 207 std::shared_ptr<AudioRendererConcurrencyCallbackImpl> audioConcurrencyCallback_ = nullptr; 208 AppInfo appInfo_ = {}; 209 AudioInterrupt audioInterrupt_ = {STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, 210 {AudioStreamType::STREAM_DEFAULT, SourceType::SOURCE_TYPE_INVALID, true}, 0}; 211 uint32_t sessionID_ = INVALID_SESSION_ID; 212 std::shared_ptr<AudioRendererProxyObj> rendererProxyObj_; 213 FILE *dumpFile_ = nullptr; 214 std::shared_ptr<AudioRendererErrorCallback> audioRendererErrorCallback_ = nullptr; 215 std::mutex audioRendererErrCallbackMutex_; 216 std::shared_ptr<OutputDeviceChangeWithInfoCallbackImpl> outputDeviceChangeCallback_ = nullptr; 217 mutable std::shared_ptr<RendererPolicyServiceDiedCallback> audioPolicyServiceDiedCallback_ = nullptr; 218 std::atomic<bool> isFastRenderer_ = false; 219 bool latencyMeasEnabled_ = false; 220 std::shared_ptr<AudioLatencyMeasurement> latencyMeasurement_ = nullptr; 221 bool isSwitching_ = false; 222 mutable std::shared_mutex rendererMutex_; 223 mutable AudioRenderMode audioRenderMode_ = RENDER_MODE_NORMAL; 224 bool isFastVoipSupported_ = false; 225 bool isDirectVoipSupported_ = false; 226 bool isEnableVoiceModemCommunicationStartStream_ = false; 227 RendererState state_ = RENDERER_INVALID; 228 DeviceType selectedDefaultOutputDevice_ = DEVICE_TYPE_NONE; 229 230 float speed_ = 1.0; 231 232 std::shared_ptr<AudioRendererPolicyServiceDiedCallback> policyServiceDiedCallback_ = nullptr; 233 std::mutex policyServiceDiedCallbackMutex_; 234 235 std::vector<uint32_t> usedSessionId_ = {}; 236 std::mutex silentModeAndMixWithOthersMutex_; 237 std::mutex setStreamCallbackMutex_; 238 std::mutex setParamsMutex_; 239 std::mutex rendererPolicyServiceDiedCbMutex_; 240 int64_t framesAlreadyWritten_ = 0; 241 }; 242 243 class AudioRendererInterruptCallbackImpl : public AudioInterruptCallback { 244 public: 245 explicit AudioRendererInterruptCallbackImpl(const std::shared_ptr<IAudioStream> &audioStream, 246 const AudioInterrupt &audioInterrupt); 247 virtual ~AudioRendererInterruptCallbackImpl(); 248 249 void OnInterrupt(const InterruptEventInternal &interruptEvent) override; 250 void SaveCallback(const std::weak_ptr<AudioRendererCallback> &callback); 251 void UpdateAudioStream(const std::shared_ptr<IAudioStream> &audioStream); 252 private: 253 void NotifyEvent(const InterruptEvent &interruptEvent); 254 InterruptCallbackEvent HandleAndNotifyForcedEvent(const InterruptEventInternal &interruptEvent); 255 void NotifyForcedEvent(const InterruptEventInternal &interruptEvent); 256 void NotifyForcePausedToResume(const InterruptEventInternal &interruptEvent); 257 bool HandleForceDucking(const InterruptEventInternal &interruptEvent); 258 std::shared_ptr<IAudioStream> audioStream_; 259 std::weak_ptr<AudioRendererCallback> callback_; 260 std::shared_ptr<AudioRendererCallback> cb_; 261 AudioInterrupt audioInterrupt_ {}; 262 bool isForcePaused_ = false; 263 bool isForceDucked_ = false; 264 uint32_t sessionID_ = INVALID_SESSION_ID; 265 std::mutex mutex_; 266 }; 267 268 class AudioStreamCallbackRenderer : public AudioStreamCallback { 269 public: 270 virtual ~AudioStreamCallbackRenderer() = default; 271 272 void OnStateChange(const State state, const StateChangeCmdType cmdType = CMD_FROM_CLIENT) override; 273 void SaveCallback(const std::weak_ptr<AudioRendererCallback> &callback); 274 private: 275 std::weak_ptr<AudioRendererCallback> callback_; 276 }; 277 278 class OutputDeviceChangeWithInfoCallbackImpl : public DeviceChangeWithInfoCallback { 279 public: 280 OutputDeviceChangeWithInfoCallbackImpl() = default; 281 virtual ~OutputDeviceChangeWithInfoCallbackImpl() = default; 282 283 void OnDeviceChangeWithInfo(const uint32_t sessionId, const AudioDeviceDescriptor &deviceInfo, 284 const AudioStreamDeviceChangeReasonExt reason) override; 285 286 void OnRecreateStreamEvent(const uint32_t sessionId, const int32_t streamFlag, 287 const AudioStreamDeviceChangeReasonExt reason) override; 288 SaveCallback(const std::shared_ptr<AudioRendererOutputDeviceChangeCallback> & callback)289 void SaveCallback(const std::shared_ptr<AudioRendererOutputDeviceChangeCallback> &callback) 290 { 291 std::lock_guard<std::mutex> lock(callbackMutex_); 292 callbacks_.push_back(callback); 293 } 294 RemoveCallback()295 void RemoveCallback() 296 { 297 std::lock_guard<std::mutex> lock(callbackMutex_); 298 callbacks_.clear(); 299 } 300 RemoveCallback(const std::shared_ptr<AudioRendererOutputDeviceChangeCallback> & callback)301 void RemoveCallback(const std::shared_ptr<AudioRendererOutputDeviceChangeCallback> &callback) 302 { 303 std::lock_guard<std::mutex> lock(callbackMutex_); 304 callbacks_.erase(std::remove(callbacks_.begin(), callbacks_.end(), callback), callbacks_.end()); 305 } 306 SetAudioRendererObj(AudioRendererPrivate * rendererObj)307 void SetAudioRendererObj(AudioRendererPrivate *rendererObj) 308 { 309 std::lock_guard<std::mutex> lock(audioRendererObjMutex_); 310 renderer_ = rendererObj; 311 } 312 UnsetAudioRendererObj()313 void UnsetAudioRendererObj() 314 { 315 std::lock_guard<std::mutex> lock(audioRendererObjMutex_); 316 renderer_ = nullptr; 317 } 318 private: 319 std::vector<std::shared_ptr<AudioRendererOutputDeviceChangeCallback>> callbacks_; 320 AudioRendererPrivate *renderer_ = nullptr; 321 std::mutex audioRendererObjMutex_; 322 std::mutex callbackMutex_; 323 }; 324 325 class RendererPolicyServiceDiedCallback : public AudioStreamPolicyServiceDiedCallback { 326 public: 327 RendererPolicyServiceDiedCallback(); 328 virtual ~RendererPolicyServiceDiedCallback(); 329 void SetAudioRendererObj(AudioRendererPrivate *rendererObj); 330 void SetAudioInterrupt(AudioInterrupt &audioInterrupt); 331 void OnAudioPolicyServiceDied() override; 332 333 private: 334 AudioRendererPrivate *renderer_ = nullptr; 335 AudioInterrupt audioInterrupt_; 336 void RestoreTheadLoop(); 337 std::unique_ptr<std::thread> restoreThread_ = nullptr; 338 }; 339 340 class AudioRendererConcurrencyCallbackImpl : public AudioConcurrencyCallback { 341 public: 342 explicit AudioRendererConcurrencyCallbackImpl(); 343 virtual ~AudioRendererConcurrencyCallbackImpl(); 344 void OnConcedeStream() override; SetAudioRendererObj(AudioRendererPrivate * rendererObj)345 void SetAudioRendererObj(AudioRendererPrivate *rendererObj) 346 { 347 std::lock_guard<std::mutex> lock(mutex_); 348 renderer_ = rendererObj; 349 } UnsetAudioRendererObj()350 void UnsetAudioRendererObj() 351 { 352 std::lock_guard<std::mutex> lock(mutex_); 353 renderer_ = nullptr; 354 } 355 private: 356 AudioRendererPrivate *renderer_ = nullptr; 357 std::mutex mutex_; 358 }; 359 } // namespace AudioStandard 360 } // namespace OHOS 361 #endif // AUDIO_RENDERER_PRIVATE_H 362