1 /*
2 * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #ifndef LOG_TAG
16 #define LOG_TAG "MultiChannelRendererSinkInner"
17 #endif
18
19 #include "multichannel_audio_renderer_sink.h"
20
21 #include <atomic>
22 #include <cstring>
23 #include <cinttypes>
24 #include <condition_variable>
25 #include <dlfcn.h>
26 #include <string>
27 #include <unistd.h>
28 #include <mutex>
29
30 #include "securec.h"
31 #ifdef FEATURE_POWER_MANAGER
32 #include "power_mgr_client.h"
33 #include "running_lock.h"
34 #include "audio_running_lock_manager.h"
35 #endif
36 #include "v4_0/iaudio_manager.h"
37
38 #include "audio_errors.h"
39 #include "audio_hdi_log.h"
40 #include "audio_utils.h"
41 #include "parameters.h"
42
43 using namespace std;
44
45 namespace OHOS {
46 namespace AudioStandard {
47 namespace {
48 const int32_t HALF_FACTOR = 2;
49 const int32_t MAX_AUDIO_ADAPTER_NUM = 5;
50 const float DEFAULT_VOLUME_LEVEL = 1.0f;
51 const uint32_t AUDIO_SAMPLE_RATE_48K = 48000;
52 const uint32_t DEEP_BUFFER_RENDER_PERIOD_SIZE = 4096;
53 const uint32_t INT_32_MAX = 0x7fffffff;
54 const uint32_t PCM_8_BIT = 8;
55 const uint32_t PCM_16_BIT = 16;
56 const uint32_t PCM_24_BIT = 24;
57 const uint32_t PCM_32_BIT = 32;
58 const uint32_t STEREO_CHANNEL_COUNT = 2;
59 const uint16_t GET_MAX_AMPLITUDE_FRAMES_THRESHOLD = 10;
60
61 #ifdef FEATURE_POWER_MANAGER
62 constexpr int32_t RUNNINGLOCK_LOCK_TIMEOUTMS_LASTING = -1;
63 #endif
64 const int32_t SLEEP_TIME_FOR_RENDER_EMPTY = 120;
65 }
66 class MultiChannelRendererSinkInner : public MultiChannelRendererSink {
67 public:
68 int32_t Init(const IAudioSinkAttr &attr) override;
69 bool IsInited(void) override;
70 void DeInit(void) override;
71
72 int32_t Flush(void) override;
73 int32_t Pause(void) override;
74 int32_t Reset(void) override;
75 int32_t Resume(void) override;
76 int32_t Start(void) override;
77 int32_t Stop(void) override;
78
79 int32_t SuspendRenderSink(void) override;
80 int32_t RestoreRenderSink(void) override;
81
82 int32_t RenderFrame(char &data, uint64_t len, uint64_t &writeLen) override;
83 int32_t SetVolume(float left, float right) override;
84 int32_t GetVolume(float &left, float &right) override;
85 int32_t SetVoiceVolume(float volume) override;
86 int32_t GetLatency(uint32_t *latency) override;
87 int32_t GetTransactionId(uint64_t *transactionId) override;
88 int32_t SetAudioScene(AudioScene audioScene, std::vector<DeviceType> &activeDevices) override;
89
90 void SetAudioParameter(const AudioParamKey key, const std::string &condition, const std::string &value) override;
91 std::string GetAudioParameter(const AudioParamKey key, const std::string &condition) override;
92 void RegisterParameterCallback(IAudioSinkCallback* callback) override;
93 int32_t GetPresentationPosition(uint64_t& frames, int64_t& timeSec, int64_t& timeNanoSec) override;
94
95 void SetAudioMonoState(bool audioMono) override;
96 void SetAudioBalanceValue(float audioBalance) override;
97
98 int32_t SetOutputRoutes(std::vector<DeviceType> &outputDevices) override;
99 int32_t SetOutputRoute(DeviceType outputDevice, AudioPortPin &outputPortPin);
100
101 int32_t Preload(const std::string &usbInfoStr) override;
102 float GetMaxAmplitude() override;
103
104 void ResetOutputRouteForDisconnect(DeviceType device) override;
105 int32_t SetPaPower(int32_t flag) override;
106 int32_t SetPriPaPower() override;
107
108 int32_t UpdateAppsUid(const int32_t appsUid[MAX_MIX_CHANNELS], const size_t size) final;
109 int32_t UpdateAppsUid(const std::vector<int32_t> &appsUid) final;
110
111 explicit MultiChannelRendererSinkInner(const std::string &halName = "multichannel");
112 ~MultiChannelRendererSinkInner();
113 private:
114 IAudioSinkAttr attr_ = {};
115 bool sinkInited_ = false;
116 bool adapterInited_ = false;
117 bool renderInited_ = false;
118 bool started_ = false;
119 bool paused_ = false;
120 float leftVolume_ = 0;
121 float rightVolume_ = 0;
122 int32_t routeHandle_ = -1;
123 int32_t logMode_ = 0;
124 uint32_t openSpeaker_ = 0;
125 uint32_t renderId_ = 0;
126 std::string adapterNameCase_ = "";
127 struct IAudioManager *audioManager_ = nullptr;
128 struct IAudioAdapter *audioAdapter_ = nullptr;
129 struct IAudioRender *audioRender_ = nullptr;
130 std::string halName_;
131 struct AudioAdapterDescriptor adapterDesc_ = {};
132 struct AudioPort audioPort_ = {};
133 bool audioMonoState_ = false;
134 bool audioBalanceState_ = false;
135 float leftBalanceCoef_ = 1.0f;
136 float rightBalanceCoef_ = 1.0f;
137 // for get amplitude
138 float maxAmplitude_ = 0;
139 int64_t lastGetMaxAmplitudeTime_ = 0;
140 int64_t last10FrameStartTime_ = 0;
141 bool startUpdate_ = false;
142 int renderFrameNum_ = 0;
143 #ifdef FEATURE_POWER_MANAGER
144 std::shared_ptr<AudioRunningLockManager<PowerMgr::RunningLock>> runningLockManager_;
145 #endif
146 // for device switch
147 std::atomic<bool> inSwitch_ = false;
148 std::atomic<int32_t> renderEmptyFrameCount_ = 0;
149 std::mutex switchMutex_;
150 std::condition_variable switchCV_;
151
152 private:
153 int32_t CreateRender(const struct AudioPort &renderPort);
154 int32_t InitAudioManager();
155 AudioFormat ConvertToHdiFormat(HdiAdapterFormat format);
156 void AdjustStereoToMono(char *data, uint64_t len);
157 void AdjustAudioBalance(char *data, uint64_t len);
158
159 int32_t UpdateUsbAttrs(const std::string &usbInfoStr);
160 int32_t InitAdapter();
161 int32_t InitRender();
162
163 void CheckUpdateState(char *frame, uint64_t replyBytes);
164
165 void InitAudioRouteNode(AudioRouteNode &source, AudioRouteNode &sink);
166
167 FILE *dumpFile_ = nullptr;
168 DeviceType currentActiveDevice_ = DEVICE_TYPE_NONE;
169 AudioScene currentAudioScene_ = AudioScene::AUDIO_SCENE_INVALID;
170 };
171
MultiChannelRendererSinkInner(const std::string & halName)172 MultiChannelRendererSinkInner::MultiChannelRendererSinkInner(const std::string &halName)
173 : sinkInited_(false), adapterInited_(false), renderInited_(false), started_(false), paused_(false),
174 leftVolume_(DEFAULT_VOLUME_LEVEL), rightVolume_(DEFAULT_VOLUME_LEVEL), openSpeaker_(0),
175 audioManager_(nullptr), audioAdapter_(nullptr), audioRender_(nullptr), halName_(halName)
176 {
177 AUDIO_INFO_LOG("MultiChannelRendererSinkInner");
178 }
179
~MultiChannelRendererSinkInner()180 MultiChannelRendererSinkInner::~MultiChannelRendererSinkInner()
181 {
182 AUDIO_INFO_LOG("~MultiChannelRendererSinkInner");
183 }
184
GetInstance(const std::string & halName)185 MultiChannelRendererSink *MultiChannelRendererSink::GetInstance(const std::string &halName)
186 {
187 static MultiChannelRendererSinkInner audioRenderer;
188 return &audioRenderer;
189 }
190
191 // LCOV_EXCL_START
SwitchAdapterRender(struct AudioAdapterDescriptor * descs,const string & adapterNameCase,enum AudioPortDirection portFlag,struct AudioPort & renderPort,uint32_t size)192 static int32_t SwitchAdapterRender(struct AudioAdapterDescriptor *descs, const string &adapterNameCase,
193 enum AudioPortDirection portFlag, struct AudioPort &renderPort, uint32_t size)
194 {
195 if (descs == nullptr) {
196 return ERROR;
197 }
198 for (uint32_t index = 0; index < size; index++) {
199 struct AudioAdapterDescriptor *desc = &descs[index];
200 if (desc == nullptr || desc->adapterName == nullptr) {
201 continue;
202 }
203 AUDIO_DEBUG_LOG("index %{public}u, adapterName %{public}s", index, desc->adapterName);
204 if (strcmp(desc->adapterName, adapterNameCase.c_str())) {
205 continue;
206 }
207 for (uint32_t port = 0; port < desc->portsLen; port++) {
208 // Only find out the port of out in the sound card
209 if (desc->ports[port].dir == portFlag) {
210 renderPort = desc->ports[port];
211 return index;
212 }
213 }
214 }
215 AUDIO_ERR_LOG("switch adapter render fail");
216 return ERR_INVALID_INDEX;
217 }
218
219
SetAudioParameter(const AudioParamKey key,const std::string & condition,const std::string & value)220 void MultiChannelRendererSinkInner::SetAudioParameter(const AudioParamKey key, const std::string &condition,
221 const std::string &value)
222 {
223 AUDIO_INFO_LOG("SetAudioParameter: key %{public}d, condition: %{public}s, value: %{public}s", key,
224 condition.c_str(), value.c_str());
225 AudioExtParamKey hdiKey = AudioExtParamKey(key);
226 if (audioAdapter_ == nullptr) {
227 AUDIO_ERR_LOG("SetAudioParameter failed, audioAdapter_ is null");
228 return;
229 }
230 int32_t ret = audioAdapter_->SetExtraParams(audioAdapter_, hdiKey, condition.c_str(), value.c_str());
231 if (ret != SUCCESS) {
232 AUDIO_ERR_LOG("SetAudioParameter failed, error code: %d", ret);
233 }
234 }
235
GetAudioParameter(const AudioParamKey key,const std::string & condition)236 std::string MultiChannelRendererSinkInner::GetAudioParameter(const AudioParamKey key, const std::string &condition)
237 {
238 AUDIO_INFO_LOG("GetAudioParameter: key %{public}d, condition: %{public}s", key,
239 condition.c_str());
240 if (condition == "get_usb_info") {
241 // Init adapter to get parameter before load sink module (need fix)
242 adapterNameCase_ = "usb";
243 int32_t ret = InitAdapter();
244 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, "", "Init adapter failed for get usb info param");
245 }
246
247 AudioExtParamKey hdiKey = AudioExtParamKey(key);
248 char value[PARAM_VALUE_LENTH];
249 if (audioAdapter_ == nullptr) {
250 AUDIO_ERR_LOG("GetAudioParameter failed, audioAdapter_ is null");
251 return "";
252 }
253 int32_t ret = audioAdapter_->GetExtraParams(audioAdapter_, hdiKey, condition.c_str(), value, PARAM_VALUE_LENTH);
254 if (ret != SUCCESS) {
255 AUDIO_ERR_LOG("GetAudioParameter failed, error code: %d", ret);
256 return "";
257 }
258 return value;
259 }
260
SetAudioMonoState(bool audioMono)261 void MultiChannelRendererSinkInner::SetAudioMonoState(bool audioMono)
262 {
263 audioMonoState_ = audioMono;
264 }
265
SetAudioBalanceValue(float audioBalance)266 void MultiChannelRendererSinkInner::SetAudioBalanceValue(float audioBalance)
267 {
268 // reset the balance coefficient value firstly
269 leftBalanceCoef_ = 1.0f;
270 rightBalanceCoef_ = 1.0f;
271
272 if (std::abs(audioBalance - 0.0f) <= std::numeric_limits<float>::epsilon()) {
273 // audioBalance is equal to 0.0f
274 audioBalanceState_ = false;
275 } else {
276 // audioBalance is not equal to 0.0f
277 audioBalanceState_ = true;
278 // calculate the balance coefficient
279 if (audioBalance > 0.0f) {
280 leftBalanceCoef_ -= audioBalance;
281 } else if (audioBalance < 0.0f) {
282 rightBalanceCoef_ += audioBalance;
283 }
284 }
285 }
286
AdjustStereoToMono(char * data,uint64_t len)287 void MultiChannelRendererSinkInner::AdjustStereoToMono(char *data, uint64_t len)
288 {
289 if (attr_.channel != STEREO_CHANNEL_COUNT) {
290 // only stereo is surpported now (stereo channel count is 2)
291 AUDIO_ERR_LOG("AdjustStereoToMono: Unsupported channel number: %{public}d", attr_.channel);
292 return;
293 }
294
295 switch (attr_.format) {
296 case SAMPLE_U8: {
297 // this function needs to be further tested for usability
298 AdjustStereoToMonoForPCM8Bit(reinterpret_cast<int8_t *>(data), len);
299 break;
300 }
301 case SAMPLE_S16: {
302 AdjustStereoToMonoForPCM16Bit(reinterpret_cast<int16_t *>(data), len);
303 break;
304 }
305 case SAMPLE_S24: {
306 // this function needs to be further tested for usability
307 AdjustStereoToMonoForPCM24Bit(reinterpret_cast<int8_t *>(data), len);
308 break;
309 }
310 case SAMPLE_S32: {
311 AdjustStereoToMonoForPCM32Bit(reinterpret_cast<int32_t *>(data), len);
312 break;
313 }
314 default: {
315 // if the audio format is unsupported, the audio data will not be changed
316 AUDIO_ERR_LOG("AdjustStereoToMono: Unsupported audio format: %{public}d", attr_.format);
317 break;
318 }
319 }
320 }
321
AdjustAudioBalance(char * data,uint64_t len)322 void MultiChannelRendererSinkInner::AdjustAudioBalance(char *data, uint64_t len)
323 {
324 if (attr_.channel != STEREO_CHANNEL_COUNT) {
325 // only stereo is surpported now (stereo channel count is 2)
326 AUDIO_ERR_LOG("Unsupported channel number: %{public}d", attr_.channel);
327 return;
328 }
329
330 switch (attr_.format) {
331 case SAMPLE_U8: {
332 // this function needs to be further tested for usability
333 AdjustAudioBalanceForPCM8Bit(reinterpret_cast<int8_t *>(data), len, leftBalanceCoef_, rightBalanceCoef_);
334 break;
335 }
336 case SAMPLE_S16LE: {
337 AdjustAudioBalanceForPCM16Bit(reinterpret_cast<int16_t *>(data), len, leftBalanceCoef_, rightBalanceCoef_);
338 break;
339 }
340 case SAMPLE_S24LE: {
341 // this function needs to be further tested for usability
342 AdjustAudioBalanceForPCM24Bit(reinterpret_cast<int8_t *>(data), len, leftBalanceCoef_, rightBalanceCoef_);
343 break;
344 }
345 case SAMPLE_S32LE: {
346 AdjustAudioBalanceForPCM32Bit(reinterpret_cast<int32_t *>(data), len, leftBalanceCoef_, rightBalanceCoef_);
347 break;
348 }
349 default: {
350 // if the audio format is unsupported, the audio data will not be changed
351 AUDIO_ERR_LOG("Unsupported audio format: %{public}d", attr_.format);
352 break;
353 }
354 }
355 }
356
IsInited()357 bool MultiChannelRendererSinkInner::IsInited()
358 {
359 return sinkInited_;
360 }
361
RegisterParameterCallback(IAudioSinkCallback * callback)362 void MultiChannelRendererSinkInner::RegisterParameterCallback(IAudioSinkCallback* callback)
363 {
364 AUDIO_ERR_LOG("RegisterParameterCallback not supported.");
365 }
366
GetPresentationPosition(uint64_t & frames,int64_t & timeSec,int64_t & timeNanoSec)367 int32_t MultiChannelRendererSinkInner::GetPresentationPosition(uint64_t& frames, int64_t& timeSec, int64_t& timeNanoSec)
368 {
369 AUDIO_ERR_LOG("not supported.");
370 return ERR_INVALID_HANDLE;
371 }
372
DeInit()373 void MultiChannelRendererSinkInner::DeInit()
374 {
375 AUDIO_INFO_LOG("Mch DeInit.");
376 started_ = false;
377 sinkInited_ = false;
378
379 if (audioAdapter_ != nullptr) {
380 AUDIO_INFO_LOG("DestroyRender rendererid: %{public}u", renderId_);
381 audioAdapter_->DestroyRender(audioAdapter_, renderId_);
382 }
383 audioRender_ = nullptr;
384 renderInited_ = false;
385 audioManager_ = nullptr;
386 adapterInited_ = false;
387
388 DumpFileUtil::CloseDumpFile(&dumpFile_);
389 }
390
InitAttrs(struct AudioSampleAttributes & attrs)391 void InitAttrs(struct AudioSampleAttributes &attrs)
392 {
393 /* Initialization of audio parameters for playback */
394 attrs.channelCount = CHANNEL_6;
395 attrs.sampleRate = AUDIO_SAMPLE_RATE_48K;
396 attrs.interleaved = true;
397 attrs.streamId = static_cast<int32_t>(GenerateUniqueID(AUDIO_HDI_RENDER_ID_BASE, HDI_RENDER_OFFSET_MULTICHANNEL));
398 attrs.type = AUDIO_MULTI_CHANNEL;
399 attrs.period = DEEP_BUFFER_RENDER_PERIOD_SIZE;
400 attrs.isBigEndian = false;
401 attrs.isSignedData = true;
402 attrs.stopThreshold = INT_32_MAX;
403 attrs.silenceThreshold = 0;
404 }
405
InitAudioManager()406 int32_t MultiChannelRendererSinkInner::InitAudioManager()
407 {
408 AUDIO_INFO_LOG("Initialize audio proxy manager");
409
410 audioManager_ = IAudioManagerGet(false);
411 if (audioManager_ == nullptr) {
412 return ERR_INVALID_HANDLE;
413 }
414
415 return 0;
416 }
417
PcmFormatToBits(enum AudioFormat format)418 uint32_t PcmFormatToBits(enum AudioFormat format)
419 {
420 switch (format) {
421 case AUDIO_FORMAT_TYPE_PCM_8_BIT:
422 return PCM_8_BIT;
423 case AUDIO_FORMAT_TYPE_PCM_16_BIT:
424 return PCM_16_BIT;
425 case AUDIO_FORMAT_TYPE_PCM_24_BIT:
426 return PCM_24_BIT;
427 case AUDIO_FORMAT_TYPE_PCM_32_BIT:
428 return PCM_32_BIT;
429 default:
430 AUDIO_INFO_LOG("Unkown format type,set it to default");
431 return PCM_24_BIT;
432 }
433 }
434
ConvertToHdiFormat(HdiAdapterFormat format)435 AudioFormat MultiChannelRendererSinkInner::ConvertToHdiFormat(HdiAdapterFormat format)
436 {
437 AudioFormat hdiFormat;
438 switch (format) {
439 case SAMPLE_U8:
440 hdiFormat = AUDIO_FORMAT_TYPE_PCM_8_BIT;
441 break;
442 case SAMPLE_S16:
443 hdiFormat = AUDIO_FORMAT_TYPE_PCM_16_BIT;
444 break;
445 case SAMPLE_S24:
446 hdiFormat = AUDIO_FORMAT_TYPE_PCM_24_BIT;
447 break;
448 case SAMPLE_S32:
449 hdiFormat = AUDIO_FORMAT_TYPE_PCM_32_BIT;
450 break;
451 default:
452 hdiFormat = AUDIO_FORMAT_TYPE_PCM_16_BIT;
453 break;
454 }
455
456 return hdiFormat;
457 }
458
CreateRender(const struct AudioPort & renderPort)459 int32_t MultiChannelRendererSinkInner::CreateRender(const struct AudioPort &renderPort)
460 {
461 int32_t ret;
462 struct AudioSampleAttributes param;
463 struct AudioDeviceDescriptor deviceDesc;
464 InitAttrs(param);
465 param.sampleRate = attr_.sampleRate;
466 param.channelCount = attr_.channel;
467 param.channelLayout = attr_.channelLayout;
468 param.format = ConvertToHdiFormat(attr_.format);
469 param.frameSize = PcmFormatToBits(param.format) * param.channelCount / PCM_8_BIT;
470 param.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (param.frameSize);
471 deviceDesc.portId = renderPort.portId;
472 deviceDesc.desc = const_cast<char *>("");
473 deviceDesc.pins = PIN_OUT_SPEAKER;
474 if (halName_ == "usb") {
475 deviceDesc.pins = PIN_OUT_USB_HEADSET;
476 }
477 AUDIO_INFO_LOG("Create render halname: %{public}s format: %{public}d, sampleRate:%{public}u channel%{public}u",
478 halName_.c_str(), param.format, param.sampleRate, param.channelCount);
479 ret = audioAdapter_->CreateRender(audioAdapter_, &deviceDesc, ¶m, &audioRender_, &renderId_);
480 if (ret != 0 || audioRender_ == nullptr) {
481 AUDIO_ERR_LOG("AudioDeviceCreateRender failed.");
482 return ERR_NOT_STARTED;
483 }
484 AUDIO_INFO_LOG("Create success rendererid: %{public}u", renderId_);
485
486 return 0;
487 }
488
Init(const IAudioSinkAttr & attr)489 int32_t MultiChannelRendererSinkInner::Init(const IAudioSinkAttr &attr)
490 {
491 attr_ = attr;
492 adapterNameCase_ = attr_.adapterName;
493 openSpeaker_ = attr_.openMicSpeaker;
494 logMode_ = system::GetIntParameter("persist.multimedia.audiolog.switch", 0);
495 int32_t ret = InitAdapter();
496 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Init adapter failed");
497
498 ret = InitRender();
499 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Init render failed");
500
501 sinkInited_ = true;
502
503 return SUCCESS;
504 }
505
RenderFrame(char & data,uint64_t len,uint64_t & writeLen)506 int32_t MultiChannelRendererSinkInner::RenderFrame(char &data, uint64_t len, uint64_t &writeLen)
507 {
508 int64_t stamp = ClockTime::GetCurNano();
509 int32_t ret;
510 if (audioRender_ == nullptr) {
511 AUDIO_ERR_LOG("Audio Render Handle is nullptr!");
512 return ERR_INVALID_HANDLE;
513 }
514
515 if (audioMonoState_) {
516 AdjustStereoToMono(&data, len);
517 }
518
519 if (audioBalanceState_) {
520 AdjustAudioBalance(&data, len);
521 }
522
523 DumpFileUtil::WriteDumpFile(dumpFile_, static_cast<void *>(&data), len);
524 CheckUpdateState(&data, len);
525
526 if (inSwitch_) {
527 Trace traceInSwitch("AudioRendererSinkInner::RenderFrame::inSwitch");
528 writeLen = len;
529 return SUCCESS;
530 }
531 if (renderEmptyFrameCount_ > 0) {
532 Trace traceEmpty("MchSinkInner::RenderFrame::renderEmpty");
533 if (memset_s(reinterpret_cast<void*>(&data), static_cast<size_t>(len), 0,
534 static_cast<size_t>(len)) != EOK) {
535 AUDIO_WARNING_LOG("call memset_s failed");
536 }
537 renderEmptyFrameCount_--;
538 if (renderEmptyFrameCount_ == 0) {
539 switchCV_.notify_all();
540 }
541 }
542 Trace::CountVolume("MultiChannelRendererSinkInner::RenderFrame", static_cast<uint8_t>(data));
543 Trace trace("MchSinkInner::RenderFrame");
544
545 ret = audioRender_->RenderFrame(audioRender_, reinterpret_cast<int8_t*>(&data), static_cast<uint32_t>(len),
546 &writeLen);
547 if (ret != 0) {
548 AUDIO_ERR_LOG("RenderFrame failed ret: %{public}x", ret);
549 return ERR_WRITE_FAILED;
550 }
551 stamp = (ClockTime::GetCurNano() - stamp) / AUDIO_US_PER_SECOND;
552 if (logMode_) {
553 AUDIO_DEBUG_LOG("RenderFrame len[%{public}" PRIu64 "] cost[%{public}" PRId64 "]ms", len, stamp);
554 }
555 return SUCCESS;
556 }
557
CheckUpdateState(char * frame,uint64_t replyBytes)558 void MultiChannelRendererSinkInner::CheckUpdateState(char *frame, uint64_t replyBytes)
559 {
560 if (startUpdate_) {
561 if (renderFrameNum_ == 0) {
562 last10FrameStartTime_ = ClockTime::GetCurNano();
563 }
564 renderFrameNum_++;
565 maxAmplitude_ = UpdateMaxAmplitude(static_cast<ConvertHdiFormat>(attr_.format), frame, replyBytes);
566 if (renderFrameNum_ == GET_MAX_AMPLITUDE_FRAMES_THRESHOLD) {
567 renderFrameNum_ = 0;
568 if (last10FrameStartTime_ > lastGetMaxAmplitudeTime_) {
569 startUpdate_ = false;
570 maxAmplitude_ = 0;
571 }
572 }
573 }
574 }
575
GetMaxAmplitude()576 float MultiChannelRendererSinkInner::GetMaxAmplitude()
577 {
578 lastGetMaxAmplitudeTime_ = ClockTime::GetCurNano();
579 startUpdate_ = true;
580 return maxAmplitude_;
581 }
582
Start(void)583 int32_t MultiChannelRendererSinkInner::Start(void)
584 {
585 Trace trace("MCHSink::Start");
586 #ifdef FEATURE_POWER_MANAGER
587 std::shared_ptr<PowerMgr::RunningLock> keepRunningLock;
588 if (runningLockManager_ == nullptr) {
589 keepRunningLock = PowerMgr::PowerMgrClient::GetInstance().CreateRunningLock("AudioMultiChannelBackgroundPlay",
590 PowerMgr::RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO);
591 if (keepRunningLock) {
592 runningLockManager_ = std::make_shared<AudioRunningLockManager<PowerMgr::RunningLock>> (keepRunningLock);
593 }
594 }
595
596 if (runningLockManager_ != nullptr) {
597 AUDIO_INFO_LOG("keepRunningLock lock");
598 runningLockManager_->Lock(RUNNINGLOCK_LOCK_TIMEOUTMS_LASTING); // -1 for lasting.
599 } else {
600 AUDIO_WARNING_LOG("keepRunningLock is null, playback can not work well!");
601 }
602 #endif
603 DumpFileUtil::OpenDumpFile(DUMP_SERVER_PARA, DUMP_MCH_SINK_FILENAME, &dumpFile_);
604
605 if (!started_) {
606 int32_t ret = audioRender_->Start(audioRender_);
607 if (ret) {
608 AUDIO_ERR_LOG("Mch Start failed!");
609 return ERR_NOT_STARTED;
610 }
611 started_ = true;
612 uint64_t frameSize = 0;
613 uint64_t frameCount = 0;
614 ret = audioRender_->GetFrameSize(audioRender_, &frameSize);
615 if (ret) {
616 AUDIO_ERR_LOG("Mch GetFrameSize failed!");
617 return ERR_NOT_STARTED;
618 }
619 ret = audioRender_->GetFrameCount(audioRender_, &frameCount);
620 if (ret) {
621 AUDIO_ERR_LOG("Mch GetFrameCount failed!");
622 return ERR_NOT_STARTED;
623 }
624 ret = audioRender_->SetVolume(audioRender_, 1);
625 if (ret) {
626 AUDIO_ERR_LOG("Mch setvolume failed!");
627 return ERR_NOT_STARTED;
628 }
629 }
630
631 return SUCCESS;
632 }
633
SetVolume(float left,float right)634 int32_t MultiChannelRendererSinkInner::SetVolume(float left, float right)
635 {
636 int32_t ret;
637 float volume;
638
639 if (audioRender_ == nullptr) {
640 AUDIO_ERR_LOG("SetVolume failed audioRender_ null");
641 return ERR_INVALID_HANDLE;
642 }
643
644 leftVolume_ = left;
645 rightVolume_ = right;
646 if ((leftVolume_ == 0) && (rightVolume_ != 0)) {
647 volume = rightVolume_;
648 } else if ((leftVolume_ != 0) && (rightVolume_ == 0)) {
649 volume = leftVolume_;
650 } else {
651 volume = (leftVolume_ + rightVolume_) / HALF_FACTOR;
652 }
653
654 ret = audioRender_->SetVolume(audioRender_, volume);
655 if (ret) {
656 AUDIO_ERR_LOG("Set volume failed!");
657 }
658
659 return ret;
660 }
661
GetVolume(float & left,float & right)662 int32_t MultiChannelRendererSinkInner::GetVolume(float &left, float &right)
663 {
664 left = leftVolume_;
665 right = rightVolume_;
666 return SUCCESS;
667 }
668
SetVoiceVolume(float volume)669 int32_t MultiChannelRendererSinkInner::SetVoiceVolume(float volume)
670 {
671 Trace trace("AudioRendererSinkInner::SetVoiceVolume");
672 if (audioAdapter_ == nullptr) {
673 AUDIO_ERR_LOG("SetVoiceVolume failed, audioAdapter_ is null");
674 return ERR_INVALID_HANDLE;
675 }
676 AUDIO_DEBUG_LOG("SetVoiceVolume %{public}f", volume);
677 return audioAdapter_->SetVoiceVolume(audioAdapter_, volume);
678 }
679
GetLatency(uint32_t * latency)680 int32_t MultiChannelRendererSinkInner::GetLatency(uint32_t *latency)
681 {
682 Trace trace("MultiChannelRendererSinkInner::GetLatency");
683 if (audioRender_ == nullptr) {
684 AUDIO_ERR_LOG("GetLatency failed audio render null");
685 return ERR_INVALID_HANDLE;
686 }
687
688 if (!latency) {
689 AUDIO_ERR_LOG("GetLatency failed latency null");
690 return ERR_INVALID_PARAM;
691 }
692
693 uint32_t hdiLatency;
694 if (audioRender_->GetLatency(audioRender_, &hdiLatency) == 0) {
695 *latency = hdiLatency;
696 return SUCCESS;
697 } else {
698 return ERR_OPERATION_FAILED;
699 }
700 }
701
GetAudioCategory(AudioScene audioScene)702 static AudioCategory GetAudioCategory(AudioScene audioScene)
703 {
704 AudioCategory audioCategory;
705 switch (audioScene) {
706 case AUDIO_SCENE_DEFAULT:
707 audioCategory = AUDIO_IN_MEDIA;
708 break;
709 case AUDIO_SCENE_RINGING:
710 case AUDIO_SCENE_VOICE_RINGING:
711 audioCategory = AUDIO_IN_RINGTONE;
712 break;
713 case AUDIO_SCENE_PHONE_CALL:
714 audioCategory = AUDIO_IN_CALL;
715 break;
716 case AUDIO_SCENE_PHONE_CHAT:
717 audioCategory = AUDIO_IN_COMMUNICATION;
718 break;
719 default:
720 audioCategory = AUDIO_IN_MEDIA;
721 break;
722 }
723 AUDIO_DEBUG_LOG("Audio category returned is: %{public}d", audioCategory);
724
725 return audioCategory;
726 }
727
SetOutputPortPin(DeviceType outputDevice,AudioRouteNode & sink)728 static int32_t SetOutputPortPin(DeviceType outputDevice, AudioRouteNode &sink)
729 {
730 int32_t ret = SUCCESS;
731 switch (outputDevice) {
732 case DEVICE_TYPE_EARPIECE:
733 sink.ext.device.type = PIN_OUT_EARPIECE;
734 sink.ext.device.desc = (char *)"pin_out_earpiece";
735 break;
736 case DEVICE_TYPE_SPEAKER:
737 sink.ext.device.type = PIN_OUT_SPEAKER;
738 sink.ext.device.desc = (char *)"pin_out_speaker";
739 break;
740 case DEVICE_TYPE_WIRED_HEADSET:
741 sink.ext.device.type = PIN_OUT_HEADSET;
742 sink.ext.device.desc = (char *)"pin_out_headset";
743 break;
744 case DEVICE_TYPE_USB_ARM_HEADSET:
745 sink.ext.device.type = PIN_OUT_USB_HEADSET;
746 sink.ext.device.desc = (char *)"pin_out_usb_headset";
747 break;
748 case DEVICE_TYPE_USB_HEADSET:
749 sink.ext.device.type = PIN_OUT_USB_EXT;
750 sink.ext.device.desc = (char *)"pin_out_usb_ext";
751 break;
752 case DEVICE_TYPE_BLUETOOTH_SCO:
753 sink.ext.device.type = PIN_OUT_BLUETOOTH_SCO;
754 sink.ext.device.desc = (char *)"pin_out_bluetooth_sco";
755 break;
756 case DEVICE_TYPE_BLUETOOTH_A2DP:
757 sink.ext.device.type = PIN_OUT_BLUETOOTH_A2DP;
758 sink.ext.device.desc = (char *)"pin_out_bluetooth_a2dp";
759 break;
760 default:
761 ret = ERR_NOT_SUPPORTED;
762 break;
763 }
764
765 return ret;
766 }
767
SetOutputRoutes(std::vector<DeviceType> & outputDevices)768 int32_t MultiChannelRendererSinkInner::SetOutputRoutes(std::vector<DeviceType> &outputDevices)
769 {
770 CHECK_AND_RETURN_RET_LOG(!outputDevices.empty() && outputDevices.size() <= AUDIO_CONCURRENT_ACTIVE_DEVICES_LIMIT,
771 ERR_INVALID_PARAM, "Invalid audio devices.");
772 DeviceType outputDevice = outputDevices.front();
773 AudioPortPin outputPortPin = PIN_OUT_SPEAKER;
774 return SetOutputRoute(outputDevice, outputPortPin);
775 }
776
SetOutputRoute(DeviceType outputDevice,AudioPortPin & outputPortPin)777 int32_t MultiChannelRendererSinkInner::SetOutputRoute(DeviceType outputDevice, AudioPortPin &outputPortPin)
778 {
779 if (outputDevice == currentActiveDevice_) {
780 AUDIO_INFO_LOG("SetOutputRoute output device not change");
781 return SUCCESS;
782 }
783 currentActiveDevice_ = outputDevice;
784
785 AudioRouteNode source = {};
786 AudioRouteNode sink = {};
787
788 int32_t ret = SetOutputPortPin(outputDevice, sink);
789 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "SetOutputRoute FAILED: %{public}d", ret);
790
791 outputPortPin = sink.ext.device.type;
792 AUDIO_INFO_LOG("Output PIN is: 0x%{public}X", outputPortPin);
793
794 InitAudioRouteNode(source, sink);
795
796 AudioRoute route = {
797 .sources = &source,
798 .sourcesLen = 1,
799 .sinks = &sink,
800 .sinksLen = 1,
801 };
802
803 renderEmptyFrameCount_ = 5; // preRender 5 frames
804 std::unique_lock<std::mutex> lock(switchMutex_);
805 switchCV_.wait_for(lock, std::chrono::milliseconds(SLEEP_TIME_FOR_RENDER_EMPTY), [this] {
806 if (renderEmptyFrameCount_ == 0) {
807 AUDIO_INFO_LOG("Wait for preRender end.");
808 return true;
809 }
810 AUDIO_DEBUG_LOG("Current renderEmptyFrameCount_ is %{public}d", renderEmptyFrameCount_.load());
811 return false;
812 });
813 int64_t stamp = ClockTime::GetCurNano();
814 CHECK_AND_RETURN_RET_LOG(audioAdapter_ != nullptr, ERR_INVALID_HANDLE, "SetOutputRoute failed with null adapter");
815 inSwitch_.store(true);
816 ret = audioAdapter_->UpdateAudioRoute(audioAdapter_, &route, &routeHandle_);
817 inSwitch_.store(false);
818 stamp = (ClockTime::GetCurNano() - stamp) / AUDIO_US_PER_SECOND;
819 AUDIO_INFO_LOG("UpdateAudioRoute cost[%{public}" PRId64 "]ms", stamp);
820 renderEmptyFrameCount_ = 5; // render 5 empty frame
821 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "UpdateAudioRoute failed");
822
823 return SUCCESS;
824 }
825
InitAudioRouteNode(AudioRouteNode & source,AudioRouteNode & sink)826 void MultiChannelRendererSinkInner::InitAudioRouteNode(AudioRouteNode &source, AudioRouteNode &sink)
827 {
828 source.portId = 0;
829 source.role = AUDIO_PORT_SOURCE_ROLE;
830 source.type = AUDIO_PORT_MIX_TYPE;
831 source.ext.mix.moduleId = 0;
832 source.ext.mix.streamId = static_cast<int32_t>(
833 GenerateUniqueID(AUDIO_HDI_RENDER_ID_BASE, HDI_RENDER_OFFSET_MULTICHANNEL));
834 source.ext.device.desc = (char *)"";
835
836 sink.portId = static_cast<int32_t>(audioPort_.portId);
837 sink.role = AUDIO_PORT_SINK_ROLE;
838 sink.type = AUDIO_PORT_DEVICE_TYPE;
839 sink.ext.device.moduleId = 0;
840 sink.ext.device.desc = (char *)"";
841 }
842
SetAudioScene(AudioScene audioScene,std::vector<DeviceType> & activeDevices)843 int32_t MultiChannelRendererSinkInner::SetAudioScene(AudioScene audioScene, std::vector<DeviceType> &activeDevices)
844 {
845 CHECK_AND_RETURN_RET_LOG(!activeDevices.empty() && activeDevices.size() <= AUDIO_CONCURRENT_ACTIVE_DEVICES_LIMIT,
846 ERR_INVALID_PARAM, "Invalid audio devices.");
847 DeviceType activeDevice = activeDevices.front();
848 AUDIO_INFO_LOG("SetAudioScene scene: %{public}d, device: %{public}d", audioScene, activeDevice);
849 CHECK_AND_RETURN_RET_LOG(audioScene >= AUDIO_SCENE_DEFAULT && audioScene < AUDIO_SCENE_MAX,
850 ERR_INVALID_PARAM, "invalid audioScene");
851 if (audioRender_ == nullptr) {
852 AUDIO_ERR_LOG("SetAudioScene failed audio render handle is null!");
853 return ERR_INVALID_HANDLE;
854 }
855 if (openSpeaker_) {
856 AudioPortPin audioSceneOutPort = PIN_OUT_SPEAKER;
857 if (halName_ == "usb") {
858 audioSceneOutPort = PIN_OUT_USB_HEADSET;
859 }
860
861 AUDIO_DEBUG_LOG("OUTPUT port is %{public}d", audioSceneOutPort);
862 int32_t ret = SUCCESS;
863 if (audioScene != currentAudioScene_) {
864 struct AudioSceneDescriptor scene;
865 scene.scene.id = GetAudioCategory(audioScene);
866 scene.desc.pins = audioSceneOutPort;
867 scene.desc.desc = (char *)"";
868
869 ret = audioRender_->SelectScene(audioRender_, &scene);
870 if (ret < 0) {
871 AUDIO_ERR_LOG("Select scene FAILED: %{public}d", ret);
872 return ERR_OPERATION_FAILED;
873 }
874 currentAudioScene_ = audioScene;
875 }
876
877 ret = SetOutputRoute(activeDevice, audioSceneOutPort);
878 if (ret < 0) {
879 AUDIO_ERR_LOG("Update route FAILED: %{public}d", ret);
880 }
881 }
882 return SUCCESS;
883 }
884
GetTransactionId(uint64_t * transactionId)885 int32_t MultiChannelRendererSinkInner::GetTransactionId(uint64_t *transactionId)
886 {
887 AUDIO_INFO_LOG("MultiChannelRendererSinkInner::GetTransactionId");
888
889 if (audioRender_ == nullptr) {
890 AUDIO_ERR_LOG("GetTransactionId failed audio render null");
891 return ERR_INVALID_HANDLE;
892 }
893
894 if (!transactionId) {
895 AUDIO_ERR_LOG("GetTransactionId failed transactionId null");
896 return ERR_INVALID_PARAM;
897 }
898
899 *transactionId = reinterpret_cast<uint64_t>(audioRender_);
900 return SUCCESS;
901 }
902
Stop(void)903 int32_t MultiChannelRendererSinkInner::Stop(void)
904 {
905 Trace trace("MCHSink::Stop");
906 AUDIO_INFO_LOG("Stop.");
907 #ifdef FEATURE_POWER_MANAGER
908 if (runningLockManager_ != nullptr) {
909 AUDIO_INFO_LOG("keepRunningLock unLock");
910 runningLockManager_->UnLock();
911 } else {
912 AUDIO_WARNING_LOG("keepRunningLock is null, playback can not work well!");
913 }
914 #endif
915
916 if (audioRender_ == nullptr) {
917 AUDIO_ERR_LOG("Stop failed audioRender_ null");
918 return ERR_INVALID_HANDLE;
919 }
920
921 if (started_) {
922 int32_t ret = audioRender_->Stop(audioRender_);
923 if (!ret) {
924 started_ = false;
925 return SUCCESS;
926 } else {
927 AUDIO_ERR_LOG("Stop failed!");
928 return ERR_OPERATION_FAILED;
929 }
930 }
931
932 return SUCCESS;
933 }
934
Pause(void)935 int32_t MultiChannelRendererSinkInner::Pause(void)
936 {
937 Trace trace("MCHSink::Pause");
938 if (audioRender_ == nullptr) {
939 AUDIO_ERR_LOG("Pause failed audioRender_ null");
940 return ERR_INVALID_HANDLE;
941 }
942
943 if (!started_) {
944 AUDIO_ERR_LOG("Pause invalid state!");
945 return ERR_OPERATION_FAILED;
946 }
947
948 if (!paused_) {
949 int32_t ret = audioRender_->Pause(audioRender_);
950 if (!ret) {
951 paused_ = true;
952 return SUCCESS;
953 } else {
954 AUDIO_ERR_LOG("Pause failed!");
955 return ERR_OPERATION_FAILED;
956 }
957 }
958
959 return SUCCESS;
960 }
961
Resume(void)962 int32_t MultiChannelRendererSinkInner::Resume(void)
963 {
964 if (audioRender_ == nullptr) {
965 AUDIO_ERR_LOG("Resume failed audioRender_ null");
966 return ERR_INVALID_HANDLE;
967 }
968
969 if (!started_) {
970 AUDIO_ERR_LOG("Resume invalid state!");
971 return ERR_OPERATION_FAILED;
972 }
973
974 if (paused_) {
975 int32_t ret = audioRender_->Resume(audioRender_);
976 if (!ret) {
977 paused_ = false;
978 return SUCCESS;
979 } else {
980 AUDIO_ERR_LOG("Resume failed!");
981 return ERR_OPERATION_FAILED;
982 }
983 }
984
985 return SUCCESS;
986 }
987
Reset(void)988 int32_t MultiChannelRendererSinkInner::Reset(void)
989 {
990 if (started_ && audioRender_ != nullptr) {
991 int32_t ret = audioRender_->Flush(audioRender_);
992 if (!ret) {
993 return SUCCESS;
994 } else {
995 AUDIO_ERR_LOG("Reset failed!");
996 return ERR_OPERATION_FAILED;
997 }
998 }
999
1000 return ERR_OPERATION_FAILED;
1001 }
1002
Flush(void)1003 int32_t MultiChannelRendererSinkInner::Flush(void)
1004 {
1005 Trace trace("MCHSink::Flush");
1006 if (started_ && audioRender_ != nullptr) {
1007 int32_t ret = audioRender_->Flush(audioRender_);
1008 if (!ret) {
1009 return SUCCESS;
1010 } else {
1011 AUDIO_ERR_LOG("Flush failed!");
1012 return ERR_OPERATION_FAILED;
1013 }
1014 }
1015
1016 return ERR_OPERATION_FAILED;
1017 }
1018
SuspendRenderSink(void)1019 int32_t MultiChannelRendererSinkInner::SuspendRenderSink(void)
1020 {
1021 return SUCCESS;
1022 }
1023
RestoreRenderSink(void)1024 int32_t MultiChannelRendererSinkInner::RestoreRenderSink(void)
1025 {
1026 return SUCCESS;
1027 }
1028
Preload(const std::string & usbInfoStr)1029 int32_t MultiChannelRendererSinkInner::Preload(const std::string &usbInfoStr)
1030 {
1031 CHECK_AND_RETURN_RET_LOG(halName_ == "usb", ERR_INVALID_OPERATION, "Preload only supported for usb");
1032
1033 int32_t ret = UpdateUsbAttrs(usbInfoStr);
1034 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Preload failed when init attr");
1035
1036 ret = InitAdapter();
1037 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Preload failed when init adapter");
1038
1039 ret = InitRender();
1040 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Preload failed when init render");
1041
1042 return SUCCESS;
1043 }
1044
ParseAudioFormat(const std::string & format)1045 static HdiAdapterFormat ParseAudioFormat(const std::string &format)
1046 {
1047 if (format == "AUDIO_FORMAT_PCM_16_BIT") {
1048 return HdiAdapterFormat::SAMPLE_S16;
1049 } else if (format == "AUDIO_FORMAT_PCM_24_BIT") {
1050 return HdiAdapterFormat::SAMPLE_S24;
1051 } else if (format == "AUDIO_FORMAT_PCM_32_BIT") {
1052 return HdiAdapterFormat::SAMPLE_S32;
1053 } else {
1054 return HdiAdapterFormat::SAMPLE_S16;
1055 }
1056 }
1057
UpdateUsbAttrs(const std::string & usbInfoStr)1058 int32_t MultiChannelRendererSinkInner::UpdateUsbAttrs(const std::string &usbInfoStr)
1059 {
1060 CHECK_AND_RETURN_RET_LOG(usbInfoStr != "", ERR_INVALID_PARAM, "usb info string error");
1061
1062 auto sinkRate_begin = usbInfoStr.find("sink_rate:");
1063 auto sinkRate_end = usbInfoStr.find_first_of(";", sinkRate_begin);
1064 std::string sampleRateStr = usbInfoStr.substr(sinkRate_begin + std::strlen("sink_rate:"),
1065 sinkRate_end - sinkRate_begin - std::strlen("sink_rate:"));
1066 auto sinkFormat_begin = usbInfoStr.find("sink_format:");
1067 auto sinkFormat_end = usbInfoStr.find_first_of(";", sinkFormat_begin);
1068 std::string formatStr = usbInfoStr.substr(sinkFormat_begin + std::strlen("sink_format:"),
1069 sinkFormat_end - sinkFormat_begin - std::strlen("sink_format:"));
1070
1071 // usb default config
1072 attr_.sampleRate = static_cast<uint32_t>(stoi(sampleRateStr));
1073 attr_.channel = STEREO_CHANNEL_COUNT;
1074 attr_.format = ParseAudioFormat(formatStr);
1075
1076 adapterNameCase_ = "usb";
1077 openSpeaker_ = 0;
1078
1079 return SUCCESS;
1080 }
1081
InitAdapter()1082 int32_t MultiChannelRendererSinkInner::InitAdapter()
1083 {
1084 AUDIO_INFO_LOG("MultiChannelRendererSinkInner::InitAdapter");
1085
1086 if (adapterInited_) {
1087 AUDIO_INFO_LOG("Adapter already inited");
1088 return SUCCESS;
1089 }
1090
1091 if (InitAudioManager() != 0) {
1092 AUDIO_ERR_LOG("Init audio manager Fail.");
1093 return ERR_NOT_STARTED;
1094 }
1095
1096 AudioAdapterDescriptor descs[MAX_AUDIO_ADAPTER_NUM];
1097 uint32_t size = MAX_AUDIO_ADAPTER_NUM;
1098 if (audioManager_ == nullptr) {
1099 AUDIO_ERR_LOG("The audioManager is nullptr.");
1100 return ERROR;
1101 }
1102 int32_t ret = audioManager_->GetAllAdapters(audioManager_, (struct AudioAdapterDescriptor *)&descs, &size);
1103 if (size > MAX_AUDIO_ADAPTER_NUM || size == 0 || ret != 0) {
1104 AUDIO_ERR_LOG("Get adapters failed");
1105 return ERR_NOT_STARTED;
1106 }
1107
1108 enum AudioPortDirection port = PORT_OUT;
1109 int32_t index =
1110 SwitchAdapterRender((struct AudioAdapterDescriptor *)&descs, "primary", port, audioPort_, size);
1111 CHECK_AND_RETURN_RET_LOG((index >= 0), ERR_NOT_STARTED, "Switch Adapter failed");
1112
1113 adapterDesc_ = descs[index];
1114 CHECK_AND_RETURN_RET_LOG((audioManager_->LoadAdapter(audioManager_, &adapterDesc_, &audioAdapter_) == SUCCESS),
1115 ERR_NOT_STARTED, "Load Adapter Fail.");
1116
1117 adapterInited_ = true;
1118
1119 return SUCCESS;
1120 }
1121
InitRender()1122 int32_t MultiChannelRendererSinkInner::InitRender()
1123 {
1124 AUDIO_INFO_LOG("MultiChannelRendererSinkInner::InitRender");
1125
1126 if (renderInited_) {
1127 AUDIO_INFO_LOG("Render already inited");
1128 return SUCCESS;
1129 }
1130
1131 CHECK_AND_RETURN_RET_LOG((audioAdapter_ != nullptr), ERR_NOT_STARTED, "Audio device not loaded");
1132
1133 // Initialization port information, can fill through mode and other parameters
1134 CHECK_AND_RETURN_RET_LOG((audioAdapter_->InitAllPorts(audioAdapter_) == SUCCESS),
1135 ERR_NOT_STARTED, "Init ports failed");
1136
1137 if (CreateRender(audioPort_) != 0) {
1138 AUDIO_ERR_LOG("Create render failed, Audio Port: %{public}d", audioPort_.portId);
1139 return ERR_NOT_STARTED;
1140 }
1141
1142 renderInited_ = true;
1143
1144 return SUCCESS;
1145 }
1146
ResetOutputRouteForDisconnect(DeviceType device)1147 void MultiChannelRendererSinkInner::ResetOutputRouteForDisconnect(DeviceType device)
1148 {
1149 if (currentActiveDevice_ == device) {
1150 currentActiveDevice_ = DEVICE_TYPE_NONE;
1151 }
1152 }
1153
SetPaPower(int32_t flag)1154 int32_t MultiChannelRendererSinkInner::SetPaPower(int32_t flag)
1155 {
1156 (void)flag;
1157 return ERR_NOT_SUPPORTED;
1158 }
1159
SetPriPaPower()1160 int32_t MultiChannelRendererSinkInner::SetPriPaPower()
1161 {
1162 return ERR_NOT_SUPPORTED;
1163 }
1164
UpdateAppsUid(const int32_t appsUid[MAX_MIX_CHANNELS],const size_t size)1165 int32_t MultiChannelRendererSinkInner::UpdateAppsUid(const int32_t appsUid[MAX_MIX_CHANNELS], const size_t size)
1166 {
1167 #ifdef FEATURE_POWER_MANAGER
1168 if (!runningLockManager_) {
1169 return ERROR;
1170 }
1171
1172 return runningLockManager_->UpdateAppsUid(appsUid, appsUid + size);
1173 #endif
1174
1175 return SUCCESS;
1176 }
1177
UpdateAppsUid(const std::vector<int32_t> & appsUid)1178 int32_t MultiChannelRendererSinkInner::UpdateAppsUid(const std::vector<int32_t> &appsUid)
1179 {
1180 AUDIO_WARNING_LOG("not supported.");
1181 return SUCCESS;
1182 }
1183 // LCOV_EXCL_STOP
1184 } // namespace AudioStandard
1185 } // namespace OHOS
1186