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