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