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 LOG_TAG
17 #define LOG_TAG "AudioRenderSink"
18 #endif
19
20 #include "sink/audio_render_sink.h"
21 #include <thread>
22 #include <climits>
23 #include "parameters.h"
24 #include "audio_hdi_log.h"
25 #include "audio_errors.h"
26 #include "audio_dump_pcm.h"
27 #include "volume_tools.h"
28 #include "media_monitor_manager.h"
29 #include "audio_enhance_chain_manager.h"
30 #include "common/hdi_adapter_info.h"
31 #include "manager/hdi_adapter_manager.h"
32 #include "adapter/i_device_manager.h"
33
34 namespace OHOS {
35 namespace AudioStandard {
AudioRenderSink(const uint32_t renderId,const std::string & halName)36 AudioRenderSink::AudioRenderSink(const uint32_t renderId, const std::string &halName)
37 : renderId_(renderId), halName_(halName)
38 {
39 if (halName_ == HDI_ID_INFO_DIRECT || halName_ == HDI_ID_INFO_VOIP) {
40 sinkType_ = ADAPTER_TYPE_DIRECT;
41 }
42 }
43
~AudioRenderSink()44 AudioRenderSink::~AudioRenderSink()
45 {
46 AUDIO_WARNING_LOG("in");
47 AUDIO_INFO_LOG("[%{public}s] volumeDataCount: %{public}" PRId64, logUtilsTag_.c_str(), volumeDataCount_);
48 #ifdef FEATURE_POWER_MANAGER
49 if (runningLock_ != nullptr) {
50 AUDIO_INFO_LOG("running lock unlock");
51 runningLock_->UnLock();
52 } else {
53 AUDIO_WARNING_LOG("running lock is null, playback can not work well");
54 }
55 #endif
56 AudioPerformanceMonitor::GetInstance().DeleteOvertimeMonitor(sinkType_);
57 }
58
Init(const IAudioSinkAttr & attr)59 int32_t AudioRenderSink::Init(const IAudioSinkAttr &attr)
60 {
61 std::lock_guard<std::mutex> lock(sinkMutex_);
62 attr_ = attr;
63 adapterNameCase_ = attr_.adapterName;
64 AUDIO_INFO_LOG("adapterNameCase_: %{public}s", adapterNameCase_.c_str());
65 openSpeaker_ = attr_.openMicSpeaker;
66 logMode_ = system::GetIntParameter("persist.multimedia.audiolog.switch", 0);
67
68 Trace trace("AudioRenderSink::Init " + adapterNameCase_);
69 int32_t ret = InitRender();
70 CHECK_AND_RETURN_RET(ret == SUCCESS, ret);
71
72 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
73 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_LOCAL);
74 CHECK_AND_RETURN_RET(deviceManager != nullptr, ERR_INVALID_HANDLE);
75
76 sinkInited_ = true;
77 return SUCCESS;
78 }
79
DeInit(void)80 void AudioRenderSink::DeInit(void)
81 {
82 std::lock_guard<std::mutex> lock(sinkMutex_);
83 sinkInited_ = false;
84 started_ = false;
85
86 AUDIO_INFO_LOG("destroy render, hdiRenderId: %{public}u", hdiRenderId_);
87 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
88 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_LOCAL);
89 CHECK_AND_RETURN(deviceManager != nullptr);
90 renderInited_ = false;
91 deviceManager->DestroyRender(adapterNameCase_, hdiRenderId_);
92 audioRender_ = nullptr;
93 }
94
IsInited(void)95 bool AudioRenderSink::IsInited(void)
96 {
97 return sinkInited_;
98 }
99
Start(void)100 int32_t AudioRenderSink::Start(void)
101 {
102 std::lock_guard<std::mutex> lock(sinkMutex_);
103 AUDIO_INFO_LOG("halName: %{public}s", halName_.c_str());
104 Trace trace("AudioRenderSink::Start");
105 #ifdef FEATURE_POWER_MANAGER
106 AudioXCollie audioXCollie("AudioRenderSink::CreateRunningLock", TIMEOUT_SECONDS_10);
107 if (runningLock_ == nullptr) {
108 WatchTimeout guard("create AudioRunningLock start");
109 runningLock_ = std::make_shared<AudioRunningLock>(std::string(RUNNING_LOCK_NAME_BASE) + halName_);
110 guard.CheckCurrTimeout();
111 }
112 if (runningLock_ != nullptr) {
113 runningLock_->Lock(RUNNING_LOCK_TIMEOUTMS_LASTING);
114 } else {
115 AUDIO_ERR_LOG("running lock is null, playback can not work well");
116 }
117 audioXCollie.CancelXCollieTimer();
118 #endif
119 dumpFileName_ = halName_ + "_sink_" + GetTime() + "_" + std::to_string(attr_.sampleRate) + "_" +
120 std::to_string(attr_.channel) + "_" + std::to_string(attr_.format) + ".pcm";
121 DumpFileUtil::OpenDumpFile(DumpFileUtil::DUMP_SERVER_PARA, dumpFileName_, &dumpFile_);
122 logUtilsTag_ = "AudioSink" + halName_;
123
124 InitLatencyMeasurement();
125 if (started_) {
126 return SUCCESS;
127 }
128 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE, "render is nullptr");
129 int32_t ret = audioRender_->Start(audioRender_);
130 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_NOT_STARTED, "start fail");
131 UpdateSinkState(true);
132 AudioPerformanceMonitor::GetInstance().RecordTimeStamp(sinkType_, INIT_LASTWRITTEN_TIME);
133 started_ = true;
134 return SUCCESS;
135 }
136
Stop(void)137 int32_t AudioRenderSink::Stop(void)
138 {
139 std::lock_guard<std::mutex> lock(sinkMutex_);
140 AUDIO_INFO_LOG("halName: %{public}s", halName_.c_str());
141 Trace trace("AudioRenderSink::Stop");
142 #ifdef FEATURE_POWER_MANAGER
143 if (runningLock_ != nullptr) {
144 std::thread runningLockThread([this] {
145 runningLock_->UnLock();
146 });
147 runningLockThread.join();
148 }
149 #endif
150
151 DeInitLatencyMeasurement();
152 if (!started_) {
153 return SUCCESS;
154 }
155 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE, "render is nullptr");
156 if (halName_ == "primary") {
157 const char keyValueList[] = "primary=stop";
158 if (audioRender_->SetExtraParams(audioRender_, keyValueList) == 0) {
159 AUDIO_INFO_LOG("set primary stream stop info to hal");
160 }
161 }
162 int32_t ret = audioRender_->Stop(audioRender_);
163 UpdateSinkState(false);
164 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_NOT_STARTED, "stop fail");
165 started_ = false;
166
167 DumpFileUtil::CloseDumpFile(&dumpFile_);
168 return SUCCESS;
169 }
170
Resume(void)171 int32_t AudioRenderSink::Resume(void)
172 {
173 std::lock_guard<std::mutex> lock(sinkMutex_);
174 AUDIO_INFO_LOG("halName: %{public}s", halName_.c_str());
175 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE, "render is nullptr");
176 CHECK_AND_RETURN_RET_LOG(started_, ERR_OPERATION_FAILED, "not start, invalid state");
177
178 if (!paused_) {
179 return SUCCESS;
180 }
181 int32_t ret = audioRender_->Resume(audioRender_);
182 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "resume fail");
183 AudioPerformanceMonitor::GetInstance().RecordTimeStamp(sinkType_, INIT_LASTWRITTEN_TIME);
184 paused_ = false;
185 return SUCCESS;
186 }
187
Pause(void)188 int32_t AudioRenderSink::Pause(void)
189 {
190 std::lock_guard<std::mutex> lock(sinkMutex_);
191 AUDIO_INFO_LOG("halName: %{public}s", halName_.c_str());
192 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE, "render is nullptr");
193 CHECK_AND_RETURN_RET_LOG(started_, ERR_OPERATION_FAILED, "not start, invalid state");
194
195 if (paused_) {
196 return SUCCESS;
197 }
198 int32_t ret = audioRender_->Pause(audioRender_);
199 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "pause fail");
200 paused_ = true;
201 return SUCCESS;
202 }
203
Flush(void)204 int32_t AudioRenderSink::Flush(void)
205 {
206 AUDIO_INFO_LOG("halName: %{public}s", halName_.c_str());
207 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE, "render is nullptr");
208 CHECK_AND_RETURN_RET_LOG(started_, ERR_OPERATION_FAILED, "not start, invalid state");
209
210 int32_t ret = audioRender_->Flush(audioRender_);
211 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "flush fail");
212 return SUCCESS;
213 }
214
Reset(void)215 int32_t AudioRenderSink::Reset(void)
216 {
217 AUDIO_INFO_LOG("halName: %{public}s", halName_.c_str());
218 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE, "render is nullptr");
219 CHECK_AND_RETURN_RET_LOG(started_, ERR_OPERATION_FAILED, "not start, invalid state");
220
221 int32_t ret = audioRender_->Flush(audioRender_);
222 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "reset fail");
223 return SUCCESS;
224 }
225
RenderFrame(char & data,uint64_t len,uint64_t & writeLen)226 int32_t AudioRenderSink::RenderFrame(char &data, uint64_t len, uint64_t &writeLen)
227 {
228 int64_t stamp = ClockTime::GetCurNano();
229 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE, "render is nullptr");
230 if (!started_) {
231 AUDIO_WARNING_LOG("not start, invalid state");
232 }
233 if (audioMonoState_) {
234 AdjustStereoToMono(&data, len);
235 }
236 if (audioBalanceState_) {
237 AdjustAudioBalance(&data, len);
238 }
239 CheckUpdateState(&data, len);
240 if (switchDeviceMute_ || deviceConnectedFlag_) {
241 Trace trace("AudioRenderSink::RenderFrame::renderEmpty");
242 if (memset_s(reinterpret_cast<void *>(&data), static_cast<size_t>(len), 0, static_cast<size_t>(len)) != EOK) {
243 AUDIO_WARNING_LOG("call memset_s fail");
244 }
245 }
246 CheckLatencySignal(reinterpret_cast<uint8_t *>(&data), len);
247
248 BufferDesc buffer = { reinterpret_cast<uint8_t *>(&data), len, len };
249 AudioStreamInfo streamInfo(static_cast<AudioSamplingRate>(attr_.sampleRate), AudioEncodingType::ENCODING_PCM,
250 static_cast<AudioSampleFormat>(attr_.format), static_cast<AudioChannel>(attr_.channel));
251 VolumeTools::DfxOperation(buffer, streamInfo, logUtilsTag_, volumeDataCount_);
252 if (AudioDump::GetInstance().GetVersionType() == DumpFileUtil::BETA_VERSION) {
253 DumpFileUtil::WriteDumpFile(dumpFile_, static_cast<void *>(&data), len);
254 AudioCacheMgr::GetInstance().CacheData(dumpFileName_, static_cast<void *>(&data), len);
255 }
256 Trace trace("AudioRenderSink::RenderFrame");
257 int32_t ret = audioRender_->RenderFrame(audioRender_, reinterpret_cast<int8_t *>(&data), static_cast<uint32_t>(len),
258 &writeLen);
259 AudioPerformanceMonitor::GetInstance().RecordTimeStamp(sinkType_, ClockTime::GetCurNano());
260 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_WRITE_FAILED, "fail, ret: %{public}x", ret);
261 stamp = (ClockTime::GetCurNano() - stamp) / AUDIO_US_PER_SECOND;
262 int64_t stampThreshold = 50; // 50ms
263 if (logMode_ || stamp >= stampThreshold) {
264 AUDIO_WARNING_LOG("len: [%{public}" PRIu64 "], cost: [%{public}" PRId64 "]ms", len, stamp);
265 }
266 #ifdef FEATURE_POWER_MANAGER
267 if (runningLock_) {
268 runningLock_->UpdateAppsUidToPowerMgr();
269 }
270 #endif
271
272 return SUCCESS;
273 }
274
SuspendRenderSink(void)275 int32_t AudioRenderSink::SuspendRenderSink(void)
276 {
277 return SUCCESS;
278 }
279
RestoreRenderSink(void)280 int32_t AudioRenderSink::RestoreRenderSink(void)
281 {
282 return SUCCESS;
283 }
284
SetAudioParameter(const AudioParamKey key,const std::string & condition,const std::string & value)285 void AudioRenderSink::SetAudioParameter(const AudioParamKey key, const std::string &condition, const std::string &value)
286 {
287 }
288
GetAudioParameter(const AudioParamKey key,const std::string & condition)289 std::string AudioRenderSink::GetAudioParameter(const AudioParamKey key, const std::string &condition)
290 {
291 std::lock_guard<std::mutex> lock(sinkMutex_);
292 AUDIO_INFO_LOG("key: %{public}d, condition: %{public}s, halName: %{public}s", key, condition.c_str(),
293 halName_.c_str());
294 if (condition.starts_with("get_usb_info#C") && halName_ == HDI_ID_INFO_USB) {
295 // init adapter to get parameter before load sink module (need fix)
296 adapterNameCase_ = "usb";
297 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
298 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_LOCAL);
299 CHECK_AND_RETURN_RET_LOG(deviceManager != nullptr, "", "deviceManager is nullptr");
300 return deviceManager->GetAudioParameter(adapterNameCase_, key, condition);
301 }
302 if (key == AudioParamKey::GET_DP_DEVICE_INFO && halName_ == HDI_ID_INFO_DP) {
303 // init adapter and render to get parameter before load sink module (need fix)
304 return GetDPDeviceInfo(condition);
305 }
306 return "";
307 }
308
SetVolume(float left,float right)309 int32_t AudioRenderSink::SetVolume(float left, float right)
310 {
311 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE, "render is nullptr");
312
313 leftVolume_ = left;
314 rightVolume_ = right;
315 CHECK_AND_RETURN_RET_LOG(!(halName_ == "voip" && switchDeviceMute_ && (abs(left) > FLOAT_EPS ||
316 abs(right) > FLOAT_EPS)), ERR_ILLEGAL_STATE, "mute for switch device at voip scene, not support set volume");
317 float volume;
318 if ((abs(leftVolume_) < FLOAT_EPS) && (abs(rightVolume_) > FLOAT_EPS)) {
319 volume = rightVolume_;
320 } else if ((abs(leftVolume_) > FLOAT_EPS) && (abs(rightVolume_) < FLOAT_EPS)) {
321 volume = leftVolume_;
322 } else {
323 volume = (leftVolume_ + rightVolume_) / HALF_FACTOR;
324 }
325
326 int32_t ret = audioRender_->SetVolume(audioRender_, volume);
327 if (ret != SUCCESS) {
328 AUDIO_WARNING_LOG("set volume fail");
329 }
330
331 return ret;
332 }
333
GetVolume(float & left,float & right)334 int32_t AudioRenderSink::GetVolume(float &left, float &right)
335 {
336 left = leftVolume_;
337 right = rightVolume_;
338 return SUCCESS;
339 }
340
GetLatency(uint32_t & latency)341 int32_t AudioRenderSink::GetLatency(uint32_t &latency)
342 {
343 Trace trace("AudioRenderSink::GetLatency");
344 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE, "render is nullptr");
345
346 uint32_t hdiLatency;
347 int32_t ret = audioRender_->GetLatency(audioRender_, &hdiLatency);
348 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "get latency fail");
349 latency = hdiLatency;
350 return SUCCESS;
351 }
352
GetTransactionId(uint64_t & transactionId)353 int32_t AudioRenderSink::GetTransactionId(uint64_t &transactionId)
354 {
355 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE, "render is nullptr");
356 transactionId = reinterpret_cast<uint64_t>(audioRender_);
357 return SUCCESS;
358 }
359
GetPresentationPosition(uint64_t & frames,int64_t & timeSec,int64_t & timeNanoSec)360 int32_t AudioRenderSink::GetPresentationPosition(uint64_t &frames, int64_t &timeSec, int64_t &timeNanoSec)
361 {
362 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE, "render is nullptr");
363
364 struct AudioTimeStamp stamp = {};
365 int32_t ret = audioRender_->GetRenderPosition(audioRender_, &frames, &stamp);
366 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "get render position fail, ret: %{public}d", ret);
367 int64_t maxSec = 9223372036; // (9223372036 + 1) * 10^9 > INT64_MAX, seconds should not bigger than it
368 CHECK_AND_RETURN_RET_LOG(stamp.tvSec >= 0 && stamp.tvSec <= maxSec && stamp.tvNSec >= 0 &&
369 stamp.tvNSec <= SECOND_TO_NANOSECOND, ERR_OPERATION_FAILED,
370 "get invalid time, second: %{public}" PRId64 ", nanosecond: %{public}" PRId64, stamp.tvSec, stamp.tvNSec);
371 timeSec = stamp.tvSec;
372 timeNanoSec = stamp.tvNSec;
373 return ret;
374 }
375
GetMaxAmplitude(void)376 float AudioRenderSink::GetMaxAmplitude(void)
377 {
378 lastGetMaxAmplitudeTime_ = ClockTime::GetCurNano();
379 startUpdate_ = true;
380 return maxAmplitude_;
381 }
382
SetAudioMonoState(bool audioMono)383 void AudioRenderSink::SetAudioMonoState(bool audioMono)
384 {
385 audioMonoState_ = audioMono;
386 }
387
SetAudioBalanceValue(float audioBalance)388 void AudioRenderSink::SetAudioBalanceValue(float audioBalance)
389 {
390 // reset the balance coefficient value firstly
391 leftBalanceCoef_ = 1.0f;
392 rightBalanceCoef_ = 1.0f;
393
394 if (std::abs(audioBalance - 0.0f) <= std::numeric_limits<float>::epsilon()) {
395 // audioBalance is equal to 0.0f
396 audioBalanceState_ = false;
397 } else {
398 // audioBalance is not equal to 0.0f
399 audioBalanceState_ = true;
400 // calculate the balance coefficient
401 if (audioBalance > 0.0f) {
402 leftBalanceCoef_ -= audioBalance;
403 } else if (audioBalance < 0.0f) {
404 rightBalanceCoef_ += audioBalance;
405 }
406 }
407 }
408
SetSinkMuteForSwitchDevice(bool mute)409 int32_t AudioRenderSink::SetSinkMuteForSwitchDevice(bool mute)
410 {
411 std::lock_guard<std::mutex> lock(switchDeviceMutex_);
412 AUDIO_INFO_LOG("set %{public}s mute %{public}d", halName_.c_str(), mute);
413 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE, "render is nullptr");
414
415 if (mute) {
416 muteCount_++;
417 if (switchDeviceMute_) {
418 AUDIO_INFO_LOG("%{public}s already muted", halName_.c_str());
419 return SUCCESS;
420 }
421 switchDeviceMute_ = true;
422 if (halName_ == HDI_ID_INFO_VOIP) {
423 audioRender_->SetVolume(audioRender_, 0.0f);
424 }
425 } else {
426 muteCount_--;
427 if (muteCount_ > 0) {
428 AUDIO_WARNING_LOG("%{public}s not all unmuted", halName_.c_str());
429 return SUCCESS;
430 }
431 switchDeviceMute_ = false;
432 muteCount_ = 0;
433 if (halName_ == HDI_ID_INFO_VOIP) {
434 SetVolume(leftVolume_, rightVolume_);
435 }
436 }
437
438 return SUCCESS;
439 }
440
SetDeviceConnectedFlag(bool flag)441 int32_t AudioRenderSink::SetDeviceConnectedFlag(bool flag)
442 {
443 AUDIO_INFO_LOG("flag %{public}d", flag);
444 deviceConnectedFlag_ = flag;
445 return SUCCESS;
446 }
447
SetAudioScene(AudioScene audioScene,std::vector<DeviceType> & activeDevices)448 int32_t AudioRenderSink::SetAudioScene(AudioScene audioScene, std::vector<DeviceType> &activeDevices)
449 {
450 CHECK_AND_RETURN_RET_LOG(audioScene >= AUDIO_SCENE_DEFAULT && audioScene < AUDIO_SCENE_MAX, ERR_INVALID_PARAM,
451 "invalid scene");
452 CHECK_AND_RETURN_RET_LOG(!activeDevices.empty() && activeDevices.size() <= AUDIO_CONCURRENT_ACTIVE_DEVICES_LIMIT,
453 ERR_INVALID_PARAM, "invalid device");
454 AUDIO_INFO_LOG("scene: %{public}d, device: %{public}d", audioScene, activeDevices.front());
455 if (!openSpeaker_) {
456 return SUCCESS;
457 }
458 bool isRingingToDefaultScene = false;
459 if (audioScene != currentAudioScene_) {
460 struct AudioSceneDescriptor sceneDesc;
461 InitSceneDesc(sceneDesc, audioScene);
462
463 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE, "render is nullptr");
464 int32_t ret = audioRender_->SelectScene(audioRender_, &sceneDesc);
465 CHECK_AND_RETURN_RET_LOG(ret >= 0, ERR_OPERATION_FAILED, "select scene fail, ret: %{public}d", ret);
466 if (audioScene == AUDIO_SCENE_PHONE_CALL || audioScene == AUDIO_SCENE_PHONE_CHAT) {
467 forceSetRouteFlag_ = true;
468 }
469 if (audioScene == AUDIO_SCENE_DEFAULT &&
470 (currentAudioScene_ == AUDIO_SCENE_RINGING || currentAudioScene_ == AUDIO_SCENE_VOICE_RINGING)) {
471 isRingingToDefaultScene = true;
472 }
473 currentAudioScene_ = audioScene;
474 }
475 if (isRingingToDefaultScene) {
476 AUDIO_INFO_LOG("ringing scene to default scene");
477 return SUCCESS;
478 }
479 int32_t ret = UpdateActiveDevice(activeDevices);
480 if (ret != SUCCESS) {
481 AUDIO_WARNING_LOG("update route fail, ret: %{public}d", ret);
482 }
483 return SUCCESS;
484 }
485
GetAudioScene(void)486 int32_t AudioRenderSink::GetAudioScene(void)
487 {
488 return currentAudioScene_;
489 }
490
UpdateActiveDevice(std::vector<DeviceType> & outputDevices)491 int32_t AudioRenderSink::UpdateActiveDevice(std::vector<DeviceType> &outputDevices)
492 {
493 CHECK_AND_RETURN_RET_LOG(!outputDevices.empty() && outputDevices.size() <= AUDIO_CONCURRENT_ACTIVE_DEVICES_LIMIT,
494 ERR_INVALID_PARAM, "invalid device");
495 if (currentActiveDevice_ == outputDevices[0] && outputDevices.size() ==
496 static_cast<uint32_t>(currentDevicesSize_) && !forceSetRouteFlag_) {
497 AUDIO_INFO_LOG("output device not change, device: %{public}d", outputDevices[0]);
498 return SUCCESS;
499 }
500 forceSetRouteFlag_ = false;
501 currentActiveDevice_ = outputDevices[0];
502 currentDevicesSize_ = static_cast<int32_t>(outputDevices.size());
503 SetAudioRouteInfoForEnhanceChain();
504 return DoSetOutputRoute(outputDevices);
505 }
506
RegistCallback(uint32_t type,IAudioSinkCallback * callback)507 void AudioRenderSink::RegistCallback(uint32_t type, IAudioSinkCallback *callback)
508 {
509 std::lock_guard<std::mutex> lock(sinkMutex_);
510 callback_.RegistCallback(type, callback);
511 AUDIO_INFO_LOG("regist succ");
512 }
513
ResetActiveDeviceForDisconnect(DeviceType device)514 void AudioRenderSink::ResetActiveDeviceForDisconnect(DeviceType device)
515 {
516 if (currentActiveDevice_ == device) {
517 currentActiveDevice_ = DEVICE_TYPE_NONE;
518 }
519 }
520
SetPaPower(int32_t flag)521 int32_t AudioRenderSink::SetPaPower(int32_t flag)
522 {
523 Trace trace("AudioRenderSink::SetPaPower flag: " + std::to_string(flag));
524 std::string param;
525
526 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE, "render is nullptr");
527 if (flag == 0 && paStatus_ == 1) {
528 param = "zero_volume=true;routing=0";
529 int32_t ret = audioRender_->SetExtraParams(audioRender_, param.c_str());
530 if (ret == SUCCESS) {
531 paStatus_ = 0;
532 WriteSmartPAStatusSysEvent(paStatus_);
533 }
534 return ret;
535 } else if (flag == 1 && paStatus_ == 0) {
536 param = "zero_volume=true;routing=" + GetRouting();
537 AUDIO_INFO_LOG("param: %{public}s", param.c_str());
538 int32_t ret = audioRender_->SetExtraParams(audioRender_, param.c_str());
539 param = "zero_volume=false";
540 ret += audioRender_->SetExtraParams(audioRender_, param.c_str());
541 if (ret == SUCCESS) {
542 paStatus_ = 1;
543 WriteSmartPAStatusSysEvent(paStatus_);
544 }
545 return ret;
546 } else if ((flag == 0 && paStatus_ == 0) || (flag == 1 && paStatus_ == 1)) {
547 return SUCCESS;
548 }
549
550 AUDIO_WARNING_LOG("invalid flag");
551 return ERR_INVALID_PARAM;
552 }
553
SetPriPaPower(void)554 int32_t AudioRenderSink::SetPriPaPower(void)
555 {
556 time_t currentTime = time(nullptr);
557 double diff = difftime(currentTime, startTime_);
558 if (diff > INTERVAL) {
559 CHECK_AND_RETURN_RET(audioRender_ != nullptr, ERR_INVALID_HANDLE);
560 int32_t ret = audioRender_->SetExtraParams(audioRender_, "primary=start");
561 if (ret == SUCCESS) {
562 AUDIO_INFO_LOG("set primary stream start info to hal");
563 }
564 time(&startTime_);
565 return ret;
566 }
567 return ERR_OPERATION_FAILED;
568 }
569
UpdateAppsUid(const int32_t appsUid[MAX_MIX_CHANNELS],const size_t size)570 int32_t AudioRenderSink::UpdateAppsUid(const int32_t appsUid[MAX_MIX_CHANNELS], const size_t size)
571 {
572 #ifdef FEATURE_POWER_MANAGER
573 CHECK_AND_RETURN_RET_LOG(runningLock_, ERR_INVALID_HANDLE, "running lock is nullptr");
574 runningLock_->UpdateAppsUid(appsUid, appsUid + size);
575 #endif
576 return SUCCESS;
577 }
578
UpdateAppsUid(const std::vector<int32_t> & appsUid)579 int32_t AudioRenderSink::UpdateAppsUid(const std::vector<int32_t> &appsUid)
580 {
581 #ifdef FEATURE_POWER_MANAGER
582 CHECK_AND_RETURN_RET_LOG(runningLock_, ERR_INVALID_HANDLE, "running lock is nullptr");
583 runningLock_->UpdateAppsUid(appsUid.cbegin(), appsUid.cend());
584 runningLock_->UpdateAppsUidToPowerMgr();
585 #endif
586 return SUCCESS;
587 }
588
SetAddress(const std::string & address)589 void AudioRenderSink::SetAddress(const std::string &address)
590 {
591 address_ = address;
592 }
593
DumpInfo(std::string & dumpString)594 void AudioRenderSink::DumpInfo(std::string &dumpString)
595 {
596 dumpString += "type: PrimarySink\tstarted: " + std::string(started_ ? "true" : "false") + "\thalName: " + halName_ +
597 "\tcurrentActiveDevice: " + std::to_string(currentActiveDevice_) + "\n";
598 }
599
PcmFormatToBit(AudioSampleFormat format)600 uint32_t AudioRenderSink::PcmFormatToBit(AudioSampleFormat format)
601 {
602 AudioFormat hdiFormat = ConvertToHdiFormat(format);
603 switch (hdiFormat) {
604 case AUDIO_FORMAT_TYPE_PCM_8_BIT:
605 return PCM_8_BIT;
606 case AUDIO_FORMAT_TYPE_PCM_16_BIT:
607 return PCM_16_BIT;
608 case AUDIO_FORMAT_TYPE_PCM_24_BIT:
609 return PCM_24_BIT;
610 case AUDIO_FORMAT_TYPE_PCM_32_BIT:
611 return PCM_32_BIT;
612 default:
613 AUDIO_DEBUG_LOG("unknown format type, set it to default");
614 return PCM_24_BIT;
615 }
616 }
617
ConvertToHdiFormat(AudioSampleFormat format)618 AudioFormat AudioRenderSink::ConvertToHdiFormat(AudioSampleFormat format)
619 {
620 AudioFormat hdiFormat;
621 switch (format) {
622 case SAMPLE_U8:
623 hdiFormat = AUDIO_FORMAT_TYPE_PCM_8_BIT;
624 break;
625 case SAMPLE_S16LE:
626 hdiFormat = AUDIO_FORMAT_TYPE_PCM_16_BIT;
627 break;
628 case SAMPLE_S24LE:
629 hdiFormat = AUDIO_FORMAT_TYPE_PCM_24_BIT;
630 break;
631 case SAMPLE_S32LE:
632 hdiFormat = AUDIO_FORMAT_TYPE_PCM_32_BIT;
633 break;
634 default:
635 hdiFormat = AUDIO_FORMAT_TYPE_PCM_16_BIT;
636 break;
637 }
638 return hdiFormat;
639 }
640
ConvertByteToAudioFormat(int32_t format)641 int32_t AudioRenderSink::ConvertByteToAudioFormat(int32_t format)
642 {
643 int32_t audioSampleFormat = 0;
644 switch (format) {
645 case FORMAT_1_BYTE:
646 audioSampleFormat = SAMPLE_U8;
647 break;
648 case FORMAT_2_BYTE:
649 audioSampleFormat = SAMPLE_S16LE;
650 break;
651 case FORMAT_3_BYTE:
652 audioSampleFormat = SAMPLE_S24LE;
653 break;
654 case FORMAT_4_BYTE:
655 audioSampleFormat = SAMPLE_S32LE;
656 break;
657 default:
658 audioSampleFormat = SAMPLE_S16LE;
659 break;
660 }
661 return audioSampleFormat;
662 }
663
ParseAudioFormatToStr(int32_t format)664 std::string AudioRenderSink::ParseAudioFormatToStr(int32_t format)
665 {
666 switch (format) {
667 case FORMAT_1_BYTE:
668 return "u8";
669 case FORMAT_2_BYTE:
670 return "s16";
671 case FORMAT_3_BYTE:
672 return "s24";
673 case FORMAT_4_BYTE:
674 return "s32";
675 default:
676 return "s16";
677 }
678 return "";
679 }
680
ParseAudioFormat(const std::string & format)681 AudioSampleFormat AudioRenderSink::ParseAudioFormat(const std::string &format)
682 {
683 if (format == "AUDIO_FORMAT_PCM_16_BIT") {
684 return SAMPLE_S16LE;
685 } else if (format == "AUDIO_FORMAT_PCM_24_BIT" || format == "AUDIO_FORMAT_PCM_24_BIT_PACKED") {
686 return SAMPLE_S24LE;
687 } else if (format == "AUDIO_FORMAT_PCM_32_BIT") {
688 return SAMPLE_S32LE;
689 } else {
690 return SAMPLE_S16LE;
691 }
692 }
693
GetAudioCategory(AudioScene audioScene)694 AudioCategory AudioRenderSink::GetAudioCategory(AudioScene audioScene)
695 {
696 AudioCategory audioCategory;
697 switch (audioScene) {
698 case AUDIO_SCENE_DEFAULT:
699 audioCategory = AUDIO_IN_MEDIA;
700 break;
701 case AUDIO_SCENE_RINGING:
702 case AUDIO_SCENE_VOICE_RINGING:
703 audioCategory = AUDIO_IN_RINGTONE;
704 break;
705 case AUDIO_SCENE_PHONE_CALL:
706 audioCategory = AUDIO_IN_CALL;
707 break;
708 case AUDIO_SCENE_PHONE_CHAT:
709 audioCategory = AUDIO_IN_COMMUNICATION;
710 break;
711 default:
712 audioCategory = AUDIO_IN_MEDIA;
713 break;
714 }
715 AUDIO_DEBUG_LOG("audioCategory: %{public}d", audioCategory);
716
717 return audioCategory;
718 }
719
GetAudioPortPin(void) const720 AudioPortPin AudioRenderSink::GetAudioPortPin(void) const noexcept
721 {
722 switch (attr_.deviceType) {
723 case DEVICE_TYPE_EARPIECE:
724 return PIN_OUT_EARPIECE;
725 case DEVICE_TYPE_SPEAKER:
726 return PIN_OUT_SPEAKER;
727 case DEVICE_TYPE_WIRED_HEADSET:
728 return PIN_OUT_HEADSET;
729 case DEVICE_TYPE_WIRED_HEADPHONES:
730 return PIN_OUT_HEADPHONE;
731 case DEVICE_TYPE_BLUETOOTH_SCO:
732 return PIN_OUT_BLUETOOTH_SCO;
733 case DEVICE_TYPE_USB_HEADSET:
734 return PIN_OUT_USB_EXT;
735 case DEVICE_TYPE_NONE:
736 return PIN_NONE;
737 default:
738 return PIN_OUT_SPEAKER;
739 }
740 }
741
GetUniqueId(void) const742 uint32_t AudioRenderSink::GetUniqueId(void) const
743 {
744 if (halName_ == HDI_ID_INFO_USB) {
745 return GenerateUniqueID(AUDIO_HDI_RENDER_ID_BASE, HDI_RENDER_OFFSET_USB);
746 } else if (halName_ == HDI_ID_INFO_DP) {
747 return GenerateUniqueID(AUDIO_HDI_RENDER_ID_BASE, HDI_RENDER_OFFSET_DP);
748 } else if (halName_ == HDI_ID_INFO_VOIP) {
749 return GenerateUniqueID(AUDIO_HDI_RENDER_ID_BASE, HDI_RENDER_OFFSET_VOIP);
750 } else if (halName_ == HDI_ID_INFO_DIRECT) {
751 return GenerateUniqueID(AUDIO_HDI_RENDER_ID_BASE, HDI_RENDER_OFFSET_DIRECT);
752 }
753 return GenerateUniqueID(AUDIO_HDI_RENDER_ID_BASE, HDI_RENDER_OFFSET_PRIMARY);
754 }
755
InitAudioSampleAttr(struct AudioSampleAttributes & param)756 void AudioRenderSink::InitAudioSampleAttr(struct AudioSampleAttributes ¶m)
757 {
758 param.channelCount = AUDIO_CHANNELCOUNT;
759 param.sampleRate = AUDIO_SAMPLE_RATE_48K;
760 param.interleaved = true;
761 param.streamId = static_cast<int32_t>(GenerateUniqueID(AUDIO_HDI_RENDER_ID_BASE, HDI_RENDER_OFFSET_PRIMARY));
762 param.type = AUDIO_IN_MEDIA;
763 param.period = DEEP_BUFFER_RENDER_PERIOD_SIZE;
764 param.isBigEndian = false;
765 param.isSignedData = true;
766 param.stopThreshold = INT_MAX;
767 param.silenceThreshold = 0;
768
769 param.sampleRate = attr_.sampleRate;
770 param.channelCount = attr_.channel;
771 if (param.channelCount == MONO) {
772 param.channelLayout = CH_LAYOUT_MONO;
773 } else if (param.channelCount == STEREO) {
774 param.channelLayout = CH_LAYOUT_STEREO;
775 }
776 if (halName_ == HDI_ID_INFO_DP) {
777 param.type = AUDIO_DP;
778 } else if (halName_ == HDI_ID_INFO_DIRECT) {
779 param.type = AUDIO_DIRECT;
780 param.streamId = static_cast<int32_t>(GenerateUniqueID(AUDIO_HDI_RENDER_ID_BASE, HDI_RENDER_OFFSET_DIRECT));
781 } else if (halName_ == HDI_ID_INFO_VOIP) {
782 param.type = AUDIO_IN_COMMUNICATION;
783 param.streamId = static_cast<int32_t>(GenerateUniqueID(AUDIO_HDI_RENDER_ID_BASE, HDI_RENDER_OFFSET_VOIP));
784 }
785 param.format = ConvertToHdiFormat(attr_.format);
786 param.frameSize = PcmFormatToBit(attr_.format) * param.channelCount / PCM_8_BIT;
787 param.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (param.frameSize);
788 }
789
InitDeviceDesc(struct AudioDeviceDescriptor & deviceDesc)790 void AudioRenderSink::InitDeviceDesc(struct AudioDeviceDescriptor &deviceDesc)
791 {
792 if (halName_ == HDI_ID_INFO_USB) {
793 deviceDesc.desc = const_cast<char *>(address_.c_str());
794 } else {
795 deviceDesc.desc = const_cast<char *>(attr_.address.c_str());
796 }
797 deviceDesc.pins = GetAudioPortPin();
798 if (halName_ == HDI_ID_INFO_USB) {
799 deviceDesc.pins = PIN_OUT_USB_HEADSET;
800 } else if (halName_ == HDI_ID_INFO_DP) {
801 deviceDesc.pins = PIN_OUT_DP;
802 }
803 }
804
InitSceneDesc(struct AudioSceneDescriptor & sceneDesc,AudioScene audioScene)805 void AudioRenderSink::InitSceneDesc(struct AudioSceneDescriptor &sceneDesc, AudioScene audioScene)
806 {
807 sceneDesc.scene.id = GetAudioCategory(audioScene);
808 if (halName_ == HDI_ID_INFO_DIRECT) {
809 sceneDesc.scene.id = AUDIO_DIRECT;
810 } else if (halName_ == HDI_ID_INFO_VOIP) {
811 sceneDesc.scene.id = AUDIO_IN_COMMUNICATION;
812 }
813
814 AudioPortPin pin = GetAudioPortPin();
815 if (halName_ == HDI_ID_INFO_USB) {
816 pin = PIN_OUT_USB_HEADSET;
817 } else if (halName_ == HDI_ID_INFO_DP) {
818 pin = PIN_OUT_DP;
819 }
820 AUDIO_DEBUG_LOG("pin is %{public}d", pin);
821 sceneDesc.desc.pins = pin;
822 sceneDesc.desc.desc = const_cast<char *>("");
823 }
824
SetAudioRouteInfoForEnhanceChain(void)825 void AudioRenderSink::SetAudioRouteInfoForEnhanceChain(void)
826 {
827 AudioEnhanceChainManager *audioEnhanceChainManager = AudioEnhanceChainManager::GetInstance();
828 CHECK_AND_RETURN_LOG(audioEnhanceChainManager != nullptr, "audioEnhanceChainManager is nullptr");
829 if (halName_ == HDI_ID_INFO_USB) {
830 audioEnhanceChainManager->SetOutputDevice(renderId_, DEVICE_TYPE_USB_ARM_HEADSET);
831 } else if (halName_ == HDI_ID_INFO_DP) {
832 audioEnhanceChainManager->SetOutputDevice(renderId_, DEVICE_TYPE_DP);
833 } else {
834 audioEnhanceChainManager->SetOutputDevice(renderId_, currentActiveDevice_);
835 }
836 }
837
CreateRender(void)838 int32_t AudioRenderSink::CreateRender(void)
839 {
840 Trace trace("AudioRenderSink::CreateRender");
841
842 struct AudioSampleAttributes param;
843 struct AudioDeviceDescriptor deviceDesc;
844 InitAudioSampleAttr(param);
845 InitDeviceDesc(deviceDesc);
846
847 AUDIO_INFO_LOG("create render, halName: %{public}s, rate: %{public}u, channel: %{public}u, format: %{public}u, "
848 "devicePin: %{public}u, desc: %{public}s", halName_.c_str(), param.sampleRate, param.channelCount, param.format,
849 deviceDesc.pins, deviceDesc.desc);
850 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
851 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_LOCAL);
852 CHECK_AND_RETURN_RET(deviceManager != nullptr, ERR_INVALID_HANDLE);
853 void *render = deviceManager->CreateRender(adapterNameCase_, ¶m, &deviceDesc, hdiRenderId_);
854 audioRender_ = static_cast<struct IAudioRender *>(render);
855 CHECK_AND_RETURN_RET(audioRender_ != nullptr, ERR_NOT_STARTED);
856 SetAudioRouteInfoForEnhanceChain();
857
858 AUDIO_INFO_LOG("create render success, hdiRenderId_: %{public}u, desc: %{public}s", hdiRenderId_, deviceDesc.desc);
859 return SUCCESS;
860 }
861
DoSetOutputRoute(std::vector<DeviceType> & outputDevices)862 int32_t AudioRenderSink::DoSetOutputRoute(std::vector<DeviceType> &outputDevices)
863 {
864 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
865 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_LOCAL);
866 CHECK_AND_RETURN_RET(deviceManager != nullptr, ERR_INVALID_HANDLE);
867 int32_t ret = deviceManager->SetOutputRoute(adapterNameCase_, outputDevices,
868 GenerateUniqueID(AUDIO_HDI_RENDER_ID_BASE, HDI_RENDER_OFFSET_PRIMARY));
869 return ret;
870 }
871
InitRender(void)872 int32_t AudioRenderSink::InitRender(void)
873 {
874 AUDIO_INFO_LOG("start, halName: %{public}s", halName_.c_str());
875 Trace trace("AudioRenderSink::InitRender");
876 if (renderInited_) {
877 AUDIO_INFO_LOG("render already inited");
878 return SUCCESS;
879 }
880
881 int32_t ret = CreateRender();
882 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_NOT_STARTED, "create render fail");
883 if (openSpeaker_) {
884 ret = SUCCESS;
885 std::vector<DeviceType> outputDevices;
886 if (halName_ == HDI_ID_INFO_USB) {
887 outputDevices.push_back(DEVICE_TYPE_USB_ARM_HEADSET);
888 ret = UpdateActiveDevice(outputDevices);
889 } else if (halName_ == HDI_ID_INFO_DP) {
890 outputDevices.push_back(DEVICE_TYPE_DP);
891 ret = UpdateActiveDevice(outputDevices);
892 } else if (halName_ == HDI_ID_INFO_VOIP) {
893 // voip hal do not need to SetOutputRoute when create render, will SetOutputRoute when start stream
894 AUDIO_INFO_LOG("voip hal do not need to SetOutputRoute when create render");
895 } else {
896 DeviceType type = static_cast<DeviceType>(attr_.deviceType);
897 if (type == DEVICE_TYPE_INVALID) {
898 type = DEVICE_TYPE_SPEAKER;
899 }
900 outputDevices.push_back(type);
901 ret = UpdateActiveDevice(outputDevices);
902 }
903 if (ret != SUCCESS) {
904 AUDIO_WARNING_LOG("update route fail, ret: %{public}d", ret);
905 }
906 }
907 renderInited_ = true;
908 return SUCCESS;
909 }
910
InitLatencyMeasurement(void)911 void AudioRenderSink::InitLatencyMeasurement(void)
912 {
913 if (!AudioLatencyMeasurement::CheckIfEnabled()) {
914 return;
915 }
916
917 AUDIO_INFO_LOG("in");
918 signalDetectAgent_ = std::make_shared<SignalDetectAgent>();
919 CHECK_AND_RETURN_LOG(signalDetectAgent_ != nullptr, "signalDetectAgent is nullptr");
920 signalDetectAgent_->sampleFormat_ = attr_.format;
921 signalDetectAgent_->formatByteSize_ = GetFormatByteSize(attr_.format);
922 signalDetected_ = false;
923 }
924
DeInitLatencyMeasurement(void)925 void AudioRenderSink::DeInitLatencyMeasurement(void)
926 {
927 signalDetectAgent_ = nullptr;
928 }
929
CheckLatencySignal(uint8_t * data,size_t len)930 void AudioRenderSink::CheckLatencySignal(uint8_t *data, size_t len)
931 {
932 CHECK_AND_RETURN(signalDetectAgent_ != nullptr);
933 uint32_t byteSize = static_cast<uint32_t>(GetFormatByteSize(attr_.format));
934 size_t newlyCheckedTime = len / (attr_.sampleRate / MILLISECOND_PER_SECOND) /
935 (byteSize * sizeof(uint8_t) * attr_.channel);
936 signalDetectedTime_ += newlyCheckedTime;
937 if (signalDetectedTime_ >= MILLISECOND_PER_SECOND && signalDetectAgent_->signalDetected_ &&
938 !signalDetectAgent_->dspTimestampGot_) {
939 AudioParamKey key = NONE;
940 std::string condition = "debug_audio_latency_measurement";
941 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
942 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_LOCAL);
943 CHECK_AND_RETURN(deviceManager != nullptr);
944 std::string value = deviceManager->GetAudioParameter(adapterNameCase_, key, condition);
945
946 LatencyMonitor::GetInstance().UpdateDspTime(value.c_str());
947 LatencyMonitor::GetInstance().UpdateSinkOrSourceTime(true, signalDetectAgent_->lastPeakBufferTime_);
948 LatencyMonitor::GetInstance().ShowTimestamp(true);
949 signalDetectAgent_->dspTimestampGot_ = true;
950 signalDetectAgent_->signalDetected_ = false;
951 }
952 signalDetected_ = signalDetectAgent_->CheckAudioData(data, len);
953 if (signalDetected_) {
954 AUDIO_INFO_LOG("signal detected");
955 signalDetectedTime_ = 0;
956 }
957 }
958
AdjustStereoToMono(char * data,uint64_t len)959 void AudioRenderSink::AdjustStereoToMono(char *data, uint64_t len)
960 {
961 // only stereo is supported now (stereo channel count is 2)
962 CHECK_AND_RETURN_LOG(attr_.channel == STEREO_CHANNEL_COUNT, "unsupport, channel: %{public}d", attr_.channel);
963
964 switch (attr_.format) {
965 case SAMPLE_U8:
966 AdjustStereoToMonoForPCM8Bit(reinterpret_cast<int8_t *>(data), len);
967 break;
968 case SAMPLE_S16LE:
969 AdjustStereoToMonoForPCM16Bit(reinterpret_cast<int16_t *>(data), len);
970 break;
971 case SAMPLE_S24LE:
972 AdjustStereoToMonoForPCM24Bit(reinterpret_cast<uint8_t *>(data), len);
973 break;
974 case SAMPLE_S32LE:
975 AdjustStereoToMonoForPCM32Bit(reinterpret_cast<int32_t *>(data), len);
976 break;
977 default:
978 // if the audio format is unsupported, the audio data will not be changed
979 AUDIO_ERR_LOG("unsupport, format: %{public}d", attr_.format);
980 break;
981 }
982 }
983
AdjustAudioBalance(char * data,uint64_t len)984 void AudioRenderSink::AdjustAudioBalance(char *data, uint64_t len)
985 {
986 // only stereo is supported now (stereo channel count is 2)
987 CHECK_AND_RETURN_LOG(attr_.channel == STEREO_CHANNEL_COUNT, "unsupport, channel: %{public}d", attr_.channel);
988
989 switch (attr_.format) {
990 case SAMPLE_U8:
991 // this function needs further tested for usability
992 AdjustAudioBalanceForPCM8Bit(reinterpret_cast<int8_t *>(data), len, leftBalanceCoef_, rightBalanceCoef_);
993 break;
994 case SAMPLE_S16LE:
995 AdjustAudioBalanceForPCM16Bit(reinterpret_cast<int16_t *>(data), len, leftBalanceCoef_, rightBalanceCoef_);
996 break;
997 case SAMPLE_S24LE:
998 // this function needs further tested for usability
999 AdjustAudioBalanceForPCM24Bit(reinterpret_cast<uint8_t *>(data), len, leftBalanceCoef_, rightBalanceCoef_);
1000 break;
1001 case SAMPLE_S32LE:
1002 AdjustAudioBalanceForPCM32Bit(reinterpret_cast<int32_t *>(data), len, leftBalanceCoef_, rightBalanceCoef_);
1003 break;
1004 default:
1005 // if the audio format is unsupported, the audio data will not be changed
1006 AUDIO_ERR_LOG("unsupport, format: %{public}d", attr_.format);
1007 break;
1008 }
1009 }
1010
CheckUpdateState(char * data,uint64_t len)1011 void AudioRenderSink::CheckUpdateState(char *data, uint64_t len)
1012 {
1013 if (startUpdate_) {
1014 if (renderFrameNum_ == 0) {
1015 last10FrameStartTime_ = ClockTime::GetCurNano();
1016 }
1017 renderFrameNum_++;
1018 maxAmplitude_ = UpdateMaxAmplitude(static_cast<ConvertHdiFormat>(attr_.format), data, len);
1019 if (renderFrameNum_ == GET_MAX_AMPLITUDE_FRAMES_THRESHOLD) {
1020 renderFrameNum_ = 0;
1021 if (last10FrameStartTime_ > lastGetMaxAmplitudeTime_) {
1022 startUpdate_ = false;
1023 maxAmplitude_ = 0;
1024 }
1025 }
1026 }
1027 }
1028
GetAttrInfoStr(const struct AudioSampleAttributes & attrInfo)1029 std::string AudioRenderSink::GetAttrInfoStr(const struct AudioSampleAttributes &attrInfo)
1030 {
1031 CHECK_AND_RETURN_RET_LOG(attrInfo.sampleRate > 0, "", "invalid rate: %{public}d", attrInfo.sampleRate);
1032 CHECK_AND_RETURN_RET_LOG(attrInfo.format > 0, "", "invalid format: %{public}d", attrInfo.format);
1033 CHECK_AND_RETURN_RET_LOG(attrInfo.channelCount > 0, "", "invalid channel: %{public}d", attrInfo.channelCount);
1034
1035 uint32_t bufferSize = attrInfo.sampleRate * attrInfo.format * attrInfo.channelCount *
1036 BUFFER_CALC_20MS / BUFFER_CALC_1000MS;
1037 std::string attrInfoStr = "rate=" + std::to_string(attrInfo.sampleRate) + " format=" +
1038 ParseAudioFormatToStr(attrInfo.format) + " channels=" + std::to_string(attrInfo.channelCount) +
1039 " buffer_size=" + std::to_string(bufferSize);
1040 AUDIO_INFO_LOG("attrInfoStr: %{public}s", attrInfoStr.c_str());
1041 return attrInfoStr;
1042 }
1043
UpdateDPAttr(const std::string & dpInfo)1044 int32_t AudioRenderSink::UpdateDPAttr(const std::string &dpInfo)
1045 {
1046 CHECK_AND_RETURN_RET_LOG(!dpInfo.empty(), ERR_INVALID_PARAM, "dp info is empty");
1047
1048 auto sinkRate_begin = dpInfo.find("rate=");
1049 auto sinkRate_end = dpInfo.find_first_of(" ", sinkRate_begin);
1050 std::string sampleRateStr = dpInfo.substr(sinkRate_begin + std::strlen("rate="),
1051 sinkRate_end - sinkRate_begin - std::strlen("rate="));
1052
1053 auto sinkBuffer_begin = dpInfo.find("buffer_size=");
1054 auto sinkBuffer_end = dpInfo.find_first_of(" ", sinkBuffer_begin);
1055 std::string bufferSizeStr = dpInfo.substr(sinkBuffer_begin + std::strlen("buffer_size="),
1056 sinkBuffer_end - sinkBuffer_begin - std::strlen("buffer_size="));
1057
1058 auto sinkChannel_begin = dpInfo.find("channels=");
1059 auto sinkChannel_end = dpInfo.find_first_of(" ", sinkChannel_begin);
1060 std::string channelStr = dpInfo.substr(sinkChannel_begin + std::strlen("channels="),
1061 sinkChannel_end - sinkChannel_begin - std::strlen("channels="));
1062
1063 auto address_begin = dpInfo.find("address=");
1064 auto address_end = dpInfo.find_first_of(" ", address_begin);
1065 std::string addressStr = dpInfo.substr(address_begin + std::strlen("address="),
1066 address_end - address_begin - std::strlen("address="));
1067
1068 bool ret = StringConverter(sampleRateStr, attr_.sampleRate);
1069 CHECK_AND_RETURN_RET_LOG(ret, ERR_INVALID_PARAM, "convert fail, sampleRate: %{public}s", sampleRateStr.c_str());
1070 ret = StringConverter(channelStr, attr_.channel);
1071 CHECK_AND_RETURN_RET_LOG(ret, ERR_INVALID_PARAM, "convert fail, channel: %{public}s", channelStr.c_str());
1072
1073 attr_.address = addressStr;
1074 uint32_t formatByte = 0;
1075 if (attr_.channel <= 0 || attr_.sampleRate <= 0 || bufferSizeStr.empty()) {
1076 AUDIO_ERR_LOG("check attr fail, channel: %{public}d, sampleRate: %{public}d", attr_.channel, attr_.sampleRate);
1077 } else {
1078 uint32_t bufferSize = 0;
1079 ret = StringConverter(bufferSizeStr, bufferSize);
1080 CHECK_AND_RETURN_RET_LOG(ret, ERR_INVALID_PARAM, "convert fail, bufferSize: %{public}s", bufferSizeStr.c_str());
1081 formatByte = bufferSize * BUFFER_CALC_1000MS / BUFFER_CALC_20MS / attr_.channel / attr_.sampleRate;
1082 }
1083
1084 attr_.format = static_cast<AudioSampleFormat>(ConvertByteToAudioFormat(formatByte));
1085
1086 AUDIO_DEBUG_LOG("sampleRate: %{public}d, format: %{public}d, channelCount: %{public}d, address: %{public}s",
1087 attr_.sampleRate, attr_.format, attr_.channel, addressStr.c_str());
1088
1089 adapterNameCase_ = "dp";
1090 openSpeaker_ = 0;
1091 return SUCCESS;
1092 }
1093
GetDPDeviceInfo(const std::string & condition)1094 std::string AudioRenderSink::GetDPDeviceInfo(const std::string &condition)
1095 {
1096 int32_t ret = UpdateDPAttr(condition);
1097 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, "", "init attr fail");
1098
1099 ret = InitRender();
1100 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, "", "init render fail");
1101
1102 struct AudioSampleAttributes attrInfo = {};
1103 ret = audioRender_->GetSampleAttributes(audioRender_, &attrInfo);
1104 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, "", "get sample attr fail");
1105
1106 AUDIO_DEBUG_LOG("sampleRate: %{public}d, format: %{public}d, channelCount: %{public}d, size: %{public}d",
1107 attrInfo.sampleRate, attrInfo.format, attrInfo.channelCount, attrInfo.frameSize);
1108 return GetAttrInfoStr(attrInfo);
1109 }
1110
GetRouting(void) const1111 std::string AudioRenderSink::GetRouting(void) const
1112 {
1113 switch (currentActiveDevice_) {
1114 case DEVICE_TYPE_EARPIECE:
1115 return "1";
1116 case DEVICE_TYPE_SPEAKER:
1117 return "2";
1118 case DEVICE_TYPE_WIRED_HEADSET:
1119 return "4";
1120 case DEVICE_TYPE_USB_ARM_HEADSET:
1121 return "67108864";
1122 case DEVICE_TYPE_USB_HEADSET:
1123 return "545259520";
1124 case DEVICE_TYPE_BLUETOOTH_SCO:
1125 return "16";
1126 case DEVICE_TYPE_BLUETOOTH_A2DP:
1127 return "128";
1128 default:
1129 break;
1130 }
1131 return "-100";
1132 }
1133
WriteSmartPAStatusSysEvent(int32_t status)1134 void AudioRenderSink::WriteSmartPAStatusSysEvent(int32_t status)
1135 {
1136 std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
1137 Media::MediaMonitor::AUDIO, Media::MediaMonitor::SMARTPA_STATUS,
1138 Media::MediaMonitor::BEHAVIOR_EVENT);
1139 bean->Add("STATUS", status);
1140 Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
1141 }
1142
1143 // must be called with sinkMutex_ held
UpdateSinkState(bool started)1144 void AudioRenderSink::UpdateSinkState(bool started)
1145 {
1146 callback_.OnRenderSinkStateChange(GetUniqueId(), started);
1147 }
1148
1149 } // namespace AudioStandard
1150 } // namespace OHOS
1151