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 &params) 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 &timestamp, Timestamp::Timestampbase base) const override;
50     bool GetAudioPosition(Timestamp &timestamp, 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