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