• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_channel_blend.h"
25 #include "audio_server_death_recipient.h"
26 #include "audio_stream_tracker.h"
27 #include "audio_system_manager.h"
28 #include "audio_utils.h"
29 #include "ipc_stream_listener_impl.h"
30 #include "ipc_stream_listener_stub.h"
31 #include "iipc_stream.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 #include "istandard_audio_service.h"
41 
42 namespace OHOS {
43 namespace AudioStandard {
44 namespace {
45 const int32_t LOG_COUNT_LIMIT = 200;
46 } // namespace
47 class SpatializationStateChangeCallbackImpl;
48 
49 class RendererInClientInner : public RendererInClient, public IStreamListener, public IHandler,
50     public std::enable_shared_from_this<RendererInClientInner> {
51 public:
52     RendererInClientInner(AudioStreamType eStreamType, int32_t appUid);
53     ~RendererInClientInner();
54 
55     // IStreamListener
56     int32_t OnOperationHandled(Operation operation, int64_t result) override;
57 
58     // IAudioStream
59     void SetClientID(int32_t clientPid, int32_t clientUid, uint32_t appTokenId, uint64_t fullTokenId) override;
60 
61     int32_t UpdatePlaybackCaptureConfig(const AudioPlaybackCaptureConfig &config) override;
62     void SetRendererInfo(const AudioRendererInfo &rendererInfo) override;
63     void GetRendererInfo(AudioRendererInfo &rendererInfo) override;
64     void SetCapturerInfo(const AudioCapturerInfo &capturerInfo) override;
65     int32_t SetAudioStreamInfo(const AudioStreamParams info,
66         const std::shared_ptr<AudioClientTracker> &proxyObj,
67         const AudioPlaybackCaptureConfig &config = AudioPlaybackCaptureConfig()) override;
68     int32_t GetAudioStreamInfo(AudioStreamParams &info) override;
69     int32_t GetAudioSessionID(uint32_t &sessionID) override;
70     void GetAudioPipeType(AudioPipeType &pipeType) override;
71     State GetState() override;
72     bool GetAudioTime(Timestamp &timestamp, Timestamp::Timestampbase base) override;
73     bool GetAudioPosition(Timestamp &timestamp, Timestamp::Timestampbase base) override;
74     int32_t GetBufferSize(size_t &bufferSize) override;
75     int32_t GetFrameCount(uint32_t &frameCount) override;
76     int32_t GetLatency(uint64_t &latency) override;
77     int32_t SetAudioStreamType(AudioStreamType audioStreamType) override;
78     int32_t SetVolume(float volume) override;
79     float GetVolume() override;
80     int32_t SetLoudnessGain(float loudnessGain) override;
81     float GetLoudnessGain() override;
82     int32_t SetDuckVolume(float volume) override;
83     float GetDuckVolume() override;
84     int32_t SetMute(bool mute, StateChangeCmdType cmdType) override;
85     bool GetMute() override;
86     int32_t SetRenderRate(AudioRendererRate renderRate) override;
87     AudioRendererRate GetRenderRate() override;
88     int32_t SetStreamCallback(const std::shared_ptr<AudioStreamCallback> &callback) override;
89     int32_t SetRendererFirstFrameWritingCallback(
90         const std::shared_ptr<AudioRendererFirstFrameWritingCallback> &callback) override;
91     void OnFirstFrameWriting() override;
92     int32_t SetSpeed(float speed) override;
93     int32_t SetPitch(float pitch) override;
94     float GetSpeed() override;
95 
96     // callback mode api
97     int32_t SetRenderMode(AudioRenderMode renderMode) override;
98     void InitCallbackLoop();
99     AudioRenderMode GetRenderMode() override;
100     int32_t SetRendererWriteCallback(const std::shared_ptr<AudioRendererWriteCallback> &callback) override;
101     int32_t SetCaptureMode(AudioCaptureMode captureMode) override;
102     AudioCaptureMode GetCaptureMode() override;
103     int32_t SetCapturerReadCallback(const std::shared_ptr<AudioCapturerReadCallback> &callback) override;
104     int32_t GetBufferDesc(BufferDesc &bufDesc) override;
105     int32_t GetBufQueueState(BufferQueueState &bufState) override;
106     int32_t Enqueue(const BufferDesc &bufDesc) override;
107     int32_t Clear() override;
108 
109     int32_t SetLowPowerVolume(float volume) override;
110     float GetLowPowerVolume() override;
111     int32_t SetOffloadMode(int32_t state, bool isAppBack) override;
112     int32_t UnsetOffloadMode() override;
113     float GetSingleStreamVolume() override;
114     AudioEffectMode GetAudioEffectMode() override;
115     int32_t SetAudioEffectMode(AudioEffectMode effectMode) override;
116     int64_t GetFramesWritten() override;
117     int64_t GetFramesRead() override;
118     int32_t SetSourceDuration(int64_t duration) override;
119 
120     void SetInnerCapturerState(bool isInnerCapturer) override;
121     void SetWakeupCapturerState(bool isWakeupCapturer) override;
122     void SetCapturerSource(int capturerSource) override;
123     void SetPrivacyType(AudioPrivacyType privacyType) override;
124 
125     // Common APIs
126     bool StartAudioStream(StateChangeCmdType cmdType = CMD_FROM_CLIENT,
127         AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReasonExt::ExtEnum::UNKNOWN) override;
128     bool PauseAudioStream(StateChangeCmdType cmdType = CMD_FROM_CLIENT) override;
129     bool StopAudioStream() override;
130     bool ReleaseAudioStream(bool releaseRunner = true, bool isSwitchStream = false) override;
131     bool FlushAudioStream() override;
132 
133     // Playback related APIs
134     bool DrainAudioStream(bool stopFlag = false) override;
135     int32_t Write(uint8_t *buffer, size_t bufferSize) override;
136     int32_t Write(uint8_t *pcmBuffer, size_t pcmBufferSize, uint8_t *metaBuffer, size_t metaBufferSize) override;
137     void SetPreferredFrameSize(int32_t frameSize) override;
138 
139     // Recording related APIs
140     int32_t Read(uint8_t &buffer, size_t userSize, bool isBlockingRead) override;
141 
142     uint32_t GetUnderflowCount() override;
143     uint32_t GetOverflowCount() override;
144     void SetUnderflowCount(uint32_t underflowCount) override;
145     void SetOverflowCount(uint32_t overflowCount) override;
146 
147     void SetRendererPositionCallback(int64_t markPosition, const std::shared_ptr<RendererPositionCallback> &callback)
148         override;
149     void UnsetRendererPositionCallback() override;
150     void SetRendererPeriodPositionCallback(int64_t periodPosition,
151         const std::shared_ptr<RendererPeriodPositionCallback> &callback) override;
152     void UnsetRendererPeriodPositionCallback() override;
153     void SetCapturerPositionCallback(int64_t markPosition, const std::shared_ptr<CapturerPositionCallback> &callback)
154         override;
155     void UnsetCapturerPositionCallback() override;
156     void SetCapturerPeriodPositionCallback(int64_t periodPosition,
157         const std::shared_ptr<CapturerPeriodPositionCallback> &callback) override;
158     void UnsetCapturerPeriodPositionCallback() override;
159     int32_t SetRendererSamplingRate(uint32_t sampleRate) override;
160     uint32_t GetRendererSamplingRate() override;
161     int32_t SetBufferSizeInMsec(int32_t bufferSizeInMsec) override;
162     int32_t SetChannelBlendMode(ChannelBlendMode blendMode) override;
163     int32_t SetVolumeWithRamp(float volume, int32_t duration) override;
164 
165     void SetStreamTrackerState(bool trackerRegisteredState) override;
166     void GetSwitchInfo(IAudioStream::SwitchInfo& info) override;
167 
168     IAudioStream::StreamClass GetStreamClass() override;
169 
170     static const sptr<IStandardAudioService> GetAudioServerProxy();
171     static void AudioServerDied(pid_t pid, pid_t uid);
172 
173     void OnHandle(uint32_t code, int64_t data) override;
174     void InitCallbackHandler();
175     void SafeSendCallbackEvent(uint32_t eventCode, int64_t data);
176 
177     int32_t StateCmdTypeToParams(int64_t &params, State state, StateChangeCmdType cmdType);
178     int32_t ParamsToStateCmdType(int64_t params, State &state, StateChangeCmdType &cmdType);
179 
180     void SendRenderMarkReachedEvent(int64_t rendererMarkPosition);
181     void SendRenderPeriodReachedEvent(int64_t rendererPeriodSize);
182 
183     void HandleRendererPositionChanges(size_t bytesWritten);
184     void HandleStateChangeEvent(int64_t data);
185     void HandleRenderMarkReachedEvent(int64_t rendererMarkPosition);
186     void HandleRenderPeriodReachedEvent(int64_t rendererPeriodNumber);
187 
188     void OnSpatializationStateChange(const AudioSpatializationState &spatializationState);
189     void UpdateLatencyTimestamp(std::string &timestamp, bool isRenderer) override;
190 
191     void GetStreamSwitchInfo(SwitchInfo &info);
192 
193     bool GetOffloadEnable() override;
194     bool GetSpatializationEnabled() override;
195     bool GetHighResolutionEnabled() override;
196 
197     void SetSilentModeAndMixWithOthers(bool on) override;
198     bool GetSilentModeAndMixWithOthers() override;
199 
200     bool RestoreAudioStream(bool needStoreState = true) override;
201     void JoinCallbackLoop() override;
202 
203     int32_t SetDefaultOutputDevice(const DeviceType defaultOutputDevice, bool skipForce = false) override;
204     FastStatus GetFastStatus() override;
205     DeviceType GetDefaultOutputDevice() override;
206     int32_t GetAudioTimestampInfo(Timestamp &timestamp, Timestamp::Timestampbase base) override;
207 
208     void SetSwitchingStatus(bool isSwitching) override;
209 
210     void GetRestoreInfo(RestoreInfo &restoreInfo) override;
211     void SetRestoreInfo(RestoreInfo &restoreInfo) override;
212     RestoreStatus CheckRestoreStatus() override;
213     RestoreStatus SetRestoreStatus(RestoreStatus restoreStatus) override;
214     void SetSwitchInfoTimestamp(std::vector<std::pair<uint64_t, uint64_t>> lastFramePosAndTimePair,
215         std::vector<std::pair<uint64_t, uint64_t>> lastFramePosAndTimePairWithSpeed) override;
216     void FetchDeviceForSplitStream() override;
217     void SetCallStartByUserTid(pid_t tid) override;
218     void SetCallbackLoopTid(int32_t tid) override;
219     int32_t GetCallbackLoopTid() override;
220     int32_t SetOffloadDataCallbackState(int32_t cbState) override;
221     void NotifyRouteUpdate(uint32_t routeFlag, const std::string &networkId) override;
222     bool GetStopFlag() const override;
223     void SetAudioHapticsSyncId(const int32_t &audioHapticsSyncId) override;
224 
225 private:
226     void RegisterTracker(const std::shared_ptr<AudioClientTracker> &proxyObj);
227     void UpdateTracker(const std::string &updateCase);
228 
229     void  FlushBeforeStart();
230 
231     int32_t DeinitIpcStream();
232 
233     int32_t InitIpcStream();
234 
235     const AudioProcessConfig ConstructConfig();
236 
237     int32_t InitSharedBuffer();
238 
239     int32_t WriteCacheData(uint8_t *buffer, size_t bufferSize, bool speedCached, size_t oriBufferSize);
240 
241     void InitCallbackBuffer(uint64_t bufferDurationInUs);
242     bool 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     bool IsMutePlaying();
250     void MonitorMutePlay(bool isPlayEnd);
251     void ReportWriteMuteEvent(int64_t mutePlayDuration);
252     bool IsInvalidBuffer(uint8_t *buffer, size_t bufferSize);
253     void DfxWriteInterval();
254     void HandleStatusChangeOperation(Operation operation);
255     void UpdateDataLinkState(bool isConnected, bool needNotify);
256 
257     int32_t RegisterSpatializationStateEventListener();
258 
259     int32_t UnregisterSpatializationStateEventListener(uint32_t sessionID);
260 
261     void FirstFrameProcess();
262 
263     void ResetFramePosition();
264 
265     int32_t SetInnerVolume(float volume);
266 
267     bool IsHighResolution() const noexcept;
268 
269     int32_t ProcessWriteInner(BufferDesc &bufferDesc);
270 
271     void InitDirectPipeType();
272 
273     bool DrainAudioStreamInner(bool stopFlag = false);
274 
275     bool ProcessVolume();
276 
277     void RegisterThreadPriorityOnStart(StateChangeCmdType cmdType);
278 
279     void ResetCallbackLoopTid();
280 
281     bool DoHdiSetSpeed(float speed, bool force);
282 
283     int32_t SetSpeedInner(float speed);
284 
285     void WaitForBufferNeedWrite();
286 
287     void UpdatePauseReadIndex();
288 
289     void FlushSpeedBuffer();
290 
291     bool CheckBufferNeedWrite();
292 
293     bool NeedStopFlush();
294 
295     bool CheckBufferValid(const BufferDesc &bufDesc);
296 
297     bool IsRestoreNeeded();
298 private:
299     AudioStreamType eStreamType_ = AudioStreamType::STREAM_DEFAULT;
300     int32_t appUid_ = 0;
301     uint32_t sessionId_ = 0;
302     int32_t clientPid_ = -1;
303     int32_t clientUid_ = -1;
304     uint32_t appTokenId_ = 0;
305     uint64_t fullTokenId_ = 0;
306 
307     std::unique_ptr<AudioStreamTracker> audioStreamTracker_;
308 
309     AudioRendererInfo rendererInfo_ = {};
310     AudioCapturerInfo capturerInfo_ = {}; // not in use
311 
312     AudioPrivacyType privacyType_ = PRIVACY_TYPE_PUBLIC;
313     bool streamTrackerRegistered_ = false;
314 
315     std::atomic<bool> needSetThreadPriority_ = true;
316 
317     AudioStreamParams curStreamParams_ = {0}; // in plan next: replace it with AudioRendererParams
318     AudioStreamParams streamParams_ = {0};
319 
320     // for data process
321     bool isBlendSet_ = false;
322     AudioBlend audioBlend_;
323     VolumeRamp volumeRamp_;
324 
325     // callbacks
326     std::mutex streamCbMutex_;
327     std::weak_ptr<AudioStreamCallback> streamCallback_;
328 
329     size_t cacheSizeInByte_ = 0;
330     uint32_t spanSizeInFrame_ = 0;
331     uint64_t engineTotalSizeInFrame_ = 0;
332     size_t clientSpanSizeInByte_ = 0;
333     size_t sizePerFrameInByte_ = 4; // 16bit 2ch as default
334 
335     uint32_t bufferSizeInMsec_ = 20; // 20ms
336     std::string dumpOutFile_ = "";
337     FILE *dumpOutFd_ = nullptr;
338     mutable int64_t volumeDataCount_ = 0;
339     std::string logUtilsTag_ = "";
340 
341     std::shared_ptr<AudioRendererFirstFrameWritingCallback> firstFrameWritingCb_ = nullptr;
342     std::mutex firstFrameWritingMutex_;
343     std::atomic<bool> hasFirstFrameWrited_ = false;
344 
345     // callback mode releated
346     AudioRenderMode renderMode_ = RENDER_MODE_NORMAL;
347     std::thread callbackLoop_; // thread for callback to client and write.
348     std::mutex loopMutex_;
349     int32_t callbackLoopTid_ = -1;
350     std::mutex callbackLoopTidMutex_;
351     std::condition_variable callbackLoopTidCv_;
352     std::atomic<bool> cbThreadReleased_ = true;
353     std::mutex writeCbMutex_;
354     std::condition_variable cbThreadCv_;
355     std::shared_ptr<AudioRendererWriteCallback> writeCb_ = nullptr;
356     std::mutex cbBufferMutex_;
357     std::condition_variable cbBufferCV_;
358     std::unique_ptr<uint8_t[]> cbBuffer_ {nullptr};
359     size_t cbBufferSize_ = 0;
360     AudioSafeBlockQueue<BufferDesc> cbBufferQueue_; // only one cbBuffer_
361 
362     std::atomic<State> state_ = INVALID;
363     // using this lock when change status_
364     std::mutex statusMutex_;
365     // for status operation wait and notify
366     std::mutex callServerMutex_;
367     std::condition_variable callServerCV_;
368     std::mutex dataConnectionMutex_;
369     std::condition_variable dataConnectionCV_;
370 
371     Operation notifiedOperation_ = MAX_OPERATION_CODE;
372     int64_t notifiedResult_ = 0;
373 
374     float lowPowerVolume_ = 1.0;
375     float duckVolume_ = 1.0;
376     float muteVolume_ = 1.0;
377     std::atomic<StateChangeCmdType> muteCmd_ = CMD_FROM_CLIENT;
378     float clientVolume_ = 1.0;
379     bool silentModeAndMixWithOthers_ = false;
380 
381     float loudnessGain_ = 0.0f;
382 
383     bool flushAfterStop_ = false;
384 
385     uint64_t clientWrittenBytes_ = 0;
386     // ipc stream related
387     AudioProcessConfig clientConfig_;
388     sptr<IpcStreamListenerImpl> listener_ = nullptr;
389     sptr<IIpcStream> ipcStream_ = nullptr;
390     std::shared_ptr<OHAudioBufferBase> clientBuffer_ = nullptr;
391 
392     // buffer handle
393     std::mutex writeMutex_; // used for prevent multi thread call write
394 
395     // Mark reach and period reach callback
396     int64_t totalBytesWritten_ = 0;
397     std::mutex markReachMutex_;
398     bool rendererMarkReached_ = false;
399     int64_t rendererMarkPosition_ = 0;
400     std::shared_ptr<RendererPositionCallback> rendererPositionCallback_ = nullptr;
401 
402     std::mutex periodReachMutex_;
403     int64_t rendererPeriodSize_ = 0;
404     int64_t rendererPeriodWritten_ = 0;
405     std::shared_ptr<RendererPeriodPositionCallback> rendererPeriodPositionCallback_ = nullptr;
406 
407     // Event handler
408     bool runnerReleased_ = false;
409     std::mutex runnerMutex_;
410     std::shared_ptr<CallbackHandler> callbackHandler_ = nullptr;
411 
412     bool paramsIsSet_ = false;
413     AudioRendererRate rendererRate_ = RENDER_RATE_NORMAL;
414     AudioEffectMode effectMode_ = EFFECT_DEFAULT;
415 
416     std::optional<float> realSpeed_ = std::nullopt;
417     float speed_ = 1.0;
418     float hdiSpeed_ = 1.0;
419     std::unique_ptr<uint8_t[]> speedBuffer_ {nullptr};
420     size_t bufferSize_ = 0;
421     std::unique_ptr<AudioSpeed> audioSpeed_ = nullptr;
422     std::atomic<bool> speedEnable_ = false;
423     std::atomic<bool> isHdiSpeed_ = false;
424     std::mutex speedMutex_;
425 
426     std::unique_ptr<AudioSpatialChannelConverter> converter_;
427 
428     std::atomic<int64_t> mutePlayStartTime_ = 0; // realtime
429     std::atomic<bool> mutePlaying_ = false;
430 
431     bool offloadEnable_ = false;
432     uint64_t offloadStartReadPos_ = 0;
433     int64_t offloadStartHandleTime_ = 0;
434 
435     // for getAudioTimeStampInfo
436     std::vector<std::pair<uint64_t, uint64_t>> lastFramePosAndTimePair_ = {
437         Timestamp::Timestampbase::BASESIZE, {0, 0}
438     };
439     std::vector<std::pair<uint64_t, uint64_t>> lastFramePosAndTimePairWithSpeed_ = {
440         Timestamp::Timestampbase::BASESIZE, {0, 0}
441     };
442     std::vector<uint64_t> lastSwitchPosition_ = {0, 0};
443     std::vector<uint64_t> lastSwitchPositionWithSpeed_ = {0, 0};
444 
445     struct WrittenFramesWithSpeed {
446         uint64_t writtenFrames = 0;
447         float speed = 1.0;
448     };
449     std::atomic<WrittenFramesWithSpeed> writtenAtSpeedChange_; // afterSpeed
450     std::atomic<uint64_t> unprocessedFramesBytes_ = 0;
451     std::atomic<uint64_t> totalBytesWrittenAfterFlush_ = 0;
452 
453     std::string traceTag_;
454     std::string spatializationEnabled_ = "Invalid";
455     std::string headTrackingEnabled_ = "Invalid";
456     uint32_t spatializationRegisteredSessionID_ = 0;
457     bool firstSpatializationRegistered_ = true;
458     std::shared_ptr<SpatializationStateChangeCallbackImpl> spatializationStateChangeCallback_ = nullptr;
459     std::time_t startMuteTime_ = 0;
460     bool isUpEvent_ = false;
461     std::shared_ptr<AudioClientTracker> proxyObj_ = nullptr;
462     int64_t preWriteEndTime_ = 0;
463     uint64_t lastFlushReadIndex_ = 0;
464     uint64_t lastSpeedFlushReadIndex_ = 0;
465     bool isDataLinkConnected_ = false;
466 
467     enum {
468         STATE_CHANGE_EVENT = 0,
469         RENDERER_MARK_REACHED_EVENT,
470         RENDERER_PERIOD_REACHED_EVENT,
471         CAPTURER_PERIOD_REACHED_EVENT,
472         CAPTURER_MARK_REACHED_EVENT,
473     };
474 
475     // note that the starting elements should remain the same as the enum State
476     enum : int64_t {
477         HANDLER_PARAM_INVALID = -1,
478         HANDLER_PARAM_NEW = 0,
479         HANDLER_PARAM_PREPARED,
480         HANDLER_PARAM_RUNNING,
481         HANDLER_PARAM_STOPPED,
482         HANDLER_PARAM_RELEASED,
483         HANDLER_PARAM_PAUSED,
484         HANDLER_PARAM_STOPPING,
485         HANDLER_PARAM_RUNNING_FROM_SYSTEM,
486         HANDLER_PARAM_PAUSED_FROM_SYSTEM,
487     };
488 
489     std::mutex setPreferredFrameSizeMutex_;
490     std::optional<int32_t> userSettedPreferredFrameSize_ = std::nullopt;
491 
492     int32_t sleepCount_ = LOG_COUNT_LIMIT;
493     DeviceType defaultOutputDevice_ = DEVICE_TYPE_NONE;
494 
495     std::mutex switchingMutex_;
496     StreamSwitchingInfo switchingInfo_ {false, INVALID};
497 
498     std::mutex lastCallStartByUserTidMutex_;
499     std::optional<pid_t> lastCallStartByUserTid_ = std::nullopt;
500 
501     std::function<uid_t()> uidGetter_ = [] { return getuid(); };
502 };
503 
504 class SpatializationStateChangeCallbackImpl : public AudioSpatializationStateChangeCallback {
505 public:
506     SpatializationStateChangeCallbackImpl();
507     virtual ~SpatializationStateChangeCallbackImpl();
508 
509     void OnSpatializationStateChange(const AudioSpatializationState &spatializationState) override;
510     void SetRendererInClientPtr(std::shared_ptr<RendererInClientInner> rendererInClientPtr);
511 private:
512     std::weak_ptr<RendererInClientInner> rendererInClientPtr_;
513 };
514 } // namespace AudioStandard
515 } // namespace OHOS
516 #endif // RENDERER_IN_SERVER_H
517