1 /*
2 * Copyright (c) 2023 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 LOG_TAG
16 #define LOG_TAG "RemoteFastAudioRendererSinkInner"
17 #endif
18
19 #include "remote_fast_audio_renderer_sink.h"
20
21 #include <cinttypes>
22 #include <dlfcn.h>
23 #include <map>
24 #include <sstream>
25 #include "securec.h"
26
27 #include "audio_errors.h"
28 #include "audio_hdi_log.h"
29 #include "audio_utils.h"
30 #include "audio_info.h"
31 #include <v1_0/iaudio_manager.h>
32 #include <v1_0/iaudio_callback.h>
33 #include <v1_0/audio_types.h>
34 #include "ashmem.h"
35 #include "i_audio_renderer_sink.h"
36 #include "i_audio_device_adapter.h"
37 #include "i_audio_device_manager.h"
38
39 using OHOS::HDI::DistributedAudio::Audio::V1_0::IAudioAdapter;
40 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioAdapterDescriptor;
41 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioFormat;
42 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioPort;
43 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioPortDirection;
44 using OHOS::HDI::DistributedAudio::Audio::V1_0::IAudioManager;
45 using OHOS::HDI::DistributedAudio::Audio::V1_0::IAudioRender;
46 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioSampleAttributes;
47 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioDeviceDescriptor;
48 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioCategory;
49 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioRouteNode;
50 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioExtParamKey;
51 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioRoute;
52 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioSceneDescriptor;
53 using OHOS::HDI::DistributedAudio::Audio::V1_0::IAudioCallback;
54 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioPortPin;
55 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioPortType;
56 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioPortRole;
57 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioMmapBufferDescriptor;
58 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioTimeStamp;
59
60 namespace OHOS {
61 namespace AudioStandard {
62 namespace {
63 const int32_t HALF_FACTOR = 2;
64 const uint32_t AUDIO_CHANNELCOUNT = 2;
65 const uint32_t AUDIO_SAMPLE_RATE_48K = 48000;
66 const uint32_t DEEP_BUFFER_RENDER_PERIOD_SIZE = 3840;
67 const uint32_t INT_32_MAX = 0x7fffffff;
68 const uint32_t PCM_8_BIT = 8;
69 const uint32_t PCM_16_BIT = 16;
70 const uint32_t PCM_24_BIT = 24;
71 const uint32_t PCM_32_BIT = 32;
72 const uint32_t REMOTE_FAST_OUTPUT_STREAM_ID = 37; // 13 + 3 * 8
73 const int64_t SECOND_TO_NANOSECOND = 1000000000;
74 const int32_t INVALID_FD = -1;
75 }
76 class RemoteFastAudioRendererSinkInner : public RemoteFastAudioRendererSink, public IAudioDeviceAdapterCallback {
77 public:
78 explicit RemoteFastAudioRendererSinkInner(const std::string &deviceNetworkId);
79 ~RemoteFastAudioRendererSinkInner();
80
81 int32_t Init(const IAudioSinkAttr &attr) override;
82 bool IsInited(void) override;
83 void DeInit(void) override;
84
85 int32_t Start(void) override;
86 int32_t Stop(void) override;
87 int32_t Flush(void) override;
88 int32_t Reset(void) override;
89 int32_t Pause(void) override;
90 int32_t Resume(void) override;
91 int32_t SuspendRenderSink(void) override;
92 int32_t RestoreRenderSink(void) override;
93
94 int32_t RenderFrame(char &data, uint64_t len, uint64_t &writeLen) override;
95 int32_t SetVolume(float left, float right) override;
96 int32_t GetVolume(float &left, float &right) override;
97 int32_t SetVoiceVolume(float volume) override;
98 int32_t GetTransactionId(uint64_t *transactionId) override;
99 int32_t GetLatency(uint32_t *latency) override;
100 int32_t SetAudioScene(AudioScene audioScene, std::vector<DeviceType> &activeDevices) override;
101 int32_t SetOutputRoutes(std::vector<DeviceType> &outputDevices) override;
102 void SetAudioParameter(const AudioParamKey key, const std::string &condition, const std::string &value) override;
103 std::string GetAudioParameter(const AudioParamKey key, const std::string &condition) override;
104 void SetAudioMonoState(bool audioMono) override;
105 void SetAudioBalanceValue(float audioBalance) override;
106 int32_t GetPresentationPosition(uint64_t& frames, int64_t& timeSec, int64_t& timeNanoSec) override;
107 void RegisterParameterCallback(IAudioSinkCallback* callback) override;
108
109 int32_t GetMmapBufferInfo(int &fd, uint32_t &totalSizeInframe, uint32_t &spanSizeInframe,
110 uint32_t &byteSizePerFrame) override;
111 int32_t GetMmapHandlePosition(uint64_t &frames, int64_t &timeSec, int64_t &timeNanoSec) override;
112 int32_t CheckPositionTime();
113
114 void OnAudioParamChange(const std::string &adapterName, const AudioParamKey key, const std::string &condition,
115 const std::string &value) override;
116 float GetMaxAmplitude() override;
117
118 void ResetOutputRouteForDisconnect(DeviceType device) override;
119 int32_t SetPaPower(int32_t flag) override;
120 int32_t SetPriPaPower() override;
121
122 int32_t UpdateAppsUid(const int32_t appsUid[MAX_MIX_CHANNELS], const size_t size) final;
123 int32_t UpdateAppsUid(const std::vector<int32_t> &appsUid) final;
124
125 std::string GetNetworkId();
126 IAudioSinkCallback* GetParamCallback();
127
128 private:
129 int32_t CreateRender(const struct AudioPort &renderPort);
130 void InitAttrs(struct AudioSampleAttributes &attrs);
131 AudioFormat ConvertToHdiFormat(HdiAdapterFormat format);
132 int32_t PrepareMmapBuffer();
133 uint32_t PcmFormatToBits(HdiAdapterFormat format);
134 void ClearRender();
135
136 private:
137 std::atomic<bool> rendererInited_ = false;
138 std::atomic<bool> isRenderCreated_ = false;
139 std::atomic<bool> started_ = false;
140 std::atomic<bool> paused_ = false;
141 float leftVolume_ = 0;
142 float rightVolume_ = 0;
143 std::shared_ptr<IAudioDeviceManager> audioManager_ = nullptr;
144 std::shared_ptr<IAudioDeviceAdapter> audioAdapter_ = nullptr;
145 IAudioSinkCallback *callback_ = nullptr;
146 sptr<IAudioRender> audioRender_ = nullptr;
147 struct AudioPort audioPort_ = {};
148 IAudioSinkAttr attr_ = {};
149 std::string deviceNetworkId_ = "";
150
151 uint32_t bufferTotalFrameSize_ = 0;
152 int32_t bufferFd_ = INVALID_FD;
153 uint32_t frameSizeInByte_ = 1;
154 uint32_t eachReadFrameSize_ = 0;
155 uint32_t renderId_ = 0;
156
157 #ifdef DEBUG_DIRECT_USE_HDI
158 sptr<Ashmem> ashmemSink_ = nullptr;
159 size_t bufferSize_ = 0;
160 #endif
161 };
162
163 std::mutex g_remoteFRSinksMutex;
164 std::map<std::string, RemoteFastAudioRendererSinkInner *> allRFSinks;
GetInstance(const std::string & deviceNetworkId)165 IMmapAudioRendererSink *RemoteFastAudioRendererSink::GetInstance(const std::string &deviceNetworkId)
166 {
167 std::lock_guard<std::mutex> lock(g_remoteFRSinksMutex);
168 AUDIO_INFO_LOG("GetInstance.");
169 CHECK_AND_RETURN_RET_LOG(!deviceNetworkId.empty(), nullptr, "Remote fast render device networkId is null.");
170
171 if (allRFSinks.count(deviceNetworkId)) {
172 return allRFSinks[deviceNetworkId];
173 }
174 RemoteFastAudioRendererSinkInner *audioRenderer =
175 new(std::nothrow) RemoteFastAudioRendererSinkInner(deviceNetworkId);
176 AUDIO_DEBUG_LOG("New daudio remote fast render device networkId: [%{public}s].", deviceNetworkId.c_str());
177 allRFSinks[deviceNetworkId] = audioRenderer;
178 return audioRenderer;
179 }
180
RemoteFastAudioRendererSinkInner(const std::string & deviceNetworkId)181 RemoteFastAudioRendererSinkInner::RemoteFastAudioRendererSinkInner(const std::string &deviceNetworkId)
182 : deviceNetworkId_(deviceNetworkId)
183 {
184 AUDIO_DEBUG_LOG("RemoteFastAudioRendererSinkInner Constract.");
185 }
186
~RemoteFastAudioRendererSinkInner()187 RemoteFastAudioRendererSinkInner::~RemoteFastAudioRendererSinkInner()
188 {
189 if (rendererInited_.load()) {
190 RemoteFastAudioRendererSinkInner::DeInit();
191 }
192 AUDIO_DEBUG_LOG("RemoteFastAudioRendererSink end.");
193 }
194
IsInited()195 bool RemoteFastAudioRendererSinkInner::IsInited()
196 {
197 return rendererInited_.load();
198 }
199
ClearRender()200 void RemoteFastAudioRendererSinkInner::ClearRender()
201 {
202 AUDIO_INFO_LOG("Clear remote fast audio render enter.");
203 rendererInited_.store(false);
204 isRenderCreated_.store(false);
205 started_.store(false);
206 paused_.store(false);
207
208 #ifdef DEBUG_DIRECT_USE_HDI
209 if (ashmemSink_ != nullptr) {
210 ashmemSink_->UnmapAshmem();
211 ashmemSink_->CloseAshmem();
212 ashmemSink_ = nullptr;
213 AUDIO_INFO_LOG("ClearRender: UnInit sink ashmem OK.");
214 }
215 #endif // DEBUG_DIRECT_USE_HDI
216 if (bufferFd_ != INVALID_FD) {
217 CloseFd(bufferFd_);
218 bufferFd_ = INVALID_FD;
219 }
220
221 if (audioAdapter_ != nullptr) {
222 audioAdapter_->DestroyRender(audioRender_, renderId_);
223 audioAdapter_->Release();
224 }
225 audioRender_ = nullptr;
226 audioAdapter_ = nullptr;
227
228 if (audioManager_ != nullptr) {
229 audioManager_->UnloadAdapter(deviceNetworkId_);
230 }
231 audioManager_ = nullptr;
232
233 AudioDeviceManagerFactory::GetInstance().DestoryDeviceManager(REMOTE_DEV_MGR);
234 AUDIO_INFO_LOG("Clear remote audio render end.");
235 }
236
DeInit()237 void RemoteFastAudioRendererSinkInner::DeInit()
238 {
239 std::lock_guard<std::mutex> lock(g_remoteFRSinksMutex);
240 AUDIO_INFO_LOG("RemoteFastAudioRendererSinkInner::DeInit");
241 ClearRender();
242
243 CHECK_AND_RETURN_LOG(allRFSinks.count(this->deviceNetworkId_) > 0,
244 "not find %{public}s", this->deviceNetworkId_.c_str());
245 RemoteFastAudioRendererSink *temp = allRFSinks[this->deviceNetworkId_];
246 allRFSinks.erase(this->deviceNetworkId_);
247 if (temp == nullptr) {
248 AUDIO_ERR_LOG("temp is nullptr");
249 } else {
250 delete temp;
251 }
252 }
253
Init(const IAudioSinkAttr & attr)254 int32_t RemoteFastAudioRendererSinkInner::Init(const IAudioSinkAttr &attr)
255 {
256 AUDIO_INFO_LOG("RemoteFastAudioRendererSinkInner::Init");
257 attr_ = attr;
258 audioManager_ = AudioDeviceManagerFactory::GetInstance().CreatDeviceManager(REMOTE_DEV_MGR);
259 CHECK_AND_RETURN_RET_LOG(audioManager_ != nullptr, ERR_NOT_STARTED, "Init audio manager fail.");
260
261 struct AudioAdapterDescriptor *desc = audioManager_->GetTargetAdapterDesc(deviceNetworkId_, true);
262 CHECK_AND_RETURN_RET_LOG(desc != nullptr, ERR_NOT_STARTED, "Get target adapters descriptor fail.");
263 for (uint32_t port = 0; port < desc->ports.size(); port++) {
264 if (desc->ports[port].portId == AudioPortPin::PIN_OUT_SPEAKER) {
265 audioPort_ = desc->ports[port];
266 break;
267 }
268 CHECK_AND_RETURN_RET_LOG(port != (desc->ports.size() - 1), ERR_INVALID_INDEX,
269 "Not found the audio spk port.");
270 }
271
272 audioAdapter_ = audioManager_->LoadAdapters(deviceNetworkId_, true);
273 CHECK_AND_RETURN_RET_LOG(audioAdapter_ != nullptr, ERR_NOT_STARTED, "Load audio device adapter failed.");
274
275 int32_t ret = audioAdapter_->Init();
276 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Audio adapter init fail, ret %{public}d.", ret);
277
278 ret = CreateRender(audioPort_);
279 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Create render fail, audio port %{public}d, ret %{public}d.",
280 audioPort_.portId, ret);
281
282 rendererInited_.store(true);
283 AUDIO_DEBUG_LOG("RemoteFastAudioRendererSink: Init end.");
284 return SUCCESS;
285 }
286
CreateRender(const struct AudioPort & renderPort)287 int32_t RemoteFastAudioRendererSinkInner::CreateRender(const struct AudioPort &renderPort)
288 {
289 int64_t start = ClockTime::GetCurNano();
290
291 struct AudioSampleAttributes param;
292 InitAttrs(param);
293 param.type = attr_.audioStreamFlag == AUDIO_FLAG_VOIP_FAST ? AudioCategory::AUDIO_MMAP_VOIP :
294 AudioCategory::AUDIO_MMAP_NOIRQ;
295 param.sampleRate = attr_.sampleRate;
296 param.channelCount = attr_.channel;
297 param.format = ConvertToHdiFormat(attr_.format);
298 param.frameSize = PCM_16_BIT * param.channelCount / PCM_8_BIT;
299 param.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (param.frameSize);
300 AUDIO_INFO_LOG("Create render format: %{public}d", param.format);
301
302 struct AudioDeviceDescriptor deviceDesc;
303 deviceDesc.portId = renderPort.portId;
304 deviceDesc.pins = AudioPortPin::PIN_OUT_SPEAKER;
305 deviceDesc.desc = "";
306
307 CHECK_AND_RETURN_RET_LOG(audioAdapter_ != nullptr, ERR_INVALID_HANDLE, "CreateRender: Audio adapter is null.");
308 int32_t ret = audioAdapter_->CreateRender(deviceDesc, param, audioRender_, this, renderId_);
309
310 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS && audioRender_ != nullptr, ret,
311 "AudioDeviceCreateRender failed");
312 if (param.type == AudioCategory::AUDIO_MMAP_NOIRQ || param.type == AudioCategory::AUDIO_MMAP_VOIP) {
313 PrepareMmapBuffer();
314 }
315 isRenderCreated_.store(true);
316 int64_t cost = (ClockTime::GetCurNano() - start) / AUDIO_US_PER_SECOND;
317 AUDIO_DEBUG_LOG("CreateRender cost[%{public}" PRId64 "]ms", cost);
318 return SUCCESS;
319 }
320
PrepareMmapBuffer()321 int32_t RemoteFastAudioRendererSinkInner::PrepareMmapBuffer()
322 {
323 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE, "PrepareMmapBuffer: Audio render is null.");
324
325 int32_t totalBufferInMs = 40; // 5 * (6 + 2 * (1)) = 40ms, the buffer size, not latency.
326 frameSizeInByte_ = PcmFormatToBits(attr_.format) * attr_.channel / PCM_8_BIT;
327 int32_t reqBufferFrameSize = totalBufferInMs * static_cast<int32_t>(attr_.sampleRate / 1000);
328
329 struct AudioMmapBufferDescriptor desc;
330 int32_t ret = audioRender_->ReqMmapBuffer(reqBufferFrameSize, desc);
331 CHECK_AND_RETURN_RET_LOG((ret == SUCCESS), ERR_OPERATION_FAILED,
332 "PrepareMmapBuffer require mmap buffer failed, ret:%{public}d.", ret);
333
334 AUDIO_INFO_LOG("AudioMmapBufferDescriptor memoryFd[%{public}d] totalBufferFrames"
335 "[%{public}d] transferFrameSize[%{public}d] isShareable[%{public}d] offset[%{public}d]",
336 desc.memoryFd, desc.totalBufferFrames, desc.transferFrameSize, desc.isShareable, desc.offset);
337
338 bufferFd_ = desc.memoryFd; // fcntl(fd, 1030,3) after dup?
339 int32_t periodFrameMaxSize = 1920000; // 192khz * 10s
340 CHECK_AND_RETURN_RET_LOG(desc.totalBufferFrames >= 0 && desc.transferFrameSize >= 0 &&
341 desc.transferFrameSize <= periodFrameMaxSize, ERR_OPERATION_FAILED,
342 "ReqMmapBuffer invalid values: totalBufferFrames[%{public}d] transferFrameSize[%{public}d]",
343 desc.totalBufferFrames, desc.transferFrameSize);
344 bufferTotalFrameSize_ = static_cast<uint32_t>(desc.totalBufferFrames); // 1440 ~ 3840
345 eachReadFrameSize_ = static_cast<uint32_t>(desc.transferFrameSize); // 240
346
347 CHECK_AND_RETURN_RET_LOG(frameSizeInByte_ <= ULLONG_MAX / bufferTotalFrameSize_, ERR_OPERATION_FAILED,
348 "BufferSize will overflow!");
349
350 #ifdef DEBUG_DIRECT_USE_HDI
351 bufferSize_ = bufferTotalFrameSize_ * frameSizeInByte_;
352 ashmemSink_ = new Ashmem(bufferFd_, bufferSize_);
353 AUDIO_INFO_LOG("PrepareMmapBuffer create ashmem sink OK, ashmemLen %{public}zu.", bufferSize_);
354 bool tmp = ashmemSink_->MapReadAndWriteAshmem();
355 CHECK_AND_RETURN_RET_LOG(tmp, ERR_OPERATION_FAILED, "PrepareMmapBuffer map ashmem sink failed.");
356 #endif // DEBUG_DIRECT_USE_HDI
357 return SUCCESS;
358 }
359
GetMmapBufferInfo(int & fd,uint32_t & totalSizeInframe,uint32_t & spanSizeInframe,uint32_t & byteSizePerFrame)360 int32_t RemoteFastAudioRendererSinkInner::GetMmapBufferInfo(int &fd, uint32_t &totalSizeInframe,
361 uint32_t &spanSizeInframe, uint32_t &byteSizePerFrame)
362 {
363 CHECK_AND_RETURN_RET_LOG(bufferFd_ != INVALID_FD, ERR_INVALID_HANDLE,
364 "buffer fd has been released!");
365 fd = bufferFd_;
366 totalSizeInframe = bufferTotalFrameSize_;
367 spanSizeInframe = eachReadFrameSize_;
368 byteSizePerFrame = PcmFormatToBits(attr_.format) * attr_.channel / PCM_8_BIT;
369 return SUCCESS;
370 }
371
GetMmapHandlePosition(uint64_t & frames,int64_t & timeSec,int64_t & timeNanoSec)372 int32_t RemoteFastAudioRendererSinkInner::GetMmapHandlePosition(uint64_t &frames, int64_t &timeSec,
373 int64_t &timeNanoSec)
374 {
375 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE,
376 "GetMmapHandlePosition: Audio render is null.");
377
378 struct AudioTimeStamp timestamp;
379 int32_t ret = audioRender_->GetMmapPosition(frames, timestamp);
380 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED,
381 "Hdi GetMmapPosition filed, ret:%{public}d!", ret);
382
383 int64_t maxSec = 9223372036; // (9223372036 + 1) * 10^9 > INT64_MAX, seconds should not bigger than it.
384 CHECK_AND_RETURN_RET_LOG(timestamp.tvSec >= 0 && timestamp.tvSec <= maxSec && timestamp.tvNSec >= 0 &&
385 timestamp.tvNSec <= SECOND_TO_NANOSECOND, ERR_OPERATION_FAILED,
386 "Hdi GetMmapPosition get invaild second:%{public}" PRId64 " or nanosecond:%{public}" PRId64 " !",
387 timestamp.tvSec, timestamp.tvNSec);
388 timeSec = timestamp.tvSec;
389 timeNanoSec = timestamp.tvNSec;
390
391 return SUCCESS;
392 }
393
PcmFormatToBits(HdiAdapterFormat format)394 uint32_t RemoteFastAudioRendererSinkInner::PcmFormatToBits(HdiAdapterFormat format)
395 {
396 switch (format) {
397 case SAMPLE_U8:
398 return PCM_8_BIT;
399 case SAMPLE_S16LE:
400 return PCM_16_BIT;
401 case SAMPLE_S24LE:
402 return PCM_24_BIT;
403 case SAMPLE_S32LE:
404 return PCM_32_BIT;
405 case SAMPLE_F32LE:
406 return PCM_32_BIT;
407 default:
408 return PCM_24_BIT;
409 }
410 }
411
ConvertToHdiFormat(HdiAdapterFormat format)412 AudioFormat RemoteFastAudioRendererSinkInner::ConvertToHdiFormat(HdiAdapterFormat format)
413 {
414 AudioFormat hdiFormat;
415 switch (format) {
416 case SAMPLE_U8:
417 hdiFormat = AudioFormat::AUDIO_FORMAT_TYPE_PCM_8_BIT;
418 break;
419 case SAMPLE_S16:
420 hdiFormat = AudioFormat::AUDIO_FORMAT_TYPE_PCM_16_BIT;
421 break;
422 case SAMPLE_S24:
423 hdiFormat = AudioFormat::AUDIO_FORMAT_TYPE_PCM_24_BIT;
424 break;
425 case SAMPLE_S32:
426 hdiFormat = AudioFormat::AUDIO_FORMAT_TYPE_PCM_32_BIT;
427 break;
428 default:
429 hdiFormat = AudioFormat::AUDIO_FORMAT_TYPE_PCM_16_BIT;
430 break;
431 }
432
433 return hdiFormat;
434 }
435
InitAttrs(struct AudioSampleAttributes & attrs)436 void RemoteFastAudioRendererSinkInner::InitAttrs(struct AudioSampleAttributes &attrs)
437 {
438 /* Initialization of audio parameters for playback */
439 attrs.channelCount = AUDIO_CHANNELCOUNT;
440 attrs.sampleRate = AUDIO_SAMPLE_RATE_48K;
441 attrs.interleaved = 0;
442 attrs.streamId = REMOTE_FAST_OUTPUT_STREAM_ID;
443 attrs.period = DEEP_BUFFER_RENDER_PERIOD_SIZE;
444 attrs.isBigEndian = false;
445 attrs.isSignedData = true;
446 attrs.stopThreshold = INT_32_MAX;
447 attrs.silenceThreshold = 0;
448 }
449
PrintRemoteAttr(const IAudioSinkAttr & attr)450 inline std::string PrintRemoteAttr(const IAudioSinkAttr &attr)
451 {
452 std::stringstream value;
453 value << "adapterName[" << attr.adapterName << "] openMicSpeaker[" << attr.openMicSpeaker << "] ";
454 value << "format[" << static_cast<int32_t>(attr.format) << "] ";
455 value << "sampleRate[" << attr.sampleRate << "] channel[" << attr.channel << "] ";
456 value << "volume[" << attr.volume << "] filePath[" << attr.filePath << "] ";
457 value << "deviceNetworkId[" << attr.deviceNetworkId << "] device_type[" << attr.deviceType << "]";
458 return value.str();
459 }
460
RenderFrame(char & data,uint64_t len,uint64_t & writeLen)461 int32_t RemoteFastAudioRendererSinkInner::RenderFrame(char &data, uint64_t len, uint64_t &writeLen)
462 {
463 AUDIO_DEBUG_LOG("RenderFrame is not supported.");
464 return SUCCESS;
465 }
466
GetMaxAmplitude()467 float RemoteFastAudioRendererSinkInner::GetMaxAmplitude()
468 {
469 AUDIO_WARNING_LOG("getMaxAmplitude in remote fast audio not support");
470 return 0;
471 }
472
CheckPositionTime()473 int32_t RemoteFastAudioRendererSinkInner::CheckPositionTime()
474 {
475 int32_t tryCount = 10;
476 uint64_t frames = 0;
477 int64_t timeSec = 0;
478 int64_t timeNanoSec = 0;
479 int64_t maxHandleCost = 10000000; // ns
480 int64_t waitTime = 2000000; // 2ms
481 while (tryCount-- > 0) {
482 ClockTime::RelativeSleep(waitTime); // us
483 int32_t ret = GetMmapHandlePosition(frames, timeSec, timeNanoSec);
484 int64_t curTime = ClockTime::GetCurNano();
485 int64_t curSec = curTime / AUDIO_NS_PER_SECOND;
486 int64_t curNanoSec = curTime - curSec * AUDIO_NS_PER_SECOND;
487 if (ret != SUCCESS || curSec != timeSec || curNanoSec - timeNanoSec > maxHandleCost) {
488 AUDIO_WARNING_LOG("CheckPositionTime[%{public}d]:ret %{public}d", tryCount, ret);
489 continue;
490 } else {
491 AUDIO_INFO_LOG("CheckPositionTime end, position and time is ok.");
492 return SUCCESS;
493 }
494 }
495 return ERROR;
496 }
497
Start(void)498 int32_t RemoteFastAudioRendererSinkInner::Start(void)
499 {
500 AUDIO_INFO_LOG("Start.");
501 if (!isRenderCreated_.load()) {
502 CHECK_AND_RETURN_RET_LOG(CreateRender(audioPort_) == SUCCESS, ERR_NOT_STARTED,
503 "Create render fail, audio port %{public}d", audioPort_.portId);
504 }
505
506 if (started_.load()) {
507 AUDIO_INFO_LOG("Remote fast render is already started.");
508 return SUCCESS;
509 }
510
511 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE, "Start: Audio render is null.");
512 int32_t ret = audioRender_->Start();
513 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_NOT_STARTED, "Start fail, ret %{public}d.", ret);
514 ret = CheckPositionTime();
515 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_NOT_STARTED, "CheckPositionTime failed, ret %{public}d.", ret);
516 started_.store(true);
517 AUDIO_INFO_LOG("Start Ok.");
518 return SUCCESS;
519 }
520
Stop(void)521 int32_t RemoteFastAudioRendererSinkInner::Stop(void)
522 {
523 AUDIO_INFO_LOG("RemoteFastAudioRendererSinkInner::Stop");
524 if (!started_.load()) {
525 AUDIO_INFO_LOG("Remote fast render is already stopped.");
526 return SUCCESS;
527 }
528
529 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE, "Stop: Audio render is null.");
530 int32_t ret = audioRender_->Stop();
531 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "Stop fail, ret %{public}d.", ret);
532 started_.store(false);
533 AUDIO_DEBUG_LOG("Stop ok.");
534 return SUCCESS;
535 }
536
Pause(void)537 int32_t RemoteFastAudioRendererSinkInner::Pause(void)
538 {
539 AUDIO_INFO_LOG("RemoteFastAudioRendererSinkInner::Pause");
540 CHECK_AND_RETURN_RET_LOG(started_.load(), ERR_ILLEGAL_STATE, "Pause invalid state!");
541
542 if (paused_.load()) {
543 AUDIO_INFO_LOG("Remote fast render is already paused.");
544 return SUCCESS;
545 }
546
547 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE, "Pause: Audio render is null.");
548 int32_t ret = audioRender_->Pause();
549 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "Pause fail, ret %{public}d.", ret);
550 paused_.store(true);
551 return SUCCESS;
552 }
553
Resume(void)554 int32_t RemoteFastAudioRendererSinkInner::Resume(void)
555 {
556 AUDIO_INFO_LOG("RemoteFastAudioRendererSinkInner::Resume");
557 CHECK_AND_RETURN_RET_LOG(started_.load(), ERR_ILLEGAL_STATE, "Resume invalid state!");
558
559 if (!paused_.load()) {
560 AUDIO_INFO_LOG("Remote fast render is already resumed.");
561 return SUCCESS;
562 }
563
564 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE, "Resume: Audio render is null.");
565 int32_t ret = audioRender_->Resume();
566 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "Resume fail, ret %{public}d.", ret);
567 paused_.store(false);
568 return SUCCESS;
569 }
570
Reset(void)571 int32_t RemoteFastAudioRendererSinkInner::Reset(void)
572 {
573 AUDIO_INFO_LOG("RemoteFastAudioRendererSinkInner::Reset");
574 CHECK_AND_RETURN_RET_LOG(started_.load(), ERR_ILLEGAL_STATE, "Reset invalid state!");
575
576 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE, "Reset: Audio render is null.");
577 int32_t ret = audioRender_->Flush();
578 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "Reset fail, ret %{public}d.", ret);
579 return SUCCESS;
580 }
581
Flush(void)582 int32_t RemoteFastAudioRendererSinkInner::Flush(void)
583 {
584 AUDIO_INFO_LOG("RemoteFastAudioRendererSinkInner::Flush");
585 CHECK_AND_RETURN_RET_LOG(started_.load(), ERR_ILLEGAL_STATE, "Flush invalid state!");
586
587 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE, "Flush: Audio render is null.");
588 int32_t ret = audioRender_->Flush();
589 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "Flush fail, ret %{public}d.", ret);
590 return SUCCESS;
591 }
592
SuspendRenderSink(void)593 int32_t RemoteFastAudioRendererSinkInner::SuspendRenderSink(void)
594 {
595 return SUCCESS;
596 }
597
RestoreRenderSink(void)598 int32_t RemoteFastAudioRendererSinkInner::RestoreRenderSink(void)
599 {
600 return SUCCESS;
601 }
602
SetVolume(float left,float right)603 int32_t RemoteFastAudioRendererSinkInner::SetVolume(float left, float right)
604 {
605 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE, "SetVolume: Audio render is null.");
606
607 float volume;
608 leftVolume_ = left;
609 rightVolume_ = right;
610 if ((leftVolume_ == 0) && (rightVolume_ != 0)) {
611 volume = rightVolume_;
612 } else if ((leftVolume_ != 0) && (rightVolume_ == 0)) {
613 volume = leftVolume_;
614 } else {
615 volume = (leftVolume_ + rightVolume_) / HALF_FACTOR;
616 }
617
618 int32_t ret = audioRender_->SetVolume(volume);
619 if (ret) {
620 AUDIO_ERR_LOG("Set volume failed!");
621 }
622 return ret;
623 }
624
GetVolume(float & left,float & right)625 int32_t RemoteFastAudioRendererSinkInner::GetVolume(float &left, float &right)
626 {
627 left = leftVolume_;
628 right = rightVolume_;
629 return SUCCESS;
630 }
631
GetLatency(uint32_t * latency)632 int32_t RemoteFastAudioRendererSinkInner::GetLatency(uint32_t *latency)
633 {
634 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE,
635 "GetLatency failed audio render null");
636
637 CHECK_AND_RETURN_RET_LOG(latency, ERR_INVALID_PARAM,
638 "GetLatency failed latency null");
639
640 uint32_t hdiLatency = 0;
641 int32_t ret = audioRender_->GetLatency(hdiLatency);
642 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED,
643 "GetLatency failed.");
644
645 *latency = hdiLatency;
646 return SUCCESS;
647 }
648
RegisterParameterCallback(IAudioSinkCallback * callback)649 void RemoteFastAudioRendererSinkInner::RegisterParameterCallback(IAudioSinkCallback* callback)
650 {
651 AUDIO_INFO_LOG("register params callback");
652 callback_ = callback;
653
654 #ifdef FEATURE_DISTRIBUTE_AUDIO
655 CHECK_AND_RETURN_LOG(audioAdapter_ != nullptr, "RegisterParameterCallback: Audio adapter is null.");
656 int32_t ret = audioAdapter_->RegExtraParamObserver();
657 CHECK_AND_RETURN_LOG(ret == SUCCESS, "RegisterParameterCallback failed, ret %{public}d.", ret);
658 #endif
659 }
660
OnAudioParamChange(const std::string & adapterName,const AudioParamKey key,const std::string & condition,const std::string & value)661 void RemoteFastAudioRendererSinkInner::OnAudioParamChange(const std::string &adapterName, const AudioParamKey key,
662 const std::string &condition, const std::string &value)
663 {
664 AUDIO_INFO_LOG("Audio param change event, key:%{public}d, condition:%{public}s, value:%{public}s",
665 key, condition.c_str(), value.c_str());
666 if (key == AudioParamKey::PARAM_KEY_STATE) {
667 ClearRender();
668 }
669
670 CHECK_AND_RETURN_LOG(callback_ != nullptr, "Sink audio param callback is null.");
671 callback_->OnAudioSinkParamChange(adapterName, key, condition, value);
672 }
673
GetTransactionId(uint64_t * transactionId)674 int32_t RemoteFastAudioRendererSinkInner::GetTransactionId(uint64_t *transactionId)
675 {
676 (void)transactionId;
677 AUDIO_ERR_LOG("GetTransactionId not supported");
678 return ERR_NOT_SUPPORTED;
679 }
680
SetVoiceVolume(float volume)681 int32_t RemoteFastAudioRendererSinkInner::SetVoiceVolume(float volume)
682 {
683 (void)volume;
684 AUDIO_ERR_LOG("SetVoiceVolume not supported");
685 return ERR_NOT_SUPPORTED;
686 }
687
SetOutputRoutes(std::vector<DeviceType> & outputDevices)688 int32_t RemoteFastAudioRendererSinkInner::SetOutputRoutes(std::vector<DeviceType> &outputDevices)
689 {
690 (void)outputDevices;
691 AUDIO_DEBUG_LOG("SetOutputRoutes not supported.");
692 return ERR_NOT_SUPPORTED;
693 }
694
SetAudioMonoState(bool audioMono)695 void RemoteFastAudioRendererSinkInner::SetAudioMonoState(bool audioMono)
696 {
697 (void)audioMono;
698 AUDIO_ERR_LOG("SetAudioMonoState not supported");
699 return;
700 }
701
SetAudioBalanceValue(float audioBalance)702 void RemoteFastAudioRendererSinkInner::SetAudioBalanceValue(float audioBalance)
703 {
704 (void)audioBalance;
705 AUDIO_ERR_LOG("SetAudioBalanceValue not supported");
706 return;
707 }
708
GetPresentationPosition(uint64_t & frames,int64_t & timeSec,int64_t & timeNanoSec)709 int32_t RemoteFastAudioRendererSinkInner::GetPresentationPosition(uint64_t& frames, int64_t& timeSec,
710 int64_t& timeNanoSec)
711 {
712 AUDIO_ERR_LOG("GetPresentationPosition not supported");
713 return ERR_NOT_SUPPORTED;
714 }
715
SetAudioScene(AudioScene audioScene,std::vector<DeviceType> & activeDevices)716 int32_t RemoteFastAudioRendererSinkInner::SetAudioScene(AudioScene audioScene, std::vector<DeviceType> &activeDevices)
717 {
718 AUDIO_INFO_LOG("SetAudioScene not supported");
719 return SUCCESS;
720 }
721
SetAudioParameter(const AudioParamKey key,const std::string & condition,const std::string & value)722 void RemoteFastAudioRendererSinkInner::SetAudioParameter(const AudioParamKey key, const std::string &condition,
723 const std::string &value)
724 {
725 AUDIO_INFO_LOG("SetAudioParameter not support.");
726 }
727
GetAudioParameter(const AudioParamKey key,const std::string & condition)728 std::string RemoteFastAudioRendererSinkInner::GetAudioParameter(const AudioParamKey key, const std::string &condition)
729 {
730 AUDIO_INFO_LOG("GetAudioParameter not support.");
731 return "";
732 }
733
GetNetworkId()734 std::string RemoteFastAudioRendererSinkInner::GetNetworkId()
735 {
736 return deviceNetworkId_;
737 }
738
ResetOutputRouteForDisconnect(DeviceType device)739 void RemoteFastAudioRendererSinkInner::ResetOutputRouteForDisconnect(DeviceType device)
740 {
741 AUDIO_WARNING_LOG("not supported.");
742 }
743
GetParamCallback()744 OHOS::AudioStandard::IAudioSinkCallback* RemoteFastAudioRendererSinkInner::GetParamCallback()
745 {
746 return callback_;
747 }
748
SetPaPower(int32_t flag)749 int32_t RemoteFastAudioRendererSinkInner::SetPaPower(int32_t flag)
750 {
751 (void)flag;
752 return ERR_NOT_SUPPORTED;
753 }
754
SetPriPaPower()755 int32_t RemoteFastAudioRendererSinkInner::SetPriPaPower()
756 {
757 return ERR_NOT_SUPPORTED;
758 }
759
UpdateAppsUid(const int32_t appsUid[MAX_MIX_CHANNELS],const size_t size)760 int32_t RemoteFastAudioRendererSinkInner::UpdateAppsUid(const int32_t appsUid[MAX_MIX_CHANNELS], const size_t size)
761 {
762 AUDIO_WARNING_LOG("not supported.");
763 return ERR_NOT_SUPPORTED;
764 }
765
UpdateAppsUid(const std::vector<int32_t> & appsUid)766 int32_t RemoteFastAudioRendererSinkInner::UpdateAppsUid(const std::vector<int32_t> &appsUid)
767 {
768 AUDIO_WARNING_LOG("not supported.");
769 return ERR_NOT_SUPPORTED;
770 }
771 } // namespace AudioStandard
772 } // namespace OHOS
773