diff --git a/interfaces/inner_api/native/audiocommon/include/audio_info.h b/interfaces/inner_api/native/audiocommon/include/audio_info.h index a3a61a0ec6946ccca5432c1440b31f044826578e..3623c017a81e6b4d30af9235cb33508f69032b1d 100644 --- a/interfaces/inner_api/native/audiocommon/include/audio_info.h +++ b/interfaces/inner_api/native/audiocommon/include/audio_info.h @@ -279,17 +279,23 @@ struct AudioRendererInfo { ContentType contentType = CONTENT_TYPE_UNKNOWN; StreamUsage streamUsage = STREAM_USAGE_UNKNOWN; int32_t rendererFlags = 0; + bool spatializationEnabled = false; + bool headTrackingEnabled = false; bool Marshalling(Parcel &parcel) const { return parcel.WriteInt32(static_cast(contentType)) && parcel.WriteInt32(static_cast(streamUsage)) - && parcel.WriteInt32(rendererFlags); + && parcel.WriteInt32(rendererFlags) + && parcel.WriteBool(spatializationEnabled) + && parcel.WriteBool(headTrackingEnabled); } void Unmarshalling(Parcel &parcel) { contentType = static_cast(parcel.ReadInt32()); streamUsage = static_cast(parcel.ReadInt32()); rendererFlags = parcel.ReadInt32(); + spatializationEnabled = parcel.ReadBool(); + headTrackingEnabled = parcel.ReadBool(); } }; diff --git a/services/audio_service/client/include/ipc_stream_proxy.h b/services/audio_service/client/include/ipc_stream_proxy.h index 37329a403682528d400b241b54e4790e2367c67e..0459e8519537ea348853349257cfff28436d0568 100644 --- a/services/audio_service/client/include/ipc_stream_proxy.h +++ b/services/audio_service/client/include/ipc_stream_proxy.h @@ -77,6 +77,8 @@ public: uint64_t &cacheTimeDsp, uint64_t &cacheTimePa) override; // renderer only int32_t OffloadSetVolume(float volume) override; // renderer only + + int32_t UpdateSpatializationState(bool spatializationEnabled, bool headTrackingEnabled) override; // renderer only private: static inline BrokerDelegator delegator_; }; diff --git a/services/audio_service/client/src/ipc_stream_proxy.cpp b/services/audio_service/client/src/ipc_stream_proxy.cpp index d38a928bdcaeddeb884e84a33263f61e93d595e5..707e93d9cee7af8f3370254b30902e445044b7a8 100644 --- a/services/audio_service/client/src/ipc_stream_proxy.cpp +++ b/services/audio_service/client/src/ipc_stream_proxy.cpp @@ -435,5 +435,22 @@ int32_t IpcStreamProxy::OffloadSetVolume(float volume) return ret; } + +int32_t IpcStreamProxy::UpdateSpatializationState(bool spatializationEnabled, bool headTrackingEnabled) +{ + MessageParcel data; + MessageParcel reply; + MessageOption option; + + CHECK_AND_RETURN_RET_LOG(data.WriteInterfaceToken(GetDescriptor()), ERROR, "Write descriptor failed!"); + + data.WriteBool(spatializationEnabled); + data.WriteBool(headTrackingEnabled); + int ret = Remote()->SendRequest(IpcStreamMsg::ON_UPDATE_SPATIALIZATION_STATE, data, reply, option); + CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, ret, "failed, ipc error: %{public}d", ret); + ret = reply.ReadInt32(); + CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "failed, error: %{public}d", ret); + return ret; +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_service/client/src/renderer_in_client.cpp b/services/audio_service/client/src/renderer_in_client.cpp index 63e2a398c0a9c61ad1eb05757502bce493a89f9b..e26cd32d527d661d8641eb89c505f2a48f10d189 100644 --- a/services/audio_service/client/src/renderer_in_client.cpp +++ b/services/audio_service/client/src/renderer_in_client.cpp @@ -50,6 +50,8 @@ #include "callback_handler.h" #include "audio_speed.h" #include "audio_spatial_channel_converter.h" +#include "audio_policy_manager.h" +#include "audio_spatialization_manager.h" namespace OHOS { namespace AudioStandard { @@ -74,6 +76,7 @@ static const int32_t SHORT_TIMEOUT_IN_MS = 20; // ms static constexpr int CB_QUEUE_CAPACITY = 3; constexpr int32_t MAX_BUFFER_SIZE = 100000; } +class SpatializationStateChangeCallbackImpl; class RendererInClientInner : public RendererInClient, public IStreamListener, public IHandler, public std::enable_shared_from_this { public: @@ -203,6 +206,8 @@ public: void HandleRenderMarkReachedEvent(int64_t rendererMarkPosition); void HandleRenderPeriodReachedEvent(int64_t rendererPeriodNumber); + void OnSpatializationStateChange(const AudioSpatializationState &spatializationState); + private: void RegisterTracker(const std::shared_ptr &proxyObj); void UpdateTracker(const std::string &updateCase); @@ -227,6 +232,11 @@ private: // for callback mode. Check status if not running, wait for start or release. bool WaitForRunning(); int32_t WriteInner(uint8_t *buffer, size_t bufferSize); + + int32_t RegisterSpatializationStateEventListener(); + + int32_t UnregisterSpatializationStateEventListener(uint32_t sessionID); + private: AudioStreamType eStreamType_; int32_t appUid_; @@ -344,6 +354,12 @@ private: uint64_t offloadStartReadPos_ = 0; int64_t offloadStartHandleTime_ = 0; + std::string spatializationEnabled_ = "Invalid"; + std::string headTrackingEnabled_ = "Invalid"; + uint32_t spatializationRegisteredSessionID_ = 0; + bool firstSpatializationRegistered_ = true; + std::shared_ptr spatializationStateChangeCallback_ = nullptr; + enum { STATE_CHANGE_EVENT = 0, RENDERER_MARK_REACHED_EVENT, @@ -367,6 +383,17 @@ private: }; }; +class SpatializationStateChangeCallbackImpl : public AudioSpatializationStateChangeCallback { +public: + SpatializationStateChangeCallbackImpl(); + virtual ~SpatializationStateChangeCallbackImpl(); + + void OnSpatializationStateChange(const AudioSpatializationState &spatializationState) override; + void SetRendererInClientPtr(std::shared_ptr rendererInClientPtr); +private: + std::weak_ptr rendererInClientPtr_; +}; + std::shared_ptr RendererInClient::GetInstance(AudioStreamType eStreamType, int32_t appUid) { return std::make_shared(eStreamType, appUid); @@ -438,6 +465,10 @@ void RendererInClientInner::SetRendererInfo(const AudioRendererInfo &rendererInf rendererInfo_.streamUsage == STREAM_USAGE_NOTIFICATION) { effectMode_ = EFFECT_NONE; } + AudioSpatializationState spatializationState = + AudioPolicyManager::GetInstance().GetSpatializationState(rendererInfo_.streamUsage); + rendererInfo_.spatializationEnabled = spatializationState.spatializationEnabled; + rendererInfo_.headTrackingEnabled = spatializationState.headTrackingEnabled; AUDIO_INFO_LOG("SetRendererInfo with flag %{public}d", rendererInfo_.rendererFlags); } @@ -522,6 +553,7 @@ int32_t RendererInClientInner::SetAudioStreamInfo(const AudioStreamParams info, DumpFileUtil::OpenDumpFile(DUMP_CLIENT_PARA, dumpOutFile_, &dumpOutFd_); RegisterTracker(proxyObj); + RegisterSpatializationStateEventListener(); return SUCCESS; } @@ -2083,6 +2115,67 @@ IAudioStream::StreamClass RendererInClientInner::GetStreamClass() { return PA_STREAM; } + +void RendererInClientInner::OnSpatializationStateChange(const AudioSpatializationState &spatializationState) +{ + CHECK_AND_RETURN_LOG(ipcStream_ != nullptr, "Object ipcStream is nullptr"); + CHECK_AND_RETURN_LOG(ipcStream_->UpdateSpatializationState(spatializationState.spatializationEnabled, + spatializationState.headTrackingEnabled) == SUCCESS, "Update spatialization state failed"); +} + +int32_t RendererInClientInner::RegisterSpatializationStateEventListener() +{ + if (firstSpatializationRegistered_) { + firstSpatializationRegistered_ = false; + } else { + UnregisterSpatializationStateEventListener(spatializationRegisteredSessionID_); + } + + if (!spatializationStateChangeCallback_) { + spatializationStateChangeCallback_ = std::make_shared(); + CHECK_AND_RETURN_RET_LOG(spatializationStateChangeCallback_, ERROR, "Memory Allocation Failed !!"); + } + spatializationStateChangeCallback_->SetRendererInClientPtr(shared_from_this()); + + int32_t ret = AudioPolicyManager::GetInstance().RegisterSpatializationStateEventListener( + sessionId_, rendererInfo_.streamUsage, spatializationStateChangeCallback_); + CHECK_AND_RETURN_RET_LOG(ret == 0, ERROR, "RegisterSpatializationStateEventListener failed"); + spatializationRegisteredSessionID_ = sessionId_; + + return SUCCESS; +} + +int32_t RendererInClientInner::UnregisterSpatializationStateEventListener(uint32_t sessionID) +{ + int32_t ret = AudioPolicyManager::GetInstance().UnregisterSpatializationStateEventListener(sessionID); + CHECK_AND_RETURN_RET_LOG(ret == 0, ERROR, "UnregisterSpatializationStateEventListener failed"); + return SUCCESS; +} + +SpatializationStateChangeCallbackImpl::SpatializationStateChangeCallbackImpl() +{ + AUDIO_INFO_LOG("Instance create"); +} + +SpatializationStateChangeCallbackImpl::~SpatializationStateChangeCallbackImpl() +{ + AUDIO_INFO_LOG("Instance destory"); +} + +void SpatializationStateChangeCallbackImpl::SetRendererInClientPtr( + std::shared_ptr rendererInClientPtr) +{ + rendererInClientPtr_ = rendererInClientPtr; +} + +void SpatializationStateChangeCallbackImpl::OnSpatializationStateChange( + const AudioSpatializationState &spatializationState) +{ + std::shared_ptr rendererInClient = rendererInClientPtr_.lock(); + if (rendererInClient != nullptr) { + rendererInClient->OnSpatializationStateChange(spatializationState); + } +} } // namespace AudioStandard } // namespace OHOS #endif // FAST_AUDIO_STREAM_H diff --git a/services/audio_service/common/include/ipc_stream.h b/services/audio_service/common/include/ipc_stream.h index 129a25c9ab41dea63defe0ff8097c8815e54f58e..06b1694af04590778afc76fd27a2e3f71f38092e 100644 --- a/services/audio_service/common/include/ipc_stream.h +++ b/services/audio_service/common/include/ipc_stream.h @@ -85,6 +85,8 @@ public: virtual int32_t OffloadSetVolume(float volume) = 0; // renderer only + virtual int32_t UpdateSpatializationState(bool spatializationEnabled, bool headTrackingEnabled) = 0; // rendererOnly + // IPC code. enum IpcStreamMsg : uint32_t { ON_REGISTER_STREAM_LISTENER = 0, @@ -112,6 +114,7 @@ public: ON_UNSET_OFFLOAD_MODE, ON_GET_OFFLOAD_APPROXIMATELY_CACHE_TIME, ON_SET_OFFLOAD_VOLUME, + ON_UPDATE_SPATIALIZATION_STATE, IPC_STREAM_MAX_MSG }; diff --git a/services/audio_service/common/src/audio_process_config.cpp b/services/audio_service/common/src/audio_process_config.cpp index 0f0c91d8d08b8e760e3d5291814f97cd94eedb9b..bbf6af16e487e745b349c493f5e6e08838e46149 100644 --- a/services/audio_service/common/src/audio_process_config.cpp +++ b/services/audio_service/common/src/audio_process_config.cpp @@ -45,6 +45,8 @@ int32_t ProcessConfig::WriteConfigToParcel(const AudioProcessConfig &config, Mes parcel.WriteInt32(config.rendererInfo.contentType); parcel.WriteInt32(config.rendererInfo.streamUsage); parcel.WriteInt32(config.rendererInfo.rendererFlags); + parcel.WriteBool(config.rendererInfo.spatializationEnabled); + parcel.WriteBool(config.rendererInfo.headTrackingEnabled); //AudioPrivacyType parcel.WriteInt32(config.privacyType); @@ -84,6 +86,8 @@ int32_t ProcessConfig::ReadConfigFromParcel(AudioProcessConfig &config, MessageP config.rendererInfo.contentType = static_cast(parcel.ReadInt32()); config.rendererInfo.streamUsage = static_cast(parcel.ReadInt32()); config.rendererInfo.rendererFlags = parcel.ReadInt32(); + config.rendererInfo.spatializationEnabled = parcel.ReadBool(); + config.rendererInfo.headTrackingEnabled = parcel.ReadBool(); //AudioPrivacyType config.privacyType = static_cast(parcel.ReadInt32()); diff --git a/services/audio_service/server/include/i_renderer_stream.h b/services/audio_service/server/include/i_renderer_stream.h index ce9a5c8faa1cb48a30d9974e584e47a312434863..a3724a09badacf0e78aaa23eea86fcaead7fd7f3 100644 --- a/services/audio_service/server/include/i_renderer_stream.h +++ b/services/audio_service/server/include/i_renderer_stream.h @@ -53,6 +53,7 @@ public: uint64_t &cacheTimeDsp, uint64_t &cacheTimePa) = 0; virtual int32_t OffloadSetVolume(float volume) = 0; virtual size_t GetWritableSize() = 0; + virtual int32_t UpdateSpatializationState(bool spatializationEnabled, bool headTrackingEnabled) = 0; }; } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_service/server/include/ipc_stream_in_server.h b/services/audio_service/server/include/ipc_stream_in_server.h index 28da2267b38ea1eda11ad49cbbf97e8f5027f5e0..4cd2f9e7ee844aecbe3a535d60cb9924eeb6671c 100644 --- a/services/audio_service/server/include/ipc_stream_in_server.h +++ b/services/audio_service/server/include/ipc_stream_in_server.h @@ -100,6 +100,8 @@ public: int32_t OffloadSetVolume(float volume) override; // renderer only + int32_t UpdateSpatializationState(bool spatializationEnabled, bool headTrackingEnabled) override; // renderer only + private: int32_t ConfigRenderer(); int32_t ConfigCapturer(); diff --git a/services/audio_service/server/include/ipc_stream_stub.h b/services/audio_service/server/include/ipc_stream_stub.h index a217df0d46a4e21ebadf51b1077caac0f4ca6f29..fd2ee871aa429abbc561ad10fc17591cbfa9cbda 100644 --- a/services/audio_service/server/include/ipc_stream_stub.h +++ b/services/audio_service/server/include/ipc_stream_stub.h @@ -56,6 +56,8 @@ private: int32_t HandleGetOffloadApproximatelyCacheTime(MessageParcel &data, MessageParcel &reply); int32_t HandleOffloadSetVolume(MessageParcel &data, MessageParcel &reply); + int32_t HandleUpdateSpatializationState(MessageParcel &data, MessageParcel &reply); + using HandlerFunc = int32_t(IpcStreamStub::*)(MessageParcel &data, MessageParcel &reply); // Using the same order in IpcStreamMsg::Code when add func! static inline HandlerFunc funcList_[IpcStreamMsg::IPC_STREAM_MAX_MSG] = { @@ -84,6 +86,7 @@ private: &IpcStreamStub::HandleUnsetOffloadMode, &IpcStreamStub::HandleGetOffloadApproximatelyCacheTime, &IpcStreamStub::HandleOffloadSetVolume, + &IpcStreamStub::HandleUpdateSpatializationState, }; }; } // namespace AudioStandard diff --git a/services/audio_service/server/include/pa_adapter_manager.h b/services/audio_service/server/include/pa_adapter_manager.h index 683776acc9c5e0111ebd91c24d579873850b7b64..b4a6cf63020c2b6f0b145f3ccf96fddda78472c9 100644 --- a/services/audio_service/server/include/pa_adapter_manager.h +++ b/services/audio_service/server/include/pa_adapter_manager.h @@ -82,6 +82,7 @@ private: int32_t InitPaContext(); int32_t HandleMainLoopStart(); pa_stream *InitPaStream(AudioProcessConfig processConfig, uint32_t sessionId, bool isRecording); + bool IsEffectNone(StreamUsage streamUsage); int32_t SetPaProplist(pa_proplist *propList, pa_channel_map &map, AudioProcessConfig &processConfig, const std::string &streamName, uint32_t sessionId); std::shared_ptr CreateRendererStream(AudioProcessConfig processConfig, pa_stream *paStream); diff --git a/services/audio_service/server/include/pa_renderer_stream_impl.h b/services/audio_service/server/include/pa_renderer_stream_impl.h index 78911080320aa876c36346cb7e16f8cf96eec843..3ebb49226ccdaedc250418ff82abb46aff62465c 100644 --- a/services/audio_service/server/include/pa_renderer_stream_impl.h +++ b/services/audio_service/server/include/pa_renderer_stream_impl.h @@ -62,6 +62,8 @@ public: size_t GetWritableSize() override; // offload end + int32_t UpdateSpatializationState(bool spatializationEnabled, bool headTrackingEnabled) override; + private: static void PAStreamWriteCb(pa_stream *stream, size_t length, void *userdata); static void PAStreamMovedCb(pa_stream *stream, void *userdata); diff --git a/services/audio_service/server/include/renderer_in_server.h b/services/audio_service/server/include/renderer_in_server.h index 243dbce1bf70508716b94f0e71d64aebd25915c3..496f9004469b1a06ec3a8e8291c56e994a2dbd6c 100644 --- a/services/audio_service/server/include/renderer_in_server.h +++ b/services/audio_service/server/include/renderer_in_server.h @@ -57,6 +57,7 @@ public: int32_t GetOffloadApproximatelyCacheTime(uint64_t ×tamp, uint64_t &paWriteIndex, uint64_t &cacheTimeDsp, uint64_t &cacheTimePa); int32_t OffloadSetVolume(float volume); + int32_t UpdateSpatializationState(bool spatializationEnabled, bool headTrackingEnabled); int32_t Init(); int32_t ConfigServerBuffer(); diff --git a/services/audio_service/server/src/ipc_stream_in_server.cpp b/services/audio_service/server/src/ipc_stream_in_server.cpp index c5b6b4bca1eb5e891424af8b1e34d5a375fdaba7..06af1ce7a9ac743c810a185879faae895f5c6dae 100644 --- a/services/audio_service/server/src/ipc_stream_in_server.cpp +++ b/services/audio_service/server/src/ipc_stream_in_server.cpp @@ -370,5 +370,15 @@ int32_t IpcStreamInServer::OffloadSetVolume(float volume) } return rendererInServer_->OffloadSetVolume(volume); } + +int32_t IpcStreamInServer::UpdateSpatializationState(bool spatializationEnabled, bool headTrackingEnabled) +{ + if (mode_ != AUDIO_MODE_PLAYBACK || rendererInServer_ == nullptr) { + AUDIO_ERR_LOG("failed, invalid mode: %{public}d, or rendererInServer_ is null: %{public}d,", + static_cast(mode_), rendererInServer_ == nullptr); + return ERR_OPERATION_FAILED; + } + return rendererInServer_->UpdateSpatializationState(spatializationEnabled, headTrackingEnabled); +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_service/server/src/ipc_stream_stub.cpp b/services/audio_service/server/src/ipc_stream_stub.cpp index 2d125a1e9d0ed4c37201afb90b46d5b1fc00a358..6b717a9f545c69ed2893faddb07fd0df9402426e 100644 --- a/services/audio_service/server/src/ipc_stream_stub.cpp +++ b/services/audio_service/server/src/ipc_stream_stub.cpp @@ -272,5 +272,13 @@ int32_t IpcStreamStub::HandleOffloadSetVolume(MessageParcel &data, MessageParcel return AUDIO_OK; } + +int32_t IpcStreamStub::HandleUpdateSpatializationState(MessageParcel &data, MessageParcel &reply) +{ + bool spatializationEnabled = data.ReadBool(); + bool headTrackingEnabled = data.ReadBool(); + reply.WriteInt32(UpdateSpatializationState(spatializationEnabled, headTrackingEnabled)); + return AUDIO_OK; +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_service/server/src/pa_adapter_manager.cpp b/services/audio_service/server/src/pa_adapter_manager.cpp index 6d6049695397ef850d28bf4f27c44a97e13bc39a..6213a53b147e85bfc13a701b4eaf2b66cf505181 100644 --- a/services/audio_service/server/src/pa_adapter_manager.cpp +++ b/services/audio_service/server/src/pa_adapter_manager.cpp @@ -338,6 +338,16 @@ pa_stream *PaAdapterManager::InitPaStream(AudioProcessConfig processConfig, uint return paStream; } +bool PaAdapterManager::IsEffectNone(StreamUsage streamUsage) +{ + if (streamUsage == STREAM_USAGE_SYSTEM || streamUsage == STREAM_USAGE_DTMF || + streamUsage == STREAM_USAGE_ENFORCED_TONE || streamUsage == STREAM_USAGE_ULTRASONIC || + streamUsage == STREAM_USAGE_NAVIGATION || streamUsage == STREAM_USAGE_NOTIFICATION) { + return true; + } + return false; +} + void PaAdapterManager::SetHighResolution(pa_proplist *propList, AudioProcessConfig &processConfig) { bool isHighResolution = PolicyHandler::GetInstance().GetHighResolutionExist(); @@ -359,13 +369,6 @@ void PaAdapterManager::SetHighResolution(pa_proplist *propList, AudioProcessConf int32_t PaAdapterManager::SetPaProplist(pa_proplist *propList, pa_channel_map &map, AudioProcessConfig &processConfig, const std::string &streamName, uint32_t sessionId) { - bool isEffectNone = false; - StreamUsage mStreamUsage = processConfig.rendererInfo.streamUsage; - if (mStreamUsage == STREAM_USAGE_SYSTEM || mStreamUsage == STREAM_USAGE_DTMF || - mStreamUsage == STREAM_USAGE_ENFORCED_TONE || mStreamUsage == STREAM_USAGE_ULTRASONIC || - mStreamUsage == STREAM_USAGE_NAVIGATION || mStreamUsage == STREAM_USAGE_NOTIFICATION) { - isEffectNone = true; - } // for remote audio device router filter pa_proplist_sets(propList, "stream.sessionID", std::to_string(sessionId).c_str()); pa_proplist_sets(propList, "stream.client.uid", std::to_string(processConfig.appInfo.appUid).c_str()); @@ -374,7 +377,8 @@ int32_t PaAdapterManager::SetPaProplist(pa_proplist *propList, pa_channel_map &m pa_proplist_sets(propList, "media.name", streamName.c_str()); const std::string effectSceneName = GetEffectSceneName(processConfig.streamType); pa_proplist_sets(propList, "scene.type", effectSceneName.c_str()); - pa_proplist_sets(propList, "scene.mode", isEffectNone ? "EFFECT_NONE" : "EFFECT_DEFAULT"); + pa_proplist_sets(propList, "scene.mode", + IsEffectNone(processConfig.rendererInfo.streamUsage) ? "EFFECT_NONE" : "EFFECT_DEFAULT"); float mVolumeFactor = 1.0f; float mPowerVolumeFactor = 1.0f; pa_proplist_sets(propList, "stream.volumeFactor", std::to_string(mVolumeFactor).c_str()); @@ -385,10 +389,13 @@ int32_t PaAdapterManager::SetPaProplist(pa_proplist *propList, pa_channel_map &m if (processConfig.audioMode == AUDIO_MODE_PLAYBACK) { pa_proplist_sets(propList, "stream.flush", "false"); - pa_proplist_sets(propList, "spatialization.enabled", "0"); AudioPrivacyType privacyType = processConfig.privacyType; pa_proplist_sets(propList, "stream.privacyType", std::to_string(privacyType).c_str()); pa_proplist_sets(propList, "stream.usage", std::to_string(processConfig.rendererInfo.streamUsage).c_str()); + pa_proplist_sets(propList, "spatialization.enabled", + std::to_string(processConfig.rendererInfo.spatializationEnabled).c_str()); + pa_proplist_sets(propList, "headtracking.enabled", + std::to_string(processConfig.rendererInfo.headTrackingEnabled).c_str()); SetHighResolution(propList, processConfig); } else if (processConfig.audioMode == AUDIO_MODE_RECORD) { pa_proplist_sets(propList, "stream.isInnerCapturer", std::to_string(processConfig.isInnerCapturer).c_str()); diff --git a/services/audio_service/server/src/pa_renderer_stream_impl.cpp b/services/audio_service/server/src/pa_renderer_stream_impl.cpp index 3cd2068cb194617bf703a47f607b6f7145f579ab..ec42c1f2c9bfdfc84aa7725c8cc7037cc3eea32b 100644 --- a/services/audio_service/server/src/pa_renderer_stream_impl.cpp +++ b/services/audio_service/server/src/pa_renderer_stream_impl.cpp @@ -777,6 +777,29 @@ int32_t PaRendererStreamImpl::OffloadSetVolume(float volume) return audioRendererSinkInstance->SetVolume(volume, 0); } +int32_t PaRendererStreamImpl::UpdateSpatializationState(bool spatializationEnabled, bool headTrackingEnabled) +{ + PaLockGuard lock(mainloop_); + if (CheckReturnIfStreamInvalid(paStream_, ERR_ILLEGAL_STATE) < 0) { + return ERR_ILLEGAL_STATE; + } + + pa_proplist *propList = pa_proplist_new(); + if (propList == nullptr) { + AUDIO_ERR_LOG("pa_proplist_new failed"); + return ERR_OPERATION_FAILED; + } + + pa_proplist_sets(propList, "spatialization.enabled", std::to_string(spatializationEnabled).c_str()); + pa_proplist_sets(propList, "headtracking.enabled", std::to_string(headTrackingEnabled).c_str()); + pa_operation *updatePropOperation = pa_stream_proplist_update(paStream_, PA_UPDATE_REPLACE, propList, + nullptr, nullptr); + pa_proplist_free(propList); + pa_operation_unref(updatePropOperation); + + return SUCCESS; +} + int32_t PaRendererStreamImpl::OffloadGetPresentationPosition(uint64_t& frames, int64_t& timeSec, int64_t& timeNanoSec) { auto *audioRendererSinkInstance = static_cast (IAudioRendererSink::GetInstance( diff --git a/services/audio_service/server/src/renderer_in_server.cpp b/services/audio_service/server/src/renderer_in_server.cpp index 88029cf1d7c68589685850cda5503d959324bae2..fa76c9738fe3b4ec6cfa65fdf7d3f532e47e9164 100644 --- a/services/audio_service/server/src/renderer_in_server.cpp +++ b/services/audio_service/server/src/renderer_in_server.cpp @@ -550,5 +550,10 @@ int32_t RendererInServer::OffloadSetVolume(float volume) { return stream_->OffloadSetVolume(volume); } + +int32_t RendererInServer::UpdateSpatializationState(bool spatializationEnabled, bool headTrackingEnabled) +{ + return stream_->UpdateSpatializationState(spatializationEnabled, headTrackingEnabled); +} } // namespace AudioStandard } // namespace OHOS