1 /* 2 * Copyright (c) 2025 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 16 #ifndef SHARED_AUDIO_RENDERER_WRAPPER_H 17 #define SHARED_AUDIO_RENDERER_WRAPPER_H 18 19 #include <vector> 20 #include <stddef.h> 21 #include <stdint.h> 22 #include <memory> 23 #include <cstring> 24 #include <timestamp.h> 25 #include <mutex> 26 #include "audio_effect.h" 27 #include "audio_stream_change_info.h" 28 #include "audio_renderer.h" 29 30 namespace OHOS { 31 namespace AudioStandard { 32 class SharedAudioRendererWrapper : public AudioRenderer { 33 public: SetAudioPrivacyType(AudioPrivacyType privacyType)34 void SetAudioPrivacyType(AudioPrivacyType privacyType) override 35 { 36 sharedAudioRenderer_->SetAudioPrivacyType(privacyType); 37 } 38 GetAudioPrivacyType()39 AudioPrivacyType GetAudioPrivacyType() override 40 { 41 return sharedAudioRenderer_->GetAudioPrivacyType(); 42 } 43 SetParams(const AudioRendererParams params)44 int32_t SetParams(const AudioRendererParams params) override 45 { 46 return sharedAudioRenderer_->SetParams(params); 47 } 48 SetRendererCallback(const std::shared_ptr<AudioRendererCallback> & callback)49 int32_t SetRendererCallback(const std::shared_ptr<AudioRendererCallback> &callback) override 50 { 51 return sharedAudioRenderer_->SetRendererCallback(callback); 52 } 53 GetParams(AudioRendererParams & params)54 int32_t GetParams(AudioRendererParams ¶ms) const override 55 { 56 return sharedAudioRenderer_->GetParams(params); 57 } 58 GetRendererInfo(AudioRendererInfo & rendererInfo)59 int32_t GetRendererInfo(AudioRendererInfo &rendererInfo) const override 60 { 61 return sharedAudioRenderer_->GetRendererInfo(rendererInfo); 62 } 63 GetStreamInfo(AudioStreamInfo & streamInfo)64 int32_t GetStreamInfo(AudioStreamInfo &streamInfo) const override 65 { 66 return sharedAudioRenderer_->GetStreamInfo(streamInfo); 67 } 68 69 bool Start(StateChangeCmdType cmdType = CMD_FROM_CLIENT) override 70 { 71 return sharedAudioRenderer_->Start(cmdType); 72 } 73 Write(uint8_t * buffer,size_t bufferSize)74 int32_t Write(uint8_t *buffer, size_t bufferSize) override 75 { 76 return sharedAudioRenderer_->Write(buffer, bufferSize); 77 } 78 Write(uint8_t * pcmBuffer,size_t pcmBufferSize,uint8_t * metaBuffer,size_t metaBufferSize)79 int32_t Write(uint8_t *pcmBuffer, size_t pcmBufferSize, uint8_t *metaBuffer, size_t metaBufferSize) override 80 { 81 return sharedAudioRenderer_->Write(pcmBuffer, pcmBufferSize, metaBuffer, metaBufferSize); 82 } 83 GetStatus()84 RendererState GetStatus() const override 85 { 86 return sharedAudioRenderer_->GetStatus(); 87 } 88 GetAudioTime(Timestamp & timestamp,Timestamp::Timestampbase base)89 bool GetAudioTime(Timestamp ×tamp, Timestamp::Timestampbase base) const override 90 { 91 return sharedAudioRenderer_->GetAudioTime(timestamp, base); 92 } 93 GetAudioPosition(Timestamp & timestamp,Timestamp::Timestampbase base)94 bool GetAudioPosition(Timestamp ×tamp, Timestamp::Timestampbase base) override 95 { 96 return sharedAudioRenderer_->GetAudioPosition(timestamp, base); 97 } 98 GetLatency(uint64_t & latency)99 int32_t GetLatency(uint64_t &latency) const override 100 { 101 return sharedAudioRenderer_->GetLatency(latency); 102 } 103 Drain()104 bool Drain() const override 105 { 106 return sharedAudioRenderer_->Drain(); 107 } 108 Flush()109 bool Flush() const override 110 { 111 return sharedAudioRenderer_->Flush(); 112 } 113 114 bool PauseTransitent(StateChangeCmdType cmdType = CMD_FROM_CLIENT) override 115 { 116 return sharedAudioRenderer_->PauseTransitent(cmdType); 117 } 118 119 bool Pause(StateChangeCmdType cmdType = CMD_FROM_CLIENT) override 120 { 121 return sharedAudioRenderer_->Pause(cmdType); 122 } 123 Stop()124 bool Stop() override 125 { 126 return sharedAudioRenderer_->Stop(); 127 } 128 Release()129 bool Release() override 130 { 131 return sharedAudioRenderer_->Release(); 132 } 133 GetBufferSize(size_t & bufferSize)134 int32_t GetBufferSize(size_t &bufferSize) const override 135 { 136 return sharedAudioRenderer_->GetBufferSize(bufferSize); 137 } 138 GetAudioStreamId(uint32_t & sessionID)139 int32_t GetAudioStreamId(uint32_t &sessionID) const override 140 { 141 return sharedAudioRenderer_->GetAudioStreamId(sessionID); 142 } 143 GetFrameCount(uint32_t & frameCount)144 int32_t GetFrameCount(uint32_t &frameCount) const override 145 { 146 return sharedAudioRenderer_->GetFrameCount(frameCount); 147 } 148 SetAudioRendererDesc(AudioRendererDesc audioRendererDesc)149 int32_t SetAudioRendererDesc(AudioRendererDesc audioRendererDesc) override 150 { 151 return sharedAudioRenderer_->SetAudioRendererDesc(audioRendererDesc); 152 } 153 SetStreamType(AudioStreamType audioStreamType)154 int32_t SetStreamType(AudioStreamType audioStreamType) override 155 { 156 return sharedAudioRenderer_->SetStreamType(audioStreamType); 157 } 158 SetVolume(float volume)159 int32_t SetVolume(float volume) const override 160 { 161 return sharedAudioRenderer_->SetVolume(volume); 162 } 163 GetVolume()164 float GetVolume() const override 165 { 166 return sharedAudioRenderer_->GetVolume(); 167 } 168 SetRenderRate(AudioRendererRate renderRate)169 int32_t SetRenderRate(AudioRendererRate renderRate) const override 170 { 171 return sharedAudioRenderer_->SetRenderRate(renderRate); 172 } 173 GetRenderRate()174 AudioRendererRate GetRenderRate() const override 175 { 176 return sharedAudioRenderer_->GetRenderRate(); 177 } 178 SetRendererSamplingRate(uint32_t sampleRate)179 int32_t SetRendererSamplingRate(uint32_t sampleRate) const override 180 { 181 return sharedAudioRenderer_->SetRendererSamplingRate(sampleRate); 182 } 183 GetRendererSamplingRate()184 uint32_t GetRendererSamplingRate() const override 185 { 186 return sharedAudioRenderer_->GetRendererSamplingRate(); 187 } 188 SetRendererPositionCallback(int64_t markPosition,const std::shared_ptr<RendererPositionCallback> & callback)189 int32_t SetRendererPositionCallback(int64_t markPosition, 190 const std::shared_ptr<RendererPositionCallback> &callback) override 191 { 192 return sharedAudioRenderer_->SetRendererPositionCallback(markPosition, callback); 193 } 194 UnsetRendererPositionCallback()195 void UnsetRendererPositionCallback() override 196 { 197 sharedAudioRenderer_->UnsetRendererPositionCallback(); 198 } 199 SetRendererPeriodPositionCallback(int64_t frameNumber,const std::shared_ptr<RendererPeriodPositionCallback> & callback)200 int32_t SetRendererPeriodPositionCallback(int64_t frameNumber, 201 const std::shared_ptr<RendererPeriodPositionCallback> &callback) override 202 { 203 return sharedAudioRenderer_->SetRendererPeriodPositionCallback(frameNumber, callback); 204 } 205 UnsetRendererPeriodPositionCallback()206 void UnsetRendererPeriodPositionCallback() override 207 { 208 sharedAudioRenderer_->UnsetRendererPeriodPositionCallback(); 209 } 210 SetBufferDuration(uint64_t bufferDuration)211 int32_t SetBufferDuration(uint64_t bufferDuration) const override 212 { 213 return sharedAudioRenderer_->SetBufferDuration(bufferDuration); 214 } 215 SetRenderMode(AudioRenderMode renderMode)216 int32_t SetRenderMode(AudioRenderMode renderMode) override 217 { 218 return sharedAudioRenderer_->SetRenderMode(renderMode); 219 } 220 GetRenderMode()221 AudioRenderMode GetRenderMode() const override 222 { 223 return sharedAudioRenderer_->GetRenderMode(); 224 } 225 SetRendererWriteCallback(const std::shared_ptr<AudioRendererWriteCallback> & callback)226 int32_t SetRendererWriteCallback(const std::shared_ptr<AudioRendererWriteCallback> &callback) override 227 { 228 return sharedAudioRenderer_->SetRendererWriteCallback(callback); 229 } 230 SetRendererFirstFrameWritingCallback(const std::shared_ptr<AudioRendererFirstFrameWritingCallback> & callback)231 int32_t SetRendererFirstFrameWritingCallback( 232 const std::shared_ptr<AudioRendererFirstFrameWritingCallback> &callback) override 233 { 234 return sharedAudioRenderer_->SetRendererFirstFrameWritingCallback(callback); 235 } 236 GetBufferDesc(BufferDesc & bufDesc)237 int32_t GetBufferDesc(BufferDesc &bufDesc) override 238 { 239 return sharedAudioRenderer_->GetBufferDesc(bufDesc); 240 } 241 Enqueue(const BufferDesc & bufDesc)242 int32_t Enqueue(const BufferDesc &bufDesc) override 243 { 244 return sharedAudioRenderer_->Enqueue(bufDesc); 245 } 246 Clear()247 int32_t Clear() const override 248 { 249 return sharedAudioRenderer_->Clear(); 250 } 251 GetBufQueueState(BufferQueueState & bufState)252 int32_t GetBufQueueState(BufferQueueState &bufState) const override 253 { 254 return sharedAudioRenderer_->GetBufQueueState(bufState); 255 } 256 SetInterruptMode(InterruptMode mode)257 void SetInterruptMode(InterruptMode mode) override 258 { 259 sharedAudioRenderer_->SetInterruptMode(mode); 260 } 261 SetParallelPlayFlag(bool parallelPlayFlag)262 int32_t SetParallelPlayFlag(bool parallelPlayFlag) override 263 { 264 return sharedAudioRenderer_->SetParallelPlayFlag(parallelPlayFlag); 265 } 266 SetLowPowerVolume(float volume)267 int32_t SetLowPowerVolume(float volume) const override 268 { 269 return sharedAudioRenderer_->SetLowPowerVolume(volume); 270 } 271 GetLowPowerVolume()272 float GetLowPowerVolume() const override 273 { 274 return sharedAudioRenderer_->GetLowPowerVolume(); 275 } 276 SetOffloadAllowed(bool isAllowed)277 int32_t SetOffloadAllowed(bool isAllowed) override 278 { 279 return sharedAudioRenderer_->SetOffloadAllowed(isAllowed); 280 } 281 SetOffloadMode(int32_t state,bool isAppBack)282 int32_t SetOffloadMode(int32_t state, bool isAppBack) const override 283 { 284 return sharedAudioRenderer_->SetOffloadMode(state, isAppBack); 285 } 286 UnsetOffloadMode()287 int32_t UnsetOffloadMode() const override 288 { 289 return sharedAudioRenderer_->UnsetOffloadMode(); 290 } 291 GetSingleStreamVolume()292 float GetSingleStreamVolume() const override 293 { 294 return sharedAudioRenderer_->GetSingleStreamVolume(); 295 } 296 GetMinStreamVolume()297 float GetMinStreamVolume() const override 298 { 299 return sharedAudioRenderer_->GetMinStreamVolume(); 300 } 301 GetMaxStreamVolume()302 float GetMaxStreamVolume() const override 303 { 304 return sharedAudioRenderer_->GetMaxStreamVolume(); 305 } 306 GetUnderflowCount()307 uint32_t GetUnderflowCount() const override 308 { 309 return sharedAudioRenderer_->GetUnderflowCount(); 310 } 311 GetCurrentOutputDevices(AudioDeviceDescriptor & deviceInfo)312 int32_t GetCurrentOutputDevices(AudioDeviceDescriptor &deviceInfo) const override 313 { 314 return sharedAudioRenderer_->GetCurrentOutputDevices(deviceInfo); 315 } 316 GetAudioEffectMode()317 AudioEffectMode GetAudioEffectMode() const override 318 { 319 return sharedAudioRenderer_->GetAudioEffectMode(); 320 } 321 GetFramesWritten()322 int64_t GetFramesWritten() const override 323 { 324 return sharedAudioRenderer_->GetFramesWritten(); 325 } 326 SetAudioEffectMode(AudioEffectMode effectMode)327 int32_t SetAudioEffectMode(AudioEffectMode effectMode) const override 328 { 329 return sharedAudioRenderer_->SetAudioEffectMode(effectMode); 330 } 331 SetAudioRendererErrorCallback(std::shared_ptr<AudioRendererErrorCallback> errorCallback)332 void SetAudioRendererErrorCallback(std::shared_ptr<AudioRendererErrorCallback> errorCallback) override 333 { 334 sharedAudioRenderer_->SetAudioRendererErrorCallback(errorCallback); 335 } 336 RegisterOutputDeviceChangeWithInfoCallback(const std::shared_ptr<AudioRendererOutputDeviceChangeCallback> & callback)337 int32_t RegisterOutputDeviceChangeWithInfoCallback( 338 const std::shared_ptr<AudioRendererOutputDeviceChangeCallback> &callback) override 339 { 340 return sharedAudioRenderer_->RegisterOutputDeviceChangeWithInfoCallback(callback); 341 } 342 UnregisterOutputDeviceChangeWithInfoCallback()343 int32_t UnregisterOutputDeviceChangeWithInfoCallback() override 344 { 345 return sharedAudioRenderer_->UnregisterOutputDeviceChangeWithInfoCallback(); 346 } 347 UnregisterOutputDeviceChangeWithInfoCallback(const std::shared_ptr<AudioRendererOutputDeviceChangeCallback> & callback)348 int32_t UnregisterOutputDeviceChangeWithInfoCallback( 349 const std::shared_ptr<AudioRendererOutputDeviceChangeCallback> &callback) override 350 { 351 return sharedAudioRenderer_->UnregisterOutputDeviceChangeWithInfoCallback(callback); 352 } 353 RegisterAudioPolicyServerDiedCb(const int32_t clientPid,const std::shared_ptr<AudioRendererPolicyServiceDiedCallback> & callback)354 int32_t RegisterAudioPolicyServerDiedCb(const int32_t clientPid, 355 const std::shared_ptr<AudioRendererPolicyServiceDiedCallback> &callback) override 356 { 357 return sharedAudioRenderer_->RegisterAudioPolicyServerDiedCb(clientPid, callback); 358 } 359 UnregisterAudioPolicyServerDiedCb(const int32_t clientPid)360 int32_t UnregisterAudioPolicyServerDiedCb(const int32_t clientPid) override 361 { 362 return sharedAudioRenderer_->UnregisterAudioPolicyServerDiedCb(clientPid); 363 } 364 SetChannelBlendMode(ChannelBlendMode blendMode)365 int32_t SetChannelBlendMode(ChannelBlendMode blendMode) override 366 { 367 return sharedAudioRenderer_->SetChannelBlendMode(blendMode); 368 } 369 SetVolumeWithRamp(float volume,int32_t duration)370 int32_t SetVolumeWithRamp(float volume, int32_t duration) override 371 { 372 return sharedAudioRenderer_->SetVolumeWithRamp(volume, duration); 373 } 374 SetPreferredFrameSize(int32_t frameSize)375 void SetPreferredFrameSize(int32_t frameSize) override 376 { 377 sharedAudioRenderer_->SetPreferredFrameSize(frameSize); 378 } 379 SetSpeed(float speed)380 int32_t SetSpeed(float speed) override 381 { 382 return sharedAudioRenderer_->SetSpeed(speed); 383 } 384 GetSpeed()385 float GetSpeed() override 386 { 387 return sharedAudioRenderer_->GetSpeed(); 388 } 389 IsOffloadEnable()390 bool IsOffloadEnable() override 391 { 392 return sharedAudioRenderer_->IsOffloadEnable(); 393 } 394 IsFastRenderer()395 bool IsFastRenderer() override 396 { 397 return sharedAudioRenderer_->IsFastRenderer(); 398 } 399 SetSilentModeAndMixWithOthers(bool on)400 void SetSilentModeAndMixWithOthers(bool on) override 401 { 402 sharedAudioRenderer_->SetSilentModeAndMixWithOthers(on); 403 } 404 GetSilentModeAndMixWithOthers()405 bool GetSilentModeAndMixWithOthers() override 406 { 407 return sharedAudioRenderer_->GetSilentModeAndMixWithOthers(); 408 } 409 EnableVoiceModemCommunicationStartStream(bool enable)410 void EnableVoiceModemCommunicationStartStream(bool enable) override 411 { 412 sharedAudioRenderer_->EnableVoiceModemCommunicationStartStream(enable); 413 } 414 IsNoStreamRenderer()415 bool IsNoStreamRenderer() const override 416 { 417 return sharedAudioRenderer_->IsNoStreamRenderer(); 418 } 419 SetDefaultOutputDevice(DeviceType deviceType)420 int32_t SetDefaultOutputDevice(DeviceType deviceType) override 421 { 422 return sharedAudioRenderer_->SetDefaultOutputDevice(deviceType); 423 } 424 425 bool Mute(StateChangeCmdType cmdType = CMD_FROM_CLIENT) const override 426 { 427 return sharedAudioRenderer_->Mute(cmdType); 428 } 429 430 bool Unmute(StateChangeCmdType cmdType = CMD_FROM_CLIENT) const override 431 { 432 return sharedAudioRenderer_->Unmute(cmdType); 433 } 434 GetAudioTimestampInfo(Timestamp & timestamp,Timestamp::Timestampbase base)435 int32_t GetAudioTimestampInfo(Timestamp ×tamp, Timestamp::Timestampbase base) const override 436 { 437 return sharedAudioRenderer_->GetAudioTimestampInfo(timestamp, base); 438 } 439 SharedAudioRendererWrapper(std::shared_ptr<AudioRenderer> renderer)440 explicit SharedAudioRendererWrapper(std::shared_ptr<AudioRenderer> renderer) : sharedAudioRenderer_(renderer) 441 442 { 443 } 444 445 ~SharedAudioRendererWrapper() override = default; 446 447 SharedAudioRendererWrapper(const SharedAudioRendererWrapper &) = delete; 448 SharedAudioRendererWrapper &operator=(const SharedAudioRendererWrapper &) = delete; 449 SharedAudioRendererWrapper(SharedAudioRendererWrapper &&) = delete; 450 SharedAudioRendererWrapper &operator=(SharedAudioRendererWrapper &&) = delete; 451 private: 452 std::shared_ptr<AudioRenderer> sharedAudioRenderer_ = nullptr; 453 }; 454 } // namespace AudioStandard 455 } // namespace OHOS 456 #endif // SHARED_AUDIO_RENDERER_WRAPPER_H