1 /* 2 * Copyright (c) 2024 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 RENDERER_IN_CLIENT_PRIVATE_H 16 #define RENDERER_IN_CLIENT_PRIVATE_H 17 18 #include <optional> 19 20 #include "bundle_mgr_interface.h" 21 #include "bundle_mgr_proxy.h" 22 23 #include "audio_manager_base.h" 24 #include "audio_ring_cache.h" 25 #include "audio_channel_blend.h" 26 #include "audio_server_death_recipient.h" 27 #include "audio_stream_tracker.h" 28 #include "audio_system_manager.h" 29 #include "audio_utils.h" 30 #include "ipc_stream_listener_impl.h" 31 #include "ipc_stream_listener_stub.h" 32 #include "volume_ramp.h" 33 #include "volume_tools.h" 34 #include "callback_handler.h" 35 #include "audio_speed.h" 36 #include "audio_spatial_channel_converter.h" 37 #include "audio_policy_manager.h" 38 #include "audio_spatialization_manager.h" 39 #include "audio_safe_block_queue.h" 40 41 namespace OHOS { 42 namespace AudioStandard { 43 namespace { 44 const int32_t LOG_COUNT_LIMIT = 500; 45 } // namespace 46 class SpatializationStateChangeCallbackImpl; 47 48 class RendererInClientInner : public RendererInClient, public IStreamListener, public IHandler, 49 public std::enable_shared_from_this<RendererInClientInner> { 50 public: 51 RendererInClientInner(AudioStreamType eStreamType, int32_t appUid); 52 ~RendererInClientInner(); 53 54 // IStreamListener 55 int32_t OnOperationHandled(Operation operation, int64_t result) override; 56 57 // IAudioStream 58 void SetClientID(int32_t clientPid, int32_t clientUid, uint32_t appTokenId, uint64_t fullTokenId) override; 59 60 int32_t UpdatePlaybackCaptureConfig(const AudioPlaybackCaptureConfig &config) override; 61 void SetRendererInfo(const AudioRendererInfo &rendererInfo) override; 62 void SetCapturerInfo(const AudioCapturerInfo &capturerInfo) override; 63 int32_t SetAudioStreamInfo(const AudioStreamParams info, 64 const std::shared_ptr<AudioClientTracker> &proxyObj, 65 const AudioPlaybackCaptureConfig &config = AudioPlaybackCaptureConfig()) override; 66 int32_t GetAudioStreamInfo(AudioStreamParams &info) override; 67 int32_t GetAudioSessionID(uint32_t &sessionID) override; 68 void GetAudioPipeType(AudioPipeType &pipeType) override; 69 State GetState() override; 70 bool GetAudioTime(Timestamp ×tamp, Timestamp::Timestampbase base) override; 71 bool GetAudioPosition(Timestamp ×tamp, Timestamp::Timestampbase base) override; 72 int32_t GetBufferSize(size_t &bufferSize) override; 73 int32_t GetFrameCount(uint32_t &frameCount) override; 74 int32_t GetLatency(uint64_t &latency) override; 75 int32_t SetAudioStreamType(AudioStreamType audioStreamType) override; 76 int32_t SetVolume(float volume) override; 77 float GetVolume() override; 78 int32_t SetDuckVolume(float volume) override; 79 int32_t SetMute(bool mute) override; 80 int32_t SetRenderRate(AudioRendererRate renderRate) override; 81 AudioRendererRate GetRenderRate() override; 82 int32_t SetStreamCallback(const std::shared_ptr<AudioStreamCallback> &callback) override; 83 int32_t SetRendererFirstFrameWritingCallback( 84 const std::shared_ptr<AudioRendererFirstFrameWritingCallback> &callback) override; 85 void OnFirstFrameWriting() override; 86 int32_t SetSpeed(float speed) override; 87 float GetSpeed() override; 88 int32_t ChangeSpeed(uint8_t *buffer, int32_t bufferSize, std::unique_ptr<uint8_t[]> &outBuffer, 89 int32_t &outBufferSize) override; 90 91 // callback mode api 92 int32_t SetRenderMode(AudioRenderMode renderMode) override; 93 void InitCallbackLoop(); 94 AudioRenderMode GetRenderMode() override; 95 int32_t SetRendererWriteCallback(const std::shared_ptr<AudioRendererWriteCallback> &callback) override; 96 int32_t SetCaptureMode(AudioCaptureMode captureMode) override; 97 AudioCaptureMode GetCaptureMode() override; 98 int32_t SetCapturerReadCallback(const std::shared_ptr<AudioCapturerReadCallback> &callback) override; 99 int32_t GetBufferDesc(BufferDesc &bufDesc) override; 100 int32_t GetBufQueueState(BufferQueueState &bufState) override; 101 int32_t Enqueue(const BufferDesc &bufDesc) override; 102 int32_t Clear() override; 103 104 int32_t SetLowPowerVolume(float volume) override; 105 float GetLowPowerVolume() override; 106 int32_t SetOffloadMode(int32_t state, bool isAppBack) override; 107 int32_t UnsetOffloadMode() override; 108 float GetSingleStreamVolume() override; 109 AudioEffectMode GetAudioEffectMode() override; 110 int32_t SetAudioEffectMode(AudioEffectMode effectMode) override; 111 int64_t GetFramesWritten() override; 112 int64_t GetFramesRead() override; 113 int32_t SetSourceDuration(int64_t duration) override; 114 115 void SetInnerCapturerState(bool isInnerCapturer) override; 116 void SetWakeupCapturerState(bool isWakeupCapturer) override; 117 void SetCapturerSource(int capturerSource) override; 118 void SetPrivacyType(AudioPrivacyType privacyType) override; 119 120 // Common APIs 121 bool StartAudioStream(StateChangeCmdType cmdType = CMD_FROM_CLIENT, 122 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReasonExt::ExtEnum::UNKNOWN) override; 123 bool PauseAudioStream(StateChangeCmdType cmdType = CMD_FROM_CLIENT) override; 124 bool StopAudioStream() override; 125 bool ReleaseAudioStream(bool releaseRunner = true, bool isSwitchStream = false) override; 126 bool FlushAudioStream() override; 127 128 // Playback related APIs 129 bool DrainAudioStream(bool stopFlag = false) override; 130 int32_t Write(uint8_t *buffer, size_t bufferSize) override; 131 int32_t Write(uint8_t *pcmBuffer, size_t pcmBufferSize, uint8_t *metaBuffer, size_t metaBufferSize) override; 132 void SetPreferredFrameSize(int32_t frameSize) override; 133 134 // Recording related APIs 135 int32_t Read(uint8_t &buffer, size_t userSize, bool isBlockingRead) override; 136 137 uint32_t GetUnderflowCount() override; 138 uint32_t GetOverflowCount() override; 139 void SetUnderflowCount(uint32_t underflowCount) override; 140 void SetOverflowCount(uint32_t overflowCount) override; 141 142 void SetRendererPositionCallback(int64_t markPosition, const std::shared_ptr<RendererPositionCallback> &callback) 143 override; 144 void UnsetRendererPositionCallback() override; 145 void SetRendererPeriodPositionCallback(int64_t periodPosition, 146 const std::shared_ptr<RendererPeriodPositionCallback> &callback) override; 147 void UnsetRendererPeriodPositionCallback() override; 148 void SetCapturerPositionCallback(int64_t markPosition, const std::shared_ptr<CapturerPositionCallback> &callback) 149 override; 150 void UnsetCapturerPositionCallback() override; 151 void SetCapturerPeriodPositionCallback(int64_t periodPosition, 152 const std::shared_ptr<CapturerPeriodPositionCallback> &callback) override; 153 void UnsetCapturerPeriodPositionCallback() override; 154 int32_t SetRendererSamplingRate(uint32_t sampleRate) override; 155 uint32_t GetRendererSamplingRate() override; 156 int32_t SetBufferSizeInMsec(int32_t bufferSizeInMsec) override; 157 int32_t SetChannelBlendMode(ChannelBlendMode blendMode) override; 158 int32_t SetVolumeWithRamp(float volume, int32_t duration) override; 159 160 void SetStreamTrackerState(bool trackerRegisteredState) override; 161 void GetSwitchInfo(IAudioStream::SwitchInfo& info) override; 162 163 IAudioStream::StreamClass GetStreamClass() override; 164 165 static const sptr<IStandardAudioService> GetAudioServerProxy(); 166 static void AudioServerDied(pid_t pid, pid_t uid); 167 168 void OnHandle(uint32_t code, int64_t data) override; 169 void InitCallbackHandler(); 170 void SafeSendCallbackEvent(uint32_t eventCode, int64_t data); 171 172 int32_t StateCmdTypeToParams(int64_t ¶ms, State state, StateChangeCmdType cmdType); 173 int32_t ParamsToStateCmdType(int64_t params, State &state, StateChangeCmdType &cmdType); 174 175 void SendRenderMarkReachedEvent(int64_t rendererMarkPosition); 176 void SendRenderPeriodReachedEvent(int64_t rendererPeriodSize); 177 178 void HandleRendererPositionChanges(size_t bytesWritten); 179 void HandleStateChangeEvent(int64_t data); 180 void HandleRenderMarkReachedEvent(int64_t rendererMarkPosition); 181 void HandleRenderPeriodReachedEvent(int64_t rendererPeriodNumber); 182 183 void OnSpatializationStateChange(const AudioSpatializationState &spatializationState); 184 void UpdateLatencyTimestamp(std::string ×tamp, bool isRenderer) override; 185 186 void GetStreamSwitchInfo(SwitchInfo &info); 187 188 bool GetOffloadEnable() override; 189 bool GetSpatializationEnabled() override; 190 bool GetHighResolutionEnabled() override; 191 192 void SetSilentModeAndMixWithOthers(bool on) override; 193 bool GetSilentModeAndMixWithOthers() override; 194 195 bool RestoreAudioStream(bool needStoreState = true) override; 196 197 int32_t SetDefaultOutputDevice(const DeviceType defaultOutputDevice) override; 198 DeviceType GetDefaultOutputDevice() override; 199 int32_t GetAudioTimestampInfo(Timestamp ×tamp, Timestamp::Timestampbase base) override; 200 201 void SetSwitchingStatus(bool isSwitching) override; 202 203 void GetRestoreInfo(RestoreInfo &restoreInfo) override; 204 void SetRestoreInfo(RestoreInfo &restoreInfo) override; 205 RestoreStatus CheckRestoreStatus() override; 206 RestoreStatus SetRestoreStatus(RestoreStatus restoreStatus) override; 207 void FetchDeviceForSplitStream() override; 208 private: 209 void RegisterTracker(const std::shared_ptr<AudioClientTracker> &proxyObj); 210 void UpdateTracker(const std::string &updateCase); 211 212 int32_t DeinitIpcStream(); 213 214 int32_t InitIpcStream(); 215 216 const AudioProcessConfig ConstructConfig(); 217 218 int32_t InitSharedBuffer(); 219 int32_t InitCacheBuffer(size_t targetSize); 220 221 int32_t FlushRingCache(); 222 int32_t DrainRingCache(); 223 224 int32_t DrainIncompleteFrame(OptResult result, bool stopFlag, 225 size_t targetSize, BufferDesc *desc, bool &dropIncompleteFrame); 226 int32_t WriteCacheData(bool isDrain = false, bool stopFlag = false); 227 228 void InitCallbackBuffer(uint64_t bufferDurationInUs); 229 bool WriteCallbackFunc(); 230 // for callback mode. Check status if not running, wait for start or release. 231 bool WaitForRunning(); 232 bool ProcessSpeed(uint8_t *&buffer, size_t &bufferSize, bool &speedCached); 233 int32_t WriteInner(uint8_t *buffer, size_t bufferSize); 234 int32_t WriteInner(uint8_t *pcmBuffer, size_t pcmBufferSize, uint8_t *metaBuffer, size_t metaBufferSize); 235 void WriteMuteDataSysEvent(uint8_t *buffer, size_t bufferSize); 236 bool IsInvalidBuffer(uint8_t *buffer, size_t bufferSize); 237 void DfxWriteInterval(); 238 void HandleStatusChangeOperation(Operation operation); 239 240 int32_t RegisterSpatializationStateEventListener(); 241 242 int32_t UnregisterSpatializationStateEventListener(uint32_t sessionID); 243 244 void FirstFrameProcess(); 245 246 int32_t WriteRingCache(uint8_t *buffer, size_t bufferSize, bool speedCached, size_t oriBufferSize); 247 248 void ResetFramePosition(); 249 250 int32_t SetInnerVolume(float volume); 251 252 bool IsHighResolution() const noexcept; 253 254 int32_t ProcessWriteInner(BufferDesc &bufferDesc); 255 256 void InitDirectPipeType(); 257 258 bool DrainAudioStreamInner(bool stopFlag = false); 259 260 bool ProcessVolume(); 261 262 private: 263 AudioStreamType eStreamType_ = AudioStreamType::STREAM_DEFAULT; 264 int32_t appUid_ = 0; 265 uint32_t sessionId_ = 0; 266 int32_t clientPid_ = -1; 267 int32_t clientUid_ = -1; 268 uint32_t appTokenId_ = 0; 269 uint64_t fullTokenId_ = 0; 270 271 std::unique_ptr<AudioStreamTracker> audioStreamTracker_; 272 273 AudioRendererInfo rendererInfo_ = {}; 274 AudioCapturerInfo capturerInfo_ = {}; // not in use 275 276 AudioPrivacyType privacyType_ = PRIVACY_TYPE_PUBLIC; 277 bool streamTrackerRegistered_ = false; 278 279 std::atomic<bool> needSetThreadPriority_ = true; 280 281 AudioStreamParams curStreamParams_ = {0}; // in plan next: replace it with AudioRendererParams 282 AudioStreamParams streamParams_ = {0}; 283 284 // for data process 285 bool isBlendSet_ = false; 286 AudioBlend audioBlend_; 287 VolumeRamp volumeRamp_; 288 289 // callbacks 290 std::mutex streamCbMutex_; 291 std::weak_ptr<AudioStreamCallback> streamCallback_; 292 293 size_t cacheSizeInByte_ = 0; 294 uint32_t spanSizeInFrame_ = 0; 295 size_t clientSpanSizeInByte_ = 0; 296 size_t sizePerFrameInByte_ = 4; // 16bit 2ch as default 297 298 uint32_t bufferSizeInMsec_ = 20; // 20ms 299 std::string dumpOutFile_ = ""; 300 FILE *dumpOutFd_ = nullptr; 301 mutable int64_t volumeDataCount_ = 0; 302 std::string logUtilsTag_ = ""; 303 304 std::shared_ptr<AudioRendererFirstFrameWritingCallback> firstFrameWritingCb_ = nullptr; 305 std::mutex firstFrameWritingMutex_; 306 std::atomic<bool> hasFirstFrameWrited_ = false; 307 308 // callback mode releated 309 AudioRenderMode renderMode_ = RENDER_MODE_NORMAL; 310 std::atomic<bool> cbThreadReleased_ = true; 311 std::mutex writeCbMutex_; 312 std::condition_variable cbThreadCv_; 313 std::shared_ptr<AudioRendererWriteCallback> writeCb_ = nullptr; 314 std::mutex cbBufferMutex_; 315 std::condition_variable cbBufferCV_; 316 std::unique_ptr<uint8_t[]> cbBuffer_ {nullptr}; 317 size_t cbBufferSize_ = 0; 318 AudioSafeBlockQueue<BufferDesc> cbBufferQueue_; // only one cbBuffer_ 319 320 std::atomic<State> state_ = INVALID; 321 // using this lock when change status_ 322 std::mutex statusMutex_; 323 // for status operation wait and notify 324 std::mutex callServerMutex_; 325 std::condition_variable callServerCV_; 326 std::mutex dataConnectionMutex_; 327 std::condition_variable dataConnectionCV_; 328 329 Operation notifiedOperation_ = MAX_OPERATION_CODE; 330 int64_t notifiedResult_ = 0; 331 332 float lowPowerVolume_ = 1.0; 333 float duckVolume_ = 1.0; 334 float muteVolume_ = 1.0; 335 float clientVolume_ = 1.0; 336 bool silentModeAndMixWithOthers_ = false; 337 338 uint64_t clientWrittenBytes_ = 0; 339 // ipc stream related 340 AudioProcessConfig clientConfig_; 341 sptr<IpcStreamListenerImpl> listener_ = nullptr; 342 sptr<IpcStream> ipcStream_ = nullptr; 343 std::shared_ptr<OHAudioBuffer> clientBuffer_ = nullptr; 344 345 // buffer handle 346 std::unique_ptr<AudioRingCache> ringCache_ = nullptr; 347 std::mutex writeMutex_; // used for prevent multi thread call write 348 349 // Mark reach and period reach callback 350 int64_t totalBytesWritten_ = 0; 351 std::mutex markReachMutex_; 352 bool rendererMarkReached_ = false; 353 int64_t rendererMarkPosition_ = 0; 354 std::shared_ptr<RendererPositionCallback> rendererPositionCallback_ = nullptr; 355 356 std::mutex periodReachMutex_; 357 int64_t rendererPeriodSize_ = 0; 358 int64_t rendererPeriodWritten_ = 0; 359 std::shared_ptr<RendererPeriodPositionCallback> rendererPeriodPositionCallback_ = nullptr; 360 361 // Event handler 362 bool runnerReleased_ = false; 363 std::mutex runnerMutex_; 364 std::shared_ptr<CallbackHandler> callbackHandler_ = nullptr; 365 366 bool paramsIsSet_ = false; 367 AudioRendererRate rendererRate_ = RENDER_RATE_NORMAL; 368 AudioEffectMode effectMode_ = EFFECT_DEFAULT; 369 370 float speed_ = 1.0; 371 std::unique_ptr<uint8_t[]> speedBuffer_ {nullptr}; 372 size_t bufferSize_ = 0; 373 std::unique_ptr<AudioSpeed> audioSpeed_ = nullptr; 374 375 std::unique_ptr<AudioSpatialChannelConverter> converter_; 376 377 bool offloadEnable_ = false; 378 uint64_t offloadStartReadPos_ = 0; 379 int64_t offloadStartHandleTime_ = 0; 380 381 uint64_t lastFramePosition_ = 0; 382 uint64_t lastFrameTimestamp_ = 0; 383 384 std::string traceTag_; 385 std::string spatializationEnabled_ = "Invalid"; 386 std::string headTrackingEnabled_ = "Invalid"; 387 uint32_t spatializationRegisteredSessionID_ = 0; 388 bool firstSpatializationRegistered_ = true; 389 std::shared_ptr<SpatializationStateChangeCallbackImpl> spatializationStateChangeCallback_ = nullptr; 390 std::time_t startMuteTime_ = 0; 391 bool isUpEvent_ = false; 392 std::shared_ptr<AudioClientTracker> proxyObj_ = nullptr; 393 int64_t preWriteEndTime_ = 0; 394 uint64_t lastFlushReadIndex_ = 0; 395 bool isDataLinkConnected_ = false; 396 397 uint64_t lastLatency_ = 0; 398 uint64_t lastLatencyPosition_ = 0; 399 uint64_t lastReadIdx_ = 0; 400 401 enum { 402 STATE_CHANGE_EVENT = 0, 403 RENDERER_MARK_REACHED_EVENT, 404 RENDERER_PERIOD_REACHED_EVENT, 405 CAPTURER_PERIOD_REACHED_EVENT, 406 CAPTURER_MARK_REACHED_EVENT, 407 }; 408 409 // note that the starting elements should remain the same as the enum State 410 enum : int64_t { 411 HANDLER_PARAM_INVALID = -1, 412 HANDLER_PARAM_NEW = 0, 413 HANDLER_PARAM_PREPARED, 414 HANDLER_PARAM_RUNNING, 415 HANDLER_PARAM_STOPPED, 416 HANDLER_PARAM_RELEASED, 417 HANDLER_PARAM_PAUSED, 418 HANDLER_PARAM_STOPPING, 419 HANDLER_PARAM_RUNNING_FROM_SYSTEM, 420 HANDLER_PARAM_PAUSED_FROM_SYSTEM, 421 }; 422 423 std::mutex setPreferredFrameSizeMutex_; 424 std::optional<int32_t> userSettedPreferredFrameSize_ = std::nullopt; 425 426 int32_t sleepCount_ = LOG_COUNT_LIMIT; 427 DeviceType defaultOutputDevice_ = DEVICE_TYPE_NONE; 428 429 std::mutex switchingMutex_; 430 StreamSwitchingInfo switchingInfo_ {false, INVALID}; 431 }; 432 433 class SpatializationStateChangeCallbackImpl : public AudioSpatializationStateChangeCallback { 434 public: 435 SpatializationStateChangeCallbackImpl(); 436 virtual ~SpatializationStateChangeCallbackImpl(); 437 438 void OnSpatializationStateChange(const AudioSpatializationState &spatializationState) override; 439 void SetRendererInClientPtr(std::shared_ptr<RendererInClientInner> rendererInClientPtr); 440 private: 441 std::weak_ptr<RendererInClientInner> rendererInClientPtr_; 442 }; 443 } // namespace AudioStandard 444 } // namespace OHOS 445 #endif // RENDERER_IN_SERVER_H 446