1 /* 2 * Copyright (c) 2023-2025 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 #ifndef FAST_AUDIO_STREAM_H 16 #define FAST_AUDIO_STREAM_H 17 18 #include <mutex> 19 #include <condition_variable> 20 #include "timestamp.h" 21 #include "event_handler.h" 22 #include "event_runner.h" 23 24 #include "audio_process_in_client.h" 25 #include "audio_stream_tracker.h" 26 #include "i_audio_stream.h" 27 #include "audio_policy_manager.h" 28 #include "callback_handler.h" 29 30 namespace OHOS { 31 namespace AudioStandard { 32 class FastPolicyServiceDiedCallbackImpl; 33 class FastAudioStreamRenderCallback : public AudioDataCallback { 34 public: FastAudioStreamRenderCallback(const std::shared_ptr<AudioRendererWriteCallback> & callback,IAudioStream & audioStream)35 FastAudioStreamRenderCallback(const std::shared_ptr<AudioRendererWriteCallback> &callback, 36 IAudioStream &audioStream) 37 : rendererWriteCallback_(callback), audioStreamImpl_(audioStream), hasFirstFrameWrited_(false) {}; 38 virtual ~FastAudioStreamRenderCallback() = default; 39 40 void OnHandleData(size_t length) override; 41 std::shared_ptr<AudioRendererWriteCallback> GetRendererWriteCallback() const; 42 43 void ResetFirstFrameState(); 44 private: 45 std::shared_ptr<AudioRendererWriteCallback> rendererWriteCallback_ = nullptr; 46 IAudioStream &audioStreamImpl_; 47 std::atomic<bool> hasFirstFrameWrited_ = false; 48 }; 49 50 class FastAudioStreamCaptureCallback : public AudioDataCallback { 51 public: FastAudioStreamCaptureCallback(const std::shared_ptr<AudioCapturerReadCallback> & callback)52 FastAudioStreamCaptureCallback(const std::shared_ptr<AudioCapturerReadCallback> &callback) 53 : captureCallback_(callback) {}; 54 virtual ~FastAudioStreamCaptureCallback() = default; 55 56 void OnHandleData(size_t length) override; 57 std::shared_ptr<AudioCapturerReadCallback> GetCapturerReadCallback() const; 58 private: 59 std::shared_ptr<AudioCapturerReadCallback> captureCallback_ = nullptr; 60 }; 61 62 class FastAudioStream : public IAudioStream, public IHandler, 63 public std::enable_shared_from_this<FastAudioStream>{ 64 public: 65 FastAudioStream(AudioStreamType eStreamType, AudioMode eMode, int32_t appUid); 66 virtual ~FastAudioStream(); 67 68 void SetClientID(int32_t clientPid, int32_t clientUid, uint32_t appTokenId, uint64_t fullTokenId) override; 69 70 int32_t UpdatePlaybackCaptureConfig(const AudioPlaybackCaptureConfig &config) override; 71 void SetRendererInfo(const AudioRendererInfo &rendererInfo) override; 72 void GetRendererInfo(AudioRendererInfo &rendererInfo) override; 73 void SetCapturerInfo(const AudioCapturerInfo &capturerInfo) override; 74 int32_t SetAudioStreamInfo(const AudioStreamParams info, 75 const std::shared_ptr<AudioClientTracker> &proxyObj, 76 const AudioPlaybackCaptureConfig &config = AudioPlaybackCaptureConfig()) override; 77 int32_t GetAudioStreamInfo(AudioStreamParams &info) override; 78 int32_t GetAudioSessionID(uint32_t &sessionID) override; 79 void GetAudioPipeType(AudioPipeType &pipeType) override; 80 State GetState() override; 81 bool GetAudioTime(Timestamp ×tamp, Timestamp::Timestampbase base) override; 82 bool GetAudioPosition(Timestamp ×tamp, Timestamp::Timestampbase base) override; 83 int32_t GetBufferSize(size_t &bufferSize) override; 84 int32_t GetFrameCount(uint32_t &frameCount) override; 85 int32_t GetLatency(uint64_t &latency) override; 86 int32_t SetAudioStreamType(AudioStreamType audioStreamType) override; 87 int32_t SetVolume(float volume) override; 88 int32_t SetLoudnessGain(float loudnessGain) override; 89 float GetLoudnessGain() override; 90 int32_t SetMute(bool mute, StateChangeCmdType cmdType) override; 91 bool GetMute() override; 92 int32_t SetSourceDuration(int64_t duration) override; 93 float GetVolume() override; 94 int32_t SetDuckVolume(float volume) override; 95 float GetDuckVolume() override; 96 int32_t SetRenderRate(AudioRendererRate renderRate) override; 97 AudioRendererRate GetRenderRate() override; 98 int32_t SetStreamCallback(const std::shared_ptr<AudioStreamCallback> &callback) override; 99 100 void InitCallbackHandler(); 101 void SafeSendCallbackEvent(uint32_t eventCode, int64_t data); 102 void OnHandle(uint32_t code, int64_t data) override; 103 void HandleStateChangeEvent(int64_t data); 104 int32_t ParamsToStateCmdType(int64_t params, State &state, StateChangeCmdType &cmdType); 105 106 // callback mode api 107 int32_t SetRendererFirstFrameWritingCallback( 108 const std::shared_ptr<AudioRendererFirstFrameWritingCallback> &callback) override; 109 void OnFirstFrameWriting() override; 110 int32_t SetRenderMode(AudioRenderMode renderMode) override; 111 AudioRenderMode GetRenderMode() override; 112 int32_t SetRendererWriteCallback(const std::shared_ptr<AudioRendererWriteCallback> &callback) override; 113 int32_t SetCaptureMode(AudioCaptureMode captureMode) override; 114 AudioCaptureMode GetCaptureMode() override; 115 int32_t SetCapturerReadCallback(const std::shared_ptr<AudioCapturerReadCallback> &callback) override; 116 int32_t GetBufferDesc(BufferDesc &bufDesc) override; 117 int32_t GetBufQueueState(BufferQueueState &bufState) override; 118 int32_t Enqueue(const BufferDesc &bufDesc) override; 119 int32_t Clear() override; 120 void SetPreferredFrameSize(int32_t frameSize) override; 121 void UpdateLatencyTimestamp(std::string ×tamp, bool isRenderer) override; 122 int32_t SetLowPowerVolume(float volume) override; 123 float GetLowPowerVolume() override; 124 int32_t SetOffloadMode(int32_t state, bool isAppBack) override; 125 int32_t UnsetOffloadMode() override; 126 float GetSingleStreamVolume() override; 127 AudioEffectMode GetAudioEffectMode() override; 128 int32_t SetAudioEffectMode(AudioEffectMode effectMode) override; 129 int64_t GetFramesWritten() override; 130 int64_t GetFramesRead() override; 131 132 void SetInnerCapturerState(bool isInnerCapturer) override; 133 void SetWakeupCapturerState(bool isWakeupCapturer) override; 134 void SetCapturerSource(int capturerSource) override; 135 void SetPrivacyType(AudioPrivacyType privacyType) override; 136 137 // Common APIs 138 bool StartAudioStream(StateChangeCmdType cmdType = CMD_FROM_CLIENT, 139 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReasonExt::ExtEnum::UNKNOWN) override; 140 bool PauseAudioStream(StateChangeCmdType cmdType = CMD_FROM_CLIENT) override; 141 bool StopAudioStream() override; 142 bool ReleaseAudioStream(bool releaseRunner = true, bool isSwitchStream = false) override; 143 bool FlushAudioStream() override; 144 145 // Playback related APIs 146 bool DrainAudioStream(bool stopFlag = false) override; 147 int32_t Write(uint8_t *buffer, size_t buffer_size) override; 148 int32_t Write(uint8_t *pcmBuffer, size_t pcmSize, uint8_t *metaBuffer, size_t metaSize) override; 149 int32_t SetSpeed(float speed) override; 150 int32_t SetPitch(float pitch) override; 151 float GetSpeed() override; 152 153 // Recording related APIs 154 int32_t Read(uint8_t &buffer, size_t userSize, bool isBlockingRead) override; 155 156 uint32_t GetUnderflowCount() override; 157 uint32_t GetOverflowCount() override; 158 void SetUnderflowCount(uint32_t underflowCount) override; 159 void SetOverflowCount(uint32_t overflowCount) override; 160 161 void SetRendererPositionCallback(int64_t markPosition, const std::shared_ptr<RendererPositionCallback> &callback) 162 override; 163 void UnsetRendererPositionCallback() override; 164 void SetRendererPeriodPositionCallback(int64_t markPosition, 165 const std::shared_ptr<RendererPeriodPositionCallback> &callback) override; 166 void UnsetRendererPeriodPositionCallback() override; 167 void SetCapturerPositionCallback(int64_t markPosition, const std::shared_ptr<CapturerPositionCallback> &callback) 168 override; 169 void UnsetCapturerPositionCallback() override; 170 void SetCapturerPeriodPositionCallback(int64_t markPosition, 171 const std::shared_ptr<CapturerPeriodPositionCallback> &callback) override; 172 void UnsetCapturerPeriodPositionCallback() override; 173 int32_t SetRendererSamplingRate(uint32_t sampleRate) override; 174 uint32_t GetRendererSamplingRate() override; 175 int32_t SetBufferSizeInMsec(int32_t bufferSizeInMsec) override; 176 int32_t SetChannelBlendMode(ChannelBlendMode blendMode) override; 177 int32_t SetVolumeWithRamp(float volume, int32_t duration) override; 178 179 void SetStreamTrackerState(bool trackerRegisteredState) override; 180 void GetSwitchInfo(IAudioStream::SwitchInfo& info) override; 181 182 IAudioStream::StreamClass GetStreamClass() override; 183 184 bool RestoreAudioStream(bool needStoreState = true) override; 185 void JoinCallbackLoop() override; 186 187 bool GetOffloadEnable() override; 188 bool GetSpatializationEnabled() override; 189 bool GetHighResolutionEnabled() override; 190 191 void SetSilentModeAndMixWithOthers(bool on) override; 192 193 bool GetSilentModeAndMixWithOthers() override; 194 195 int32_t SetDefaultOutputDevice(const DeviceType defaultOutputDevice, bool skipForce = false) override; 196 197 FastStatus GetFastStatus() override; 198 199 DeviceType GetDefaultOutputDevice() override; 200 201 int32_t GetAudioTimestampInfo(Timestamp ×tamp, Timestamp::Timestampbase base) override; 202 203 void SetSwitchingStatus(bool isSwitching) override; 204 205 void GetRestoreInfo(RestoreInfo &restoreInfo) override; 206 void SetRestoreInfo(RestoreInfo &restoreInfo) override; 207 RestoreStatus CheckRestoreStatus() override; 208 RestoreStatus SetRestoreStatus(RestoreStatus restoreStatus) override; 209 void SetSwitchInfoTimestamp(std::vector<std::pair<uint64_t, uint64_t>> lastFramePosAndTimePair, 210 std::vector<std::pair<uint64_t, uint64_t>> lastFramePosAndTimePairWithSpeed) override; 211 void FetchDeviceForSplitStream() override; 212 void SetCallStartByUserTid(pid_t tid) override; 213 void SetCallbackLoopTid(int32_t tid) override; 214 int32_t GetCallbackLoopTid() override; 215 void ResetCallbackLoopTid(); 216 bool GetStopFlag() const override; 217 void ResetFirstFrameState() override; 218 void SetAudioHapticsSyncId(const int32_t &audioHapticsSyncId) override; 219 private: 220 void UpdateRegisterTrackerInfo(AudioRegisterTrackerInfo ®isterTrackerInfo); 221 int32_t InitializeAudioProcessConfig(AudioProcessConfig &config, const AudioStreamParams &info); 222 int32_t SetCallbacksWhenRestore(); 223 void RegisterThreadPriorityOnStart(StateChangeCmdType cmdType); 224 225 AudioStreamType eStreamType_; 226 AudioMode eMode_; 227 std::shared_ptr<AudioProcessInClient> processClient_ = nullptr; 228 std::shared_ptr<FastAudioStreamRenderCallback> spkProcClientCb_ = nullptr; 229 std::shared_ptr<FastAudioStreamCaptureCallback> micProcClientCb_ = nullptr; 230 std::shared_ptr<AudioRendererFirstFrameWritingCallback> firstFrameWritingCb_ = nullptr; 231 std::unique_ptr<AudioStreamTracker> audioStreamTracker_; 232 AudioRendererInfo rendererInfo_; 233 AudioCapturerInfo capturerInfo_; 234 AudioStreamParams streamInfo_; 235 AudioProcessConfig processconfig_; 236 State state_; 237 uint32_t sessionId_ = 0; 238 uint32_t underflowCount_ = 0; 239 uint32_t overflowCount_ = 0; 240 AudioRenderMode renderMode_; 241 AudioCaptureMode captureMode_; 242 AudioRendererRate renderRate_ = RENDER_RATE_NORMAL; 243 int32_t clientPid_ = 0; 244 int32_t clientUid_ = 0; 245 uint32_t appTokenId_ = 0; 246 uint64_t fullTokenId_ = 0; 247 bool streamTrackerRegistered_ = false; 248 std::shared_ptr<AudioClientTracker> proxyObj_ = nullptr; 249 bool silentModeAndMixWithOthers_ = false; 250 DeviceType defaultOutputDevice_ = DEVICE_TYPE_NONE; 251 StateChangeCmdType muteCmd_ = CMD_FROM_CLIENT; 252 253 std::mutex streamCbMutex_; 254 std::weak_ptr<AudioStreamCallback> streamCallback_; 255 256 bool runnerReleased_ = false; 257 std::mutex runnerMutex_; 258 std::shared_ptr<CallbackHandler> callbackHandler_ = nullptr; 259 260 std::mutex setPreferredFrameSizeMutex_; 261 std::optional<int32_t> userSettedPreferredFrameSize_ = std::nullopt; 262 263 std::mutex switchingMutex_; 264 StreamSwitchingInfo switchingInfo_ {false, INVALID}; 265 266 std::mutex lastCallStartByUserTidMutex_; 267 std::optional<pid_t> lastCallStartByUserTid_ = std::nullopt; 268 269 int32_t callbackLoopTid_ = -1; 270 std::mutex callbackLoopTidMutex_; 271 std::condition_variable callbackLoopTidCv_; 272 273 enum { 274 STATE_CHANGE_EVENT = 0 275 }; 276 277 enum : int64_t { 278 HANDLER_PARAM_INVALID = -1, 279 HANDLER_PARAM_NEW = 0, 280 HANDLER_PARAM_PREPARED, 281 HANDLER_PARAM_RUNNING, 282 HANDLER_PARAM_STOPPED, 283 HANDLER_PARAM_RELEASED, 284 HANDLER_PARAM_PAUSED, 285 HANDLER_PARAM_STOPPING, 286 HANDLER_PARAM_RUNNING_FROM_SYSTEM, 287 HANDLER_PARAM_PAUSED_FROM_SYSTEM, 288 }; 289 }; 290 } // namespace AudioStandard 291 } // namespace OHOS 292 #endif // FAST_AUDIO_STREAM_H 293