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 "audio_interrupt_callback.h" 20 #include "audio_renderer.h" 21 #include "audio_renderer_proxy_obj.h" 22 #include "i_audio_stream.h" 23 24 namespace OHOS { 25 namespace AudioStandard { 26 constexpr uint32_t INVALID_SESSION_ID = static_cast<uint32_t>(-1); 27 class AudioRendererStateChangeCallbackImpl; 28 29 class AudioRendererPrivate : public AudioRenderer { 30 public: 31 int32_t GetFrameCount(uint32_t &frameCount) const override; 32 int32_t GetLatency(uint64_t &latency) const override; 33 void SetAudioPrivacyType(AudioPrivacyType privacyType) override; 34 int32_t SetParams(const AudioRendererParams params) override; 35 int32_t GetParams(AudioRendererParams ¶ms) const override; 36 int32_t GetRendererInfo(AudioRendererInfo &rendererInfo) const override; 37 int32_t GetStreamInfo(AudioStreamInfo &streamInfo) const override; 38 bool Start(StateChangeCmdType cmdType = CMD_FROM_CLIENT) const override; 39 int32_t Write(uint8_t *buffer, size_t bufferSize) override; 40 RendererState GetStatus() const override; 41 bool GetAudioTime(Timestamp ×tamp, Timestamp::Timestampbase base) const override; 42 bool Drain() const override; 43 bool Pause(StateChangeCmdType cmdType = CMD_FROM_CLIENT) const override; 44 bool Stop() const override; 45 bool Flush() const override; 46 bool Release() const override; 47 int32_t GetBufferSize(size_t &bufferSize) const override; 48 int32_t GetAudioStreamId(uint32_t &sessionID) const override; 49 int32_t SetAudioRendererDesc(AudioRendererDesc audioRendererDesc) override; 50 int32_t SetStreamType(AudioStreamType audioStreamType) override; 51 int32_t SetVolume(float volume) const override; 52 float GetVolume() const override; 53 int32_t SetRenderRate(AudioRendererRate renderRate) const override; 54 AudioRendererRate GetRenderRate() const override; 55 int32_t SetRendererSamplingRate(uint32_t sampleRate) const override; 56 uint32_t GetRendererSamplingRate() const override; 57 int32_t SetRendererCallback(const std::shared_ptr<AudioRendererCallback> &callback) override; 58 int32_t SetRendererPositionCallback(int64_t markPosition, 59 const std::shared_ptr<RendererPositionCallback> &callback) override; 60 void UnsetRendererPositionCallback() override; 61 int32_t SetRendererPeriodPositionCallback(int64_t frameNumber, 62 const std::shared_ptr<RendererPeriodPositionCallback> &callback) override; 63 void UnsetRendererPeriodPositionCallback() override; 64 int32_t SetBufferDuration(uint64_t bufferDuration) const override; 65 int32_t SetRenderMode(AudioRenderMode renderMode) const override; 66 AudioRenderMode GetRenderMode() const override; 67 int32_t SetRendererWriteCallback(const std::shared_ptr<AudioRendererWriteCallback> &callback) override; 68 int32_t GetBufferDesc(BufferDesc &bufDesc) const override; 69 int32_t Enqueue(const BufferDesc &bufDesc) const override; 70 int32_t Clear() const override; 71 int32_t GetBufQueueState(BufferQueueState &bufState) const override; 72 void SetApplicationCachePath(const std::string cachePath) override; 73 void SetInterruptMode(InterruptMode mode) override; 74 int32_t SetParallelPlayFlag(bool parallelPlayFlag) override; 75 int32_t SetLowPowerVolume(float volume) const override; 76 float GetLowPowerVolume() const override; 77 float GetSingleStreamVolume() const override; 78 float GetMinStreamVolume() const override; 79 float GetMaxStreamVolume() const override; 80 int32_t GetCurrentOutputDevices(DeviceInfo &deviceInfo) const override; 81 uint32_t GetUnderflowCount() const override; 82 bool IsDeviceChanged(DeviceInfo &newDeviceInfo); 83 int32_t RegisterAudioRendererEventListener(const int32_t clientPid, 84 const std::shared_ptr<AudioRendererDeviceChangeCallback> &callback) override; 85 int32_t UnregisterAudioRendererEventListener(const int32_t clientPid) override; 86 int32_t RegisterAudioPolicyServerDiedCb(const int32_t clientPid, 87 const std::shared_ptr<AudioRendererPolicyServiceDiedCallback> &callback) override; 88 int32_t UnregisterAudioPolicyServerDiedCb(const int32_t clientPid) override; 89 void DestroyAudioRendererStateCallback() override; 90 AudioEffectMode GetAudioEffectMode() const override; 91 int64_t GetFramesWritten() const override; 92 int32_t SetAudioEffectMode(AudioEffectMode effectMode) const override; 93 void SetAudioRendererErrorCallback(std::shared_ptr<AudioRendererErrorCallback> errorCallback) override; 94 ConvertToAudioStreamParams(const AudioRendererParams params)95 static inline AudioStreamParams ConvertToAudioStreamParams(const AudioRendererParams params) 96 { 97 AudioStreamParams audioStreamParams; 98 99 audioStreamParams.format = params.sampleFormat; 100 audioStreamParams.samplingRate = params.sampleRate; 101 audioStreamParams.channels = params.channelCount; 102 audioStreamParams.encoding = params.encodingType; 103 104 return audioStreamParams; 105 } 106 107 AudioPrivacyType privacyType_ = PRIVACY_TYPE_PUBLIC; 108 AudioRendererInfo rendererInfo_ = {CONTENT_TYPE_MUSIC, STREAM_USAGE_MEDIA, 0}; 109 std::string cachePath_; 110 111 explicit AudioRendererPrivate(AudioStreamType audioStreamType, const AppInfo &appInfo, bool createStream = true); 112 113 ~AudioRendererPrivate(); 114 115 friend class AudioRendererStateChangeCallbackImpl; 116 117 protected: 118 // Method for switching between normal and low latency paths 119 void SwitchStream(bool isLowLatencyDevice); 120 121 private: 122 int32_t InitAudioInterruptCallback(); 123 void SetSwitchInfo(IAudioStream::SwitchInfo info, std::shared_ptr<IAudioStream> audioStream); 124 bool SwitchToTargetStream(IAudioStream::StreamClass targetClass); 125 void SetSelfRendererStateCallback(); 126 void InitDumpInfo(); 127 128 std::shared_ptr<IAudioStream> audioStream_; 129 std::shared_ptr<AudioInterruptCallback> audioInterruptCallback_ = nullptr; 130 std::shared_ptr<AudioStreamCallback> audioStreamCallback_ = nullptr; 131 AppInfo appInfo_ = {}; 132 AudioInterrupt audioInterrupt_ = {STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, 133 {AudioStreamType::STREAM_DEFAULT, SourceType::SOURCE_TYPE_INVALID, true}, 0}; 134 uint32_t sessionID_ = INVALID_SESSION_ID; 135 std::shared_ptr<AudioRendererProxyObj> rendererProxyObj_; 136 #ifdef DUMP_CLIENT_PCM 137 FILE *dcp_ = nullptr; 138 #endif 139 std::shared_ptr<AudioRendererStateChangeCallbackImpl> audioDeviceChangeCallback_ = nullptr; 140 std::shared_ptr<AudioRendererErrorCallback> audioRendererErrorCallback_ = nullptr; 141 DeviceInfo currentDeviceInfo = {}; 142 bool isFastRenderer_ = false; 143 bool isSwitching_ = false; 144 mutable std::mutex switchStreamMutex_; 145 }; 146 147 class AudioRendererInterruptCallbackImpl : public AudioInterruptCallback { 148 public: 149 explicit AudioRendererInterruptCallbackImpl(const std::shared_ptr<IAudioStream> &audioStream, 150 const AudioInterrupt &audioInterrupt); 151 virtual ~AudioRendererInterruptCallbackImpl(); 152 153 void OnInterrupt(const InterruptEventInternal &interruptEvent) override; 154 void SaveCallback(const std::weak_ptr<AudioRendererCallback> &callback); 155 private: 156 void NotifyEvent(const InterruptEvent &interruptEvent); 157 void HandleAndNotifyForcedEvent(const InterruptEventInternal &interruptEvent); 158 void NotifyForcePausedToResume(const InterruptEventInternal &interruptEvent); 159 bool HandleForceDucking(const InterruptEventInternal &interruptEvent); 160 std::shared_ptr<IAudioStream> audioStream_; 161 std::weak_ptr<AudioRendererCallback> callback_; 162 std::shared_ptr<AudioRendererCallback> cb_; 163 AudioInterrupt audioInterrupt_ {}; 164 bool isForcePaused_ = false; 165 bool isForceDucked_ = false; 166 float instanceVolBeforeDucking_ = 0.2f; 167 }; 168 169 class AudioStreamCallbackRenderer : public AudioStreamCallback { 170 public: 171 virtual ~AudioStreamCallbackRenderer() = default; 172 173 void OnStateChange(const State state, const StateChangeCmdType cmdType = CMD_FROM_CLIENT) override; 174 void SaveCallback(const std::weak_ptr<AudioRendererCallback> &callback); 175 private: 176 std::weak_ptr<AudioRendererCallback> callback_; 177 }; 178 179 class AudioRendererStateChangeCallbackImpl : public AudioRendererStateChangeCallback { 180 public: 181 AudioRendererStateChangeCallbackImpl(); 182 virtual ~AudioRendererStateChangeCallbackImpl(); 183 184 void OnRendererStateChange( 185 const std::vector<std::unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos) override; 186 void SaveCallback(const std::weak_ptr<AudioRendererDeviceChangeCallback> &callback); 187 void setAudioRendererObj(AudioRendererPrivate *rendererObj); 188 private: 189 std::weak_ptr<AudioRendererDeviceChangeCallback> callback_; 190 AudioRendererPrivate *renderer; 191 }; 192 } // namespace AudioStandard 193 } // namespace OHOS 194 #endif // AUDIO_RENDERER_PRIVATE_H 195