1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #ifndef LOG_TAG
16 #define LOG_TAG "OffloadAudioRendererSinkInner"
17 #endif
18
19 #include "offload_audio_renderer_sink.h"
20
21 #include <cstring>
22 #include <cinttypes>
23 #include <dlfcn.h>
24 #include <string>
25 #include <unistd.h>
26 #include <future>
27
28 #ifdef FEATURE_POWER_MANAGER
29 #include "power_mgr_client.h"
30 #include "running_lock.h"
31 #include "audio_running_lock_manager.h"
32 #endif
33 #include "v4_0/iaudio_manager.h"
34
35 #include "audio_errors.h"
36 #include "audio_hdi_log.h"
37 #include "audio_utils.h"
38 #include "audio_log_utils.h"
39 #include "media_monitor_manager.h"
40
41 using namespace std;
42
43 namespace OHOS {
44 namespace AudioStandard {
45 namespace {
46 const int32_t HALF_FACTOR = 2;
47 const int32_t MAX_AUDIO_ADAPTER_NUM = 5;
48 const float DEFAULT_VOLUME_LEVEL = 1.0f;
49 const uint32_t AUDIO_CHANNELCOUNT = 2;
50 const uint32_t AUDIO_SAMPLE_RATE_48K = 48000;
51 const uint32_t DEEP_BUFFER_RENDER_PERIOD_SIZE = 4096;
52 const uint32_t INT_32_MAX = 0x7fffffff;
53 const uint32_t PCM_8_BIT = 8;
54 const uint32_t PCM_16_BIT = 16;
55 const uint32_t PCM_24_BIT = 24;
56 const uint32_t PCM_32_BIT = 32;
57 const uint32_t STEREO_CHANNEL_COUNT = 2;
58 #ifdef FEATURE_POWER_MANAGER
59 constexpr int32_t RUNNINGLOCK_LOCK_TIMEOUTMS_LASTING = -1;
60 #endif
61 const uint64_t SECOND_TO_NANOSECOND = 1000000000;
62 const uint64_t SECOND_TO_MICROSECOND = 1000000;
63 const uint64_t SECOND_TO_MILLISECOND = 1000;
64 const uint64_t MICROSECOND_TO_MILLISECOND = 1000;
65 const uint32_t BIT_IN_BYTE = 8;
66 const uint16_t GET_MAX_AMPLITUDE_FRAMES_THRESHOLD = 10;
67 const unsigned int TIME_OUT_SECONDS = 10;
68 const std::string LOG_UTILS_TAG = "Offload";
69 constexpr size_t OFFLOAD_DFX_SPLIT = 2;
70 }
71
72 struct AudioCallbackService {
73 struct IAudioCallback interface;
74 void *cookie;
75 OnRenderCallback* renderCallback;
76 void *userdata;
77 bool registered = false;
78 };
79
80 class OffloadAudioRendererSinkInner : public OffloadRendererSink {
81 public:
82 int32_t Init(const IAudioSinkAttr& attr) override;
83 bool IsInited(void) override;
84 void DeInit(void) override;
85
86 int32_t Flush(void) override;
87 int32_t Pause(void) override;
88 int32_t Reset(void) override;
89 int32_t Resume(void) override;
90 int32_t Start(void) override;
91 int32_t Stop(void) override;
92 int32_t SuspendRenderSink(void) override;
93 int32_t RestoreRenderSink(void) override;
94 int32_t Drain(AudioDrainType type) override;
95 int32_t SetBufferSize(uint32_t sizeMs) override;
96
97 int32_t OffloadRunningLockInit(void) override;
98 int32_t OffloadRunningLockLock(void) override;
99 int32_t OffloadRunningLockUnlock(void) override;
100
101 int32_t RenderFrame(char &data, uint64_t len, uint64_t &writeLen) override;
102 int32_t SetVolume(float left, float right) override;
103 int32_t GetVolume(float &left, float &right) override;
104 int32_t SetVolumeInner(float &left, float &right);
105 int32_t SetVoiceVolume(float volume) override;
106 int32_t GetLatency(uint32_t *latency) override;
107 int32_t GetTransactionId(uint64_t *transactionId) override;
108 int32_t SetAudioScene(AudioScene audioScene, std::vector<DeviceType> &activeDevices) override;
109
110 void SetAudioParameter(const AudioParamKey key, const std::string& condition, const std::string& value) override;
111 std::string GetAudioParameter(const AudioParamKey key, const std::string& condition) override;
112 void RegisterParameterCallback(IAudioSinkCallback* callback) override;
113 int32_t RegisterRenderCallback(OnRenderCallback (*callback), int8_t *userdata) override;
114 int32_t GetPresentationPosition(uint64_t& frames, int64_t& timeSec, int64_t& timeNanoSec) override;
115
116 static int32_t RenderEventCallback(struct IAudioCallback *self, RenderCallbackType type, int8_t *reserved,
117 int8_t *cookie);
118
119 void SetAudioMonoState(bool audioMono) override;
120 void SetAudioBalanceValue(float audioBalance) override;
121 int32_t SetOutputRoutes(std::vector<DeviceType> &outputDevices) override;
122 void ResetOutputRouteForDisconnect(DeviceType device) override;
123 float GetMaxAmplitude() override;
124 int32_t SetPaPower(int32_t flag) override;
125 int32_t SetPriPaPower() override;
126
127 int32_t UpdateAppsUid(const int32_t appsUid[MAX_MIX_CHANNELS], const size_t size) final;
128 int32_t UpdateAppsUid(const std::vector<int32_t> &appsUid) final;
129 int32_t SetSinkMuteForSwitchDevice(bool mute) final;
130
131 OffloadAudioRendererSinkInner();
132 ~OffloadAudioRendererSinkInner();
133 private:
134 IAudioSinkAttr attr_ = {};
135 bool rendererInited_ = false;
136 bool started_ = false;
137 bool isFlushing_ = false;
138 bool startDuringFlush_ = false;
139 uint64_t renderPos_ = 0;
140 float leftVolume_ = 0.0f;
141 float rightVolume_ = 0.0f;
142 std::mutex volumeMutex_;
143 int32_t muteCount_ = 0;
144 bool switchDeviceMute_ = false;
145 uint32_t renderId_ = 0;
146 std::string adapterNameCase_ = "";
147 struct IAudioManager *audioManager_ = nullptr;
148 struct IAudioAdapter *audioAdapter_ = nullptr;
149 struct IAudioRender *audioRender_ = nullptr;
150 struct AudioAdapterDescriptor adapterDesc_ = {};
151 struct AudioPort audioPort_ = {};
152 struct AudioCallbackService callbackServ = {};
153 bool audioMonoState_ = false;
154 bool audioBalanceState_ = false;
155 float leftBalanceCoef_ = 1.0f;
156 float rightBalanceCoef_ = 1.0f;
157 bool signalDetected_ = false;
158 size_t detectedTime_ = 0;
159 bool latencyMeasEnabled_ = false;
160 std::shared_ptr<SignalDetectAgent> signalDetectAgent_ = nullptr;
161 // for get amplitude
162 float maxAmplitude_ = 0;
163 int64_t lastGetMaxAmplitudeTime_ = 0;
164 int64_t last10FrameStartTime_ = 0;
165 bool startUpdate_ = false;
166 int renderFrameNum_ = 0;
167 std::mutex renderMutex_;
168
169 int32_t CreateRender(const struct AudioPort &renderPort);
170 int32_t InitAudioManager();
171 AudioFormat ConverToHdiFormat(HdiAdapterFormat format);
172 void AdjustStereoToMono(char *data, uint64_t len);
173 void AdjustAudioBalance(char *data, uint64_t len);
174 void InitLatencyMeasurement();
175 void DeinitLatencyMeasurement();
176 void CheckLatencySignal(uint8_t *data, size_t len);
177 void CheckUpdateState(char *frame, uint64_t replyBytes);
178 void DfxOperation(BufferDesc &buffer, AudioSampleFormat format, AudioChannel channel) const;
179
180 #ifdef FEATURE_POWER_MANAGER
181 std::shared_ptr<AudioRunningLockManager<PowerMgr::RunningLock>> offloadRunningLockManager_;
182 bool runninglocked;
183 #endif
184
185 FILE *dumpFile_ = nullptr;
186 std::string dumpFileName_ = "";
187 mutable int64_t volumeDataCount_ = 0;
188 };
189
OffloadAudioRendererSinkInner()190 OffloadAudioRendererSinkInner::OffloadAudioRendererSinkInner()
191 : rendererInited_(false), started_(false), isFlushing_(false), startDuringFlush_(false), renderPos_(0),
192 leftVolume_(DEFAULT_VOLUME_LEVEL), rightVolume_(DEFAULT_VOLUME_LEVEL),
193 audioManager_(nullptr), audioAdapter_(nullptr), audioRender_(nullptr)
194 {
195 #ifdef FEATURE_POWER_MANAGER
196 runninglocked = false;
197 #endif
198 }
199
~OffloadAudioRendererSinkInner()200 OffloadAudioRendererSinkInner::~OffloadAudioRendererSinkInner()
201 {
202 AUDIO_DEBUG_LOG("~OffloadAudioRendererSinkInner");
203 AUDIO_INFO_LOG("[Offload] volume data counts: %{public}" PRId64, volumeDataCount_);
204 }
205
GetInstance()206 OffloadRendererSink *OffloadRendererSink::GetInstance()
207 {
208 static OffloadAudioRendererSinkInner audioRenderer;
209
210 return &audioRenderer;
211 }
212
213 // LCOV_EXCL_START
SetSinkMuteForSwitchDevice(bool mute)214 int32_t OffloadAudioRendererSinkInner::SetSinkMuteForSwitchDevice(bool mute)
215 {
216 std::lock_guard<std::mutex> lock(volumeMutex_);
217 AUDIO_INFO_LOG("set offload mute %{public}d", mute);
218
219 if (mute) {
220 muteCount_++;
221 if (switchDeviceMute_) {
222 AUDIO_INFO_LOG("offload already muted");
223 return SUCCESS;
224 }
225 switchDeviceMute_ = true;
226 float left = 0.0f;
227 float right = 0.0f;
228 SetVolumeInner(left, right);
229 } else {
230 muteCount_--;
231 if (muteCount_ > 0) {
232 AUDIO_WARNING_LOG("offload not all unmuted");
233 return SUCCESS;
234 }
235 switchDeviceMute_ = false;
236 muteCount_ = 0;
237 SetVolumeInner(leftVolume_, rightVolume_);
238 }
239
240 return SUCCESS;
241 }
242
SetAudioParameter(const AudioParamKey key,const std::string & condition,const std::string & value)243 void OffloadAudioRendererSinkInner::SetAudioParameter(const AudioParamKey key, const std::string& condition,
244 const std::string& value)
245 {
246 AUDIO_INFO_LOG("key %{public}d, condition: %{public}s, value: %{public}s", key,
247 condition.c_str(), value.c_str());
248 AudioExtParamKey hdiKey = AudioExtParamKey(key);
249 CHECK_AND_RETURN_LOG(audioAdapter_ != nullptr, "SetAudioParameter failed, audioAdapter_ is null");
250 int32_t ret = audioAdapter_->SetExtraParams(audioAdapter_, hdiKey, condition.c_str(), value.c_str());
251 if (ret != SUCCESS) {
252 AUDIO_ERR_LOG("SetAudioParameter failed, error code: %{public}d", ret);
253 }
254 }
255
GetAudioParameter(const AudioParamKey key,const std::string & condition)256 std::string OffloadAudioRendererSinkInner::GetAudioParameter(const AudioParamKey key, const std::string& condition)
257 {
258 AUDIO_INFO_LOG("key %{public}d, condition: %{public}s", key,
259 condition.c_str());
260 AudioExtParamKey hdiKey = AudioExtParamKey(key);
261 char value[PARAM_VALUE_LENTH];
262 CHECK_AND_RETURN_RET_LOG(audioAdapter_ != nullptr, "", "GetAudioParameter failed, audioAdapter_ is null");
263 int32_t ret = audioAdapter_->GetExtraParams(audioAdapter_, hdiKey, condition.c_str(), value, PARAM_VALUE_LENTH);
264 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, "", "GetAudioParameter failed, error code: %{public}d", ret);
265 return value;
266 }
267
SetAudioMonoState(bool audioMono)268 void OffloadAudioRendererSinkInner::SetAudioMonoState(bool audioMono)
269 {
270 audioMonoState_ = audioMono;
271 }
272
SetAudioBalanceValue(float audioBalance)273 void OffloadAudioRendererSinkInner::SetAudioBalanceValue(float audioBalance)
274 {
275 // reset the balance coefficient value firstly
276 leftBalanceCoef_ = 1.0f;
277 rightBalanceCoef_ = 1.0f;
278
279 if (std::abs(audioBalance - 0.0f) <= std::numeric_limits<float>::epsilon()) {
280 // audioBalance is equal to 0.0f
281 audioBalanceState_ = false;
282 } else {
283 // audioBalance is not equal to 0.0f
284 audioBalanceState_ = true;
285 // calculate the balance coefficient
286 if (audioBalance > 0.0f) {
287 leftBalanceCoef_ -= audioBalance;
288 } else if (audioBalance < 0.0f) {
289 rightBalanceCoef_ += audioBalance;
290 }
291 }
292 }
293
AdjustStereoToMono(char * data,uint64_t len)294 void OffloadAudioRendererSinkInner::AdjustStereoToMono(char *data, uint64_t len)
295 {
296 // only stereo is surpported now (stereo channel count is 2)
297 CHECK_AND_RETURN_LOG(attr_.channel == STEREO_CHANNEL_COUNT, "Unspport channel number: %{public}d", attr_.channel);
298
299 switch (attr_.format) {
300 case SAMPLE_U8: {
301 // this function needs to be further tested for usability
302 AdjustStereoToMonoForPCM8Bit(reinterpret_cast<int8_t *>(data), len);
303 break;
304 }
305 case SAMPLE_S16LE: {
306 AdjustStereoToMonoForPCM16Bit(reinterpret_cast<int16_t *>(data), len);
307 break;
308 }
309 case SAMPLE_S24LE: {
310 // this function needs to be further tested for usability
311 AdjustStereoToMonoForPCM24Bit(reinterpret_cast<int8_t *>(data), len);
312 break;
313 }
314 case SAMPLE_S32LE: {
315 AdjustStereoToMonoForPCM32Bit(reinterpret_cast<int32_t *>(data), len);
316 break;
317 }
318 default: {
319 // if the audio format is unsupported, the audio data will not be changed
320 AUDIO_ERR_LOG("Unsupported audio format: %{public}d", attr_.format);
321 break;
322 }
323 }
324 }
325
AdjustAudioBalance(char * data,uint64_t len)326 void OffloadAudioRendererSinkInner::AdjustAudioBalance(char *data, uint64_t len)
327 {
328 // only stereo is surpported now (stereo channel count is 2)
329 CHECK_AND_RETURN_LOG(attr_.channel == STEREO_CHANNEL_COUNT, "Unspport channel number: %{public}d", attr_.channel);
330
331 switch (attr_.format) {
332 case SAMPLE_U8: {
333 // this function needs to be further tested for usability
334 AdjustAudioBalanceForPCM8Bit(reinterpret_cast<int8_t *>(data), len, leftBalanceCoef_, rightBalanceCoef_);
335 break;
336 }
337 case SAMPLE_S16LE: {
338 AdjustAudioBalanceForPCM16Bit(reinterpret_cast<int16_t *>(data), len, leftBalanceCoef_, rightBalanceCoef_);
339 break;
340 }
341 case SAMPLE_S24LE: {
342 // this function needs to be further tested for usability
343 AdjustAudioBalanceForPCM24Bit(reinterpret_cast<int8_t *>(data), len, leftBalanceCoef_, rightBalanceCoef_);
344 break;
345 }
346 case SAMPLE_S32LE: {
347 AdjustAudioBalanceForPCM32Bit(reinterpret_cast<int32_t *>(data), len, leftBalanceCoef_, rightBalanceCoef_);
348 break;
349 }
350 default: {
351 // if the audio format is unsupported, the audio data will not be changed
352 AUDIO_ERR_LOG("Unsupported audio format: %{public}d", attr_.format);
353 break;
354 }
355 }
356 }
357
IsInited()358 bool OffloadAudioRendererSinkInner::IsInited()
359 {
360 return rendererInited_;
361 }
362
RegisterParameterCallback(IAudioSinkCallback * callback)363 void OffloadAudioRendererSinkInner::RegisterParameterCallback(IAudioSinkCallback* callback)
364 {
365 AUDIO_WARNING_LOG("not supported.");
366 }
367
368 typedef int32_t (*RenderCallback)(struct IAudioCallback *self, enum AudioCallbackType type, int8_t* reserved,
369 int8_t* cookie);
370
RegisterRenderCallback(OnRenderCallback (* callback),int8_t * userdata)371 int32_t OffloadAudioRendererSinkInner::RegisterRenderCallback(OnRenderCallback (*callback), int8_t *userdata)
372 {
373 callbackServ.renderCallback = callback;
374 callbackServ.userdata = userdata;
375 if (callbackServ.registered) {
376 AUDIO_DEBUG_LOG("update callback");
377 return SUCCESS;
378 }
379 // register to adapter
380 auto renderCallback = (RenderCallback) &OffloadAudioRendererSinkInner::RenderEventCallback;
381 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE, "audioRender_ is null");
382 callbackServ.interface.RenderCallback = renderCallback;
383 callbackServ.cookie = this;
384 int32_t ret = audioRender_->RegCallback(audioRender_, &callbackServ.interface, (int8_t)0);
385 if (ret != SUCCESS) {
386 AUDIO_WARNING_LOG("failed, error code: %{public}d", ret);
387 } else {
388 callbackServ.registered = true;
389 }
390 return SUCCESS;
391 }
392
RenderEventCallback(struct IAudioCallback * self,RenderCallbackType type,int8_t * reserved,int8_t * cookie)393 int32_t OffloadAudioRendererSinkInner::RenderEventCallback(struct IAudioCallback* self, RenderCallbackType type,
394 int8_t* reserved, int8_t* cookie)
395 {
396 // reserved and cookie should be null
397 if (self == nullptr) {
398 AUDIO_WARNING_LOG("self is null!");
399 }
400 auto *impl = reinterpret_cast<struct AudioCallbackService *>(self);
401 CHECK_AND_RETURN_RET_LOG(impl != nullptr, ERROR, "The impl is null");
402 if (!impl->registered || impl->cookie == nullptr || impl->renderCallback == nullptr) {
403 AUDIO_ERR_LOG("impl invalid, %{public}d, %{public}d, %{public}d",
404 impl->registered, impl->cookie == nullptr, impl->renderCallback == nullptr);
405 }
406 CHECK_AND_RETURN_RET_LOG(impl->cookie != nullptr, ERROR, "The impl->cookie is null");
407 auto *sink = reinterpret_cast<OffloadAudioRendererSinkInner *>(impl->cookie);
408 if (!sink->started_ || sink->isFlushing_) {
409 AUDIO_DEBUG_LOG("invalid renderCallback call, started_ %d, isFlushing_ %d", sink->started_, sink->isFlushing_);
410 return 0;
411 }
412
413 auto cbType = RenderCallbackType(type);
414 impl->renderCallback(cbType, reinterpret_cast<int8_t*>(impl->userdata));
415 return 0;
416 }
417
GetPresentationPosition(uint64_t & frames,int64_t & timeSec,int64_t & timeNanoSec)418 int32_t OffloadAudioRendererSinkInner::GetPresentationPosition(uint64_t& frames, int64_t& timeSec, int64_t& timeNanoSec)
419 {
420 Trace trace("OffloadSink::GetPresentationPosition");
421 CHECK_AND_RETURN_RET_LOG(!isFlushing_, ERR_OPERATION_FAILED, "failed! during flushing");
422 int32_t ret;
423 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE, "failed audioRender_ is NULL");
424 uint64_t frames_;
425 struct AudioTimeStamp timestamp = {};
426 ret = audioRender_->GetRenderPosition(audioRender_, &frames_, ×tamp);
427 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "offload failed");
428 int64_t maxSec = 9223372036; // (9223372036 + 1) * 10^9 > INT64_MAX, seconds should not bigger than it;
429 CHECK_AND_RETURN_RET_LOG(timestamp.tvSec >= 0 && timestamp.tvSec <= maxSec && timestamp.tvNSec >= 0 &&
430 timestamp.tvNSec <= SECOND_TO_NANOSECOND, ERR_OPERATION_FAILED,
431 "Hdi GetRenderPosition get invaild second:%{public}" PRIu64 " or nanosecond:%{public}" PRIu64 " !",
432 timestamp.tvSec, timestamp.tvNSec);
433 frames = frames_ * SECOND_TO_MICROSECOND / attr_.sampleRate;
434 timeSec = timestamp.tvSec;
435 timeNanoSec = timestamp.tvNSec;
436 // check hdi timestamp out of range 40 * 1000 * 1000 ns
437 struct timespec time;
438 clockid_t clockId = CLOCK_MONOTONIC;
439 if (clock_gettime(clockId, &time) >= 0) {
440 int64_t curNs = time.tv_sec * AUDIO_NS_PER_SECOND + time.tv_nsec;
441 int64_t hdiNs = timestamp.tvSec * AUDIO_NS_PER_SECOND + timestamp.tvNSec;
442 int64_t outNs = 40 * 1000 * 1000; // 40 * 1000 * 1000 ns
443 if (curNs <= hdiNs || curNs > hdiNs + outNs) {
444 AUDIO_PRERELEASE_LOGW("HDI time is not in the range, timestamp: %{public}" PRId64
445 ", now: %{public}" PRId64, hdiNs, curNs);
446 timeSec = time.tv_sec;
447 timeNanoSec = time.tv_nsec;
448 }
449 }
450 return ret;
451 }
452
DeInit()453 void OffloadAudioRendererSinkInner::DeInit()
454 {
455 Trace trace("OffloadSink::DeInit");
456 std::lock_guard<std::mutex> lock(renderMutex_);
457 std::lock_guard<std::mutex> lockVolume(volumeMutex_);
458 AUDIO_INFO_LOG("DeInit.");
459 started_ = false;
460 rendererInited_ = false;
461 if (audioAdapter_ != nullptr) {
462 AUDIO_INFO_LOG("DestroyRender rendererid: %{public}u", renderId_);
463 audioAdapter_->DestroyRender(audioAdapter_, renderId_);
464 }
465 audioRender_ = nullptr;
466 audioManager_ = nullptr;
467 callbackServ = {};
468 muteCount_ = 0;
469 switchDeviceMute_ = false;
470
471 DumpFileUtil::CloseDumpFile(&dumpFile_);
472 }
473
InitAttrs(struct AudioSampleAttributes & attrs)474 void InitAttrs(struct AudioSampleAttributes &attrs)
475 {
476 /* Initialization of audio parameters for playback*/
477 attrs.channelCount = AUDIO_CHANNELCOUNT;
478 attrs.sampleRate = AUDIO_SAMPLE_RATE_48K;
479 attrs.interleaved = true;
480 attrs.streamId = static_cast<int32_t>(GenerateUniqueID(AUDIO_HDI_RENDER_ID_BASE, HDI_RENDER_OFFSET_OFFLOAD));
481 attrs.type = AUDIO_OFFLOAD;
482 attrs.period = DEEP_BUFFER_RENDER_PERIOD_SIZE;
483 attrs.isBigEndian = false;
484 attrs.isSignedData = true;
485 attrs.stopThreshold = INT_32_MAX;
486 attrs.silenceThreshold = 0;
487 // AudioOffloadInfo attr
488 attrs.offloadInfo.sampleRate = AUDIO_SAMPLE_RATE_48K;
489 attrs.offloadInfo.channelCount = AUDIO_CHANNELCOUNT;
490 attrs.offloadInfo.bitRate = AUDIO_SAMPLE_RATE_48K * BIT_IN_BYTE;
491 attrs.offloadInfo.bitWidth = PCM_32_BIT;
492 }
493
SwitchAdapterRender(struct AudioAdapterDescriptor * descs,const string & adapterNameCase,enum AudioPortDirection portFlag,struct AudioPort & renderPort,uint32_t size)494 static int32_t SwitchAdapterRender(struct AudioAdapterDescriptor *descs, const string &adapterNameCase,
495 enum AudioPortDirection portFlag, struct AudioPort &renderPort, uint32_t size)
496 {
497 if (descs == nullptr) {
498 return ERROR;
499 }
500 for (uint32_t index = 0; index < size; index++) {
501 struct AudioAdapterDescriptor *desc = &descs[index];
502 if (desc == nullptr || desc->adapterName == nullptr) {
503 continue;
504 }
505 AUDIO_DEBUG_LOG("index %{public}u, adapterName %{public}s", index, desc->adapterName);
506 if (strcmp(desc->adapterName, adapterNameCase.c_str())) {
507 continue;
508 }
509 for (uint32_t port = 0; port < desc->portsLen; port++) {
510 // Only find out the port of out in the sound card
511 if (desc->ports[port].dir == portFlag) {
512 renderPort = desc->ports[port];
513 return index;
514 }
515 }
516 }
517 AUDIO_ERR_LOG("switch adapter render fail");
518 return ERR_INVALID_INDEX;
519 }
520
InitAudioManager()521 int32_t OffloadAudioRendererSinkInner::InitAudioManager()
522 {
523 audioManager_ = IAudioManagerGet(false);
524 CHECK_AND_RETURN_RET(audioManager_ != nullptr, ERR_INVALID_HANDLE);
525 return 0;
526 }
527
PcmFormatToBits(enum AudioFormat format)528 uint32_t PcmFormatToBits(enum AudioFormat format)
529 {
530 switch (format) {
531 case AUDIO_FORMAT_TYPE_PCM_8_BIT:
532 return PCM_8_BIT;
533 case AUDIO_FORMAT_TYPE_PCM_16_BIT:
534 return PCM_16_BIT;
535 case AUDIO_FORMAT_TYPE_PCM_24_BIT:
536 return PCM_24_BIT;
537 case AUDIO_FORMAT_TYPE_PCM_32_BIT:
538 return PCM_32_BIT;
539 default:
540 AUDIO_DEBUG_LOG("Unkown format type, set it to defalut");
541 return PCM_24_BIT;
542 }
543 }
544
ConverToHdiFormat(HdiAdapterFormat format)545 AudioFormat OffloadAudioRendererSinkInner::ConverToHdiFormat(HdiAdapterFormat format)
546 {
547 AudioFormat hdiFormat;
548 switch (format) {
549 case SAMPLE_U8:
550 hdiFormat = AUDIO_FORMAT_TYPE_PCM_8_BIT;
551 break;
552 case SAMPLE_S16:
553 hdiFormat = AUDIO_FORMAT_TYPE_PCM_16_BIT;
554 break;
555 case SAMPLE_S24:
556 hdiFormat = AUDIO_FORMAT_TYPE_PCM_24_BIT;
557 break;
558 case SAMPLE_S32:
559 hdiFormat = AUDIO_FORMAT_TYPE_PCM_32_BIT;
560 break;
561 case SAMPLE_F32:
562 hdiFormat = AUDIO_FORMAT_TYPE_PCM_FLOAT;
563 break;
564 default:
565 hdiFormat = AUDIO_FORMAT_TYPE_PCM_16_BIT;
566 break;
567 }
568
569 return hdiFormat;
570 }
571
CreateRender(const struct AudioPort & renderPort)572 int32_t OffloadAudioRendererSinkInner::CreateRender(const struct AudioPort &renderPort)
573 {
574 Trace trace("OffloadSink::CreateRender");
575 int32_t ret;
576 struct AudioSampleAttributes param;
577 struct AudioDeviceDescriptor deviceDesc;
578 InitAttrs(param);
579 param.sampleRate = attr_.sampleRate;
580 param.channelCount = attr_.channel;
581 if (param.channelCount == MONO) {
582 param.channelLayout = CH_LAYOUT_MONO;
583 } else if (param.channelCount == STEREO) {
584 param.channelLayout = CH_LAYOUT_STEREO;
585 }
586 param.format = ConverToHdiFormat(attr_.format);
587 param.offloadInfo.format = ConverToHdiFormat(attr_.format);
588 param.frameSize = PcmFormatToBits(param.format) * param.channelCount / PCM_8_BIT;
589 param.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (param.frameSize);
590
591 deviceDesc.portId = renderPort.portId;
592 deviceDesc.desc = const_cast<char *>("");
593 deviceDesc.pins = PIN_OUT_SPEAKER;
594 AudioXCollie audioXCollie("audioAdapter_->CreateRender", TIME_OUT_SECONDS);
595
596 AUDIO_INFO_LOG("Create offload render format: %{public}d, sampleRate:%{public}u channel%{public}u",
597 param.format, param.sampleRate, param.channelCount);
598 ret = audioAdapter_->CreateRender(audioAdapter_, &deviceDesc, ¶m, &audioRender_, &renderId_);
599 if (ret != 0 || audioRender_ == nullptr) {
600 AUDIO_ERR_LOG("not started failed.");
601 audioManager_->UnloadAdapter(audioManager_, adapterDesc_.adapterName);
602 return ERR_NOT_STARTED;
603 }
604 AUDIO_INFO_LOG("Create success rendererid: %{public}u", renderId_);
605
606 return 0;
607 }
608
Init(const IAudioSinkAttr & attr)609 int32_t OffloadAudioRendererSinkInner::Init(const IAudioSinkAttr &attr)
610 {
611 Trace trace("OffloadSink::Init");
612 attr_ = attr;
613 adapterNameCase_ = attr_.adapterName; // Set sound card information
614 enum AudioPortDirection port = PORT_OUT; // Set port information
615
616 CHECK_AND_RETURN_RET_LOG(InitAudioManager() == 0, ERR_NOT_STARTED, "Init audio manager Fail.");
617
618 uint32_t size = MAX_AUDIO_ADAPTER_NUM;
619 int32_t ret;
620 AudioAdapterDescriptor descs[MAX_AUDIO_ADAPTER_NUM];
621 if (audioManager_ == nullptr) {
622 AUDIO_ERR_LOG("The audioManager is null!");
623 return ERROR;
624 }
625 ret = audioManager_->GetAllAdapters(audioManager_, (struct AudioAdapterDescriptor *)&descs, &size);
626 CHECK_AND_RETURN_RET_LOG(size <= MAX_AUDIO_ADAPTER_NUM && size != 0 && ret == 0, ERR_NOT_STARTED,
627 "Get adapters Fail.");
628
629 // Get qualified sound card and port
630 int32_t index =
631 SwitchAdapterRender((struct AudioAdapterDescriptor *)&descs, adapterNameCase_, port, audioPort_, size);
632 CHECK_AND_RETURN_RET_LOG(index >= 0, ERR_NOT_STARTED, "Switch Adapter Fail.");
633
634 adapterDesc_ = descs[index];
635 ret = audioManager_->LoadAdapter(audioManager_, &adapterDesc_, &audioAdapter_);
636 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_NOT_STARTED, "Load Adapter Fail.");
637
638 CHECK_AND_RETURN_RET_LOG(audioAdapter_ != nullptr, ERR_NOT_STARTED, "Load audio device failed.");
639
640 // Initialization port information, can fill through mode and other parameters
641 int32_t result = audioAdapter_->InitAllPorts(audioAdapter_);
642 CHECK_AND_RETURN_RET_LOG(result == 0, ERR_NOT_STARTED, "InitAllPorts failed.");
643
644 int32_t tmp = CreateRender(audioPort_);
645 CHECK_AND_RETURN_RET_LOG(tmp == 0, ERR_NOT_STARTED,
646 "Create render failed, Audio Port: %{public}d", audioPort_.portId);
647 rendererInited_ = true;
648
649 return SUCCESS;
650 }
651
RenderFrame(char & data,uint64_t len,uint64_t & writeLen)652 int32_t OffloadAudioRendererSinkInner::RenderFrame(char &data, uint64_t len, uint64_t &writeLen)
653 {
654 int64_t stamp = ClockTime::GetCurNano();
655
656 CHECK_AND_RETURN_RET_LOG(!isFlushing_, ERR_OPERATION_FAILED, "failed! during flushing");
657 CHECK_AND_RETURN_RET_LOG(started_, ERR_OPERATION_FAILED, "failed! state not in started");
658 int32_t ret;
659 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE, "Audio Render Handle is nullptr!");
660
661 if (audioMonoState_) {
662 AdjustStereoToMono(&data, len);
663 }
664
665 if (audioBalanceState_) {
666 AdjustAudioBalance(&data, len);
667 }
668
669 Trace::CountVolume("OffloadAudioRendererSinkInner::RenderFrame", static_cast<uint8_t>(data));
670 Trace trace("OffloadSink::RenderFrame");
671 CheckLatencySignal(reinterpret_cast<uint8_t*>(&data), len);
672 ret = audioRender_->RenderFrame(audioRender_, reinterpret_cast<int8_t*>(&data), static_cast<uint32_t>(len),
673 &writeLen);
674 if (ret == 0 && writeLen != 0) {
675 DumpFileUtil::WriteDumpFile(dumpFile_, static_cast<void *>(&data), writeLen);
676 BufferDesc buffer = {reinterpret_cast<uint8_t *>(&data), len, len};
677 DfxOperation(buffer, static_cast<AudioSampleFormat>(attr_.format), static_cast<AudioChannel>(attr_.channel));
678 if (AudioDump::GetInstance().GetVersionType() == BETA_VERSION) {
679 Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteAudioBuffer(dumpFileName_,
680 static_cast<void *>(&data), writeLen);
681 }
682 CheckUpdateState(&data, len);
683 }
684
685 #ifdef FEATURE_POWER_MANAGER
686 offloadRunningLockManager_->UpdateAppsUidToPowerMgr();
687 #endif
688
689 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_WRITE_FAILED, "RenderFrameOffload failed! ret: %{public}x", ret);
690 renderPos_ += writeLen;
691
692 stamp = (ClockTime::GetCurNano() - stamp) / AUDIO_US_PER_SECOND;
693 int64_t stampThreshold = 50; // 50ms
694 if (stamp >= stampThreshold) {
695 AUDIO_WARNING_LOG("RenderFrame len[%{public}" PRIu64 "] cost[%{public}" PRId64 "]ms", len, stamp);
696 }
697 return SUCCESS;
698 }
699
DfxOperation(BufferDesc & buffer,AudioSampleFormat format,AudioChannel channel) const700 void OffloadAudioRendererSinkInner::DfxOperation(BufferDesc &buffer, AudioSampleFormat format,
701 AudioChannel channel) const
702 {
703 ChannelVolumes vols = VolumeTools::CountVolumeLevel(buffer, format, channel, OFFLOAD_DFX_SPLIT);
704 if (channel == MONO) {
705 Trace::Count(LOG_UTILS_TAG, vols.volStart[0]);
706 } else {
707 Trace::Count(LOG_UTILS_TAG, (vols.volStart[0] + vols.volStart[1]) / HALF_FACTOR);
708 }
709 AudioLogUtils::ProcessVolumeData(LOG_UTILS_TAG, vols, volumeDataCount_);
710 }
711
CheckUpdateState(char * frame,uint64_t replyBytes)712 void OffloadAudioRendererSinkInner::CheckUpdateState(char *frame, uint64_t replyBytes)
713 {
714 if (startUpdate_) {
715 if (renderFrameNum_ == 0) {
716 last10FrameStartTime_ = ClockTime::GetCurNano();
717 }
718 renderFrameNum_++;
719 maxAmplitude_ = UpdateMaxAmplitude(static_cast<ConvertHdiFormat>(attr_.format), frame, replyBytes);
720 if (renderFrameNum_ == GET_MAX_AMPLITUDE_FRAMES_THRESHOLD) {
721 renderFrameNum_ = 0;
722 if (last10FrameStartTime_ > lastGetMaxAmplitudeTime_) {
723 startUpdate_ = false;
724 maxAmplitude_ = 0;
725 }
726 }
727 }
728 }
729
GetMaxAmplitude()730 float OffloadAudioRendererSinkInner::GetMaxAmplitude()
731 {
732 lastGetMaxAmplitudeTime_ = ClockTime::GetCurNano();
733 startUpdate_ = true;
734 return maxAmplitude_;
735 }
736
Start(void)737 int32_t OffloadAudioRendererSinkInner::Start(void)
738 {
739 Trace trace("OffloadSink::Start");
740 AUDIO_INFO_LOG("Start");
741 InitLatencyMeasurement();
742 if (started_) {
743 if (isFlushing_) {
744 AUDIO_ERR_LOG("start failed! during flushing");
745 startDuringFlush_ = true;
746 return ERR_OPERATION_FAILED;
747 } else {
748 AUDIO_WARNING_LOG("start duplicate!"); // when start while flushing, this will use
749 return SUCCESS;
750 }
751 }
752
753 AudioXCollie audioXCollie("audioRender_->Start", TIME_OUT_SECONDS);
754 int32_t ret = audioRender_->Start(audioRender_);
755 if (ret) {
756 AUDIO_ERR_LOG("Start failed! ret %d", ret);
757 return ERR_NOT_STARTED;
758 }
759
760 dumpFileName_ = "offload_audiosink_" + std::to_string(attr_.sampleRate) + "_"
761 + std::to_string(attr_.channel) + "_" + std::to_string(attr_.format) + ".pcm";
762 DumpFileUtil::OpenDumpFile(DUMP_SERVER_PARA, dumpFileName_, &dumpFile_);
763
764 started_ = true;
765 renderPos_ = 0;
766 return SUCCESS;
767 }
768
SetVolume(float left,float right)769 int32_t OffloadAudioRendererSinkInner::SetVolume(float left, float right)
770 {
771 std::lock_guard<std::mutex> lock(volumeMutex_);
772 Trace trace("OffloadSink::SetVolume");
773
774 leftVolume_ = left;
775 rightVolume_ = right;
776 if (switchDeviceMute_) {
777 AUDIO_WARNING_LOG("switch device muted, volume in store left:%{public}f, right:%{public}f", left, right);
778 return SUCCESS;
779 }
780
781 return SetVolumeInner(left, right);
782 }
783
SetVolumeInner(float & left,float & right)784 int32_t OffloadAudioRendererSinkInner::SetVolumeInner(float &left, float &right)
785 {
786 AUDIO_INFO_LOG("set offload vol left is %{public}f, right is %{public}f", left, right);
787 float thevolume;
788 int32_t ret;
789 if (audioRender_ == nullptr) {
790 AUDIO_PRERELEASE_LOGW("OffloadAudioRendererSinkInner::SetVolume failed, audioRender_ null, "
791 "this will happen when set volume on devices which offload not available");
792 return ERR_INVALID_HANDLE;
793 }
794
795 if ((left == 0) && (right != 0)) {
796 thevolume = right;
797 } else if ((left != 0) && (right == 0)) {
798 thevolume = left;
799 } else {
800 thevolume = (left + right) / HALF_FACTOR;
801 }
802
803 ret = audioRender_->SetVolume(audioRender_, thevolume);
804 if (ret) {
805 AUDIO_ERR_LOG("Set volume failed!");
806 }
807 return ret;
808 }
809
GetVolume(float & left,float & right)810 int32_t OffloadAudioRendererSinkInner::GetVolume(float &left, float &right)
811 {
812 std::lock_guard<std::mutex> lock(volumeMutex_);
813 left = leftVolume_;
814 right = rightVolume_;
815 return SUCCESS;
816 }
817
SetVoiceVolume(float volume)818 int32_t OffloadAudioRendererSinkInner::SetVoiceVolume(float volume)
819 {
820 CHECK_AND_RETURN_RET_LOG(audioAdapter_ != nullptr, ERR_INVALID_HANDLE,
821 "failed, audioAdapter_ is null");
822 AUDIO_DEBUG_LOG("Set void volume %{public}f", volume);
823 return audioAdapter_->SetVoiceVolume(audioAdapter_, volume);
824 }
825
GetLatency(uint32_t * latency)826 int32_t OffloadAudioRendererSinkInner::GetLatency(uint32_t *latency)
827 {
828 Trace trace("OffloadSink::GetLatency");
829 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE,
830 "GetLatency failed audio render null");
831
832 CHECK_AND_RETURN_RET_LOG(latency, ERR_INVALID_PARAM,
833 "GetLatency failed latency null");
834
835 // bytewidth is 4
836 uint64_t hdiLatency = renderPos_ * SECOND_TO_MICROSECOND / (AUDIO_SAMPLE_RATE_48K * 4 * STEREO_CHANNEL_COUNT);
837 uint64_t frames = 0;
838 int64_t timeSec = 0;
839 int64_t timeNanoSec = 0;
840 CHECK_AND_RETURN_RET_LOG(GetPresentationPosition(frames, timeSec, timeNanoSec) == SUCCESS, ERR_OPERATION_FAILED,
841 "get latency failed!");
842
843 *latency = hdiLatency > frames ? (hdiLatency - frames) / MICROSECOND_TO_MILLISECOND : 0;
844 return SUCCESS;
845 }
846
SetOutputRoutes(std::vector<DeviceType> & outputDevices)847 int32_t OffloadAudioRendererSinkInner::SetOutputRoutes(std::vector<DeviceType> &outputDevices)
848 {
849 AUDIO_DEBUG_LOG("SetOutputRoutes not supported.");
850 return ERR_NOT_SUPPORTED;
851 }
852
SetAudioScene(AudioScene audioScene,std::vector<DeviceType> & activeDevices)853 int32_t OffloadAudioRendererSinkInner::SetAudioScene(AudioScene audioScene, std::vector<DeviceType> &activeDevices)
854 {
855 AUDIO_WARNING_LOG("not supported.");
856 return ERR_NOT_SUPPORTED;
857 }
858
GetTransactionId(uint64_t * transactionId)859 int32_t OffloadAudioRendererSinkInner::GetTransactionId(uint64_t *transactionId)
860 {
861 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE,
862 " failed audio render null");
863
864 CHECK_AND_RETURN_RET_LOG(transactionId, ERR_INVALID_PARAM,
865 "failed transaction Id null");
866
867 *transactionId = reinterpret_cast<uint64_t>(audioRender_);
868 return SUCCESS;
869 }
870
Drain(AudioDrainType type)871 int32_t OffloadAudioRendererSinkInner::Drain(AudioDrainType type)
872 {
873 Trace trace("OffloadSink::Drain");
874 int32_t ret;
875 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE,
876 "failed audio render null");
877
878 ret = audioRender_->DrainBuffer(audioRender_, (AudioDrainNotifyType*)&type);
879 if (!ret) {
880 return SUCCESS;
881 } else {
882 AUDIO_ERR_LOG("DrainBuffer failed!");
883 return ERR_OPERATION_FAILED;
884 }
885
886 return SUCCESS;
887 }
888
Stop(void)889 int32_t OffloadAudioRendererSinkInner::Stop(void)
890 {
891 Trace trace("OffloadSink::Stop");
892 AUDIO_INFO_LOG("Stop");
893
894 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE,
895 "failed audio render null");
896
897 DeinitLatencyMeasurement();
898
899 if (started_) {
900 CHECK_AND_RETURN_RET_LOG(!Flush(), ERR_OPERATION_FAILED, "Flush failed!");
901 AudioXCollie audioXCollie("audioRender_->Stop", TIME_OUT_SECONDS);
902 int32_t ret = audioRender_->Stop(audioRender_);
903 if (!ret) {
904 started_ = false;
905 return SUCCESS;
906 } else {
907 AUDIO_ERR_LOG("Stop failed!");
908 return ERR_OPERATION_FAILED;
909 }
910 }
911 OffloadRunningLockUnlock();
912 AUDIO_WARNING_LOG("Stop duplicate");
913
914 return SUCCESS;
915 }
916
Pause(void)917 int32_t OffloadAudioRendererSinkInner::Pause(void)
918 {
919 AUDIO_ERR_LOG("Pause not use yet");
920 return ERR_NOT_SUPPORTED;
921 }
922
Resume(void)923 int32_t OffloadAudioRendererSinkInner::Resume(void)
924 {
925 AUDIO_ERR_LOG("Resume not use yet");
926 return ERR_NOT_SUPPORTED;
927 }
928
Reset(void)929 int32_t OffloadAudioRendererSinkInner::Reset(void)
930 {
931 Trace trace("OffloadSink::Reset");
932 if (started_ && audioRender_ != nullptr) {
933 startDuringFlush_ = true;
934 if (!Flush()) {
935 return SUCCESS;
936 } else {
937 startDuringFlush_ = false;
938 AUDIO_ERR_LOG("Reset failed!");
939 return ERR_OPERATION_FAILED;
940 }
941 }
942
943 return ERR_OPERATION_FAILED;
944 }
945
Flush(void)946 int32_t OffloadAudioRendererSinkInner::Flush(void)
947 {
948 Trace trace("OffloadSink::Flush");
949 CHECK_AND_RETURN_RET_LOG(!isFlushing_, ERR_OPERATION_FAILED,
950 "failed call flush during flushing");
951 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE,
952 "failed audio render null");
953 CHECK_AND_RETURN_RET_LOG(started_, ERR_INVALID_HANDLE,
954 "failed state is not started");
955 isFlushing_ = true;
956 thread([&] {
957 auto future = async(launch::async, [&] {
958 std::lock_guard<std::mutex> lock(renderMutex_);
959 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE,
960 "failed audio render null");
961 return audioRender_->Flush(audioRender_);
962 });
963 if (future.wait_for(250ms) == future_status::timeout) { // max wait 250ms
964 AUDIO_ERR_LOG("Flush failed! timeout of 250ms");
965 } else {
966 int32_t ret = future.get();
967 if (ret) {
968 AUDIO_ERR_LOG("Flush failed! ret %{public}d", ret);
969 }
970 }
971 isFlushing_ = false;
972 if (startDuringFlush_) {
973 startDuringFlush_ = false;
974 Start();
975 }
976 }).detach();
977 renderPos_ = 0;
978 return SUCCESS;
979 }
980
SuspendRenderSink(void)981 int32_t OffloadAudioRendererSinkInner::SuspendRenderSink(void)
982 {
983 return SUCCESS;
984 }
985
RestoreRenderSink(void)986 int32_t OffloadAudioRendererSinkInner::RestoreRenderSink(void)
987 {
988 return SUCCESS;
989 }
990
SetBufferSize(uint32_t sizeMs)991 int32_t OffloadAudioRendererSinkInner::SetBufferSize(uint32_t sizeMs)
992 {
993 Trace trace("OffloadSink::SetBufferSize");
994 CHECK_AND_RETURN_RET_LOG(!isFlushing_, ERR_OPERATION_FAILED, "failed! during flushing");
995 int32_t ret;
996 // bytewidth is 4
997 uint32_t size = (uint64_t) sizeMs * AUDIO_SAMPLE_RATE_48K * 4 * STEREO_CHANNEL_COUNT / SECOND_TO_MILLISECOND;
998 CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE,
999 "failed audio render null");
1000
1001 ret = audioRender_->SetBufferSize(audioRender_, size);
1002 CHECK_AND_RETURN_RET_LOG(!ret, ERR_OPERATION_FAILED,
1003 "SetBufferSize failed!");
1004
1005 return SUCCESS;
1006 }
1007
OffloadRunningLockInit(void)1008 int32_t OffloadAudioRendererSinkInner::OffloadRunningLockInit(void)
1009 {
1010 #ifdef FEATURE_POWER_MANAGER
1011 CHECK_AND_RETURN_RET_LOG(offloadRunningLockManager_ == nullptr, ERR_OPERATION_FAILED,
1012 "OffloadKeepRunningLock is not null, init failed!");
1013 std::shared_ptr<PowerMgr::RunningLock> keepRunningLock;
1014 keepRunningLock = PowerMgr::PowerMgrClient::GetInstance().CreateRunningLock("AudioOffloadBackgroudPlay",
1015 PowerMgr::RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO);
1016
1017 CHECK_AND_RETURN_RET_LOG(keepRunningLock != nullptr, ERR_OPERATION_FAILED, "keepRunningLock is nullptr");
1018 offloadRunningLockManager_ = std::make_shared<AudioRunningLockManager<PowerMgr::RunningLock>> (keepRunningLock);
1019
1020 #endif
1021 return SUCCESS;
1022 }
1023
OffloadRunningLockLock(void)1024 int32_t OffloadAudioRendererSinkInner::OffloadRunningLockLock(void)
1025 {
1026 #ifdef FEATURE_POWER_MANAGER
1027 AUDIO_INFO_LOG("keepRunningLock Lock");
1028 std::shared_ptr<PowerMgr::RunningLock> keepRunningLock;
1029 if (offloadRunningLockManager_ == nullptr) {
1030 keepRunningLock = PowerMgr::PowerMgrClient::GetInstance().CreateRunningLock("AudioOffloadBackgroudPlay",
1031 PowerMgr::RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO);
1032 if (keepRunningLock) {
1033 offloadRunningLockManager_ =
1034 std::make_shared<AudioRunningLockManager<PowerMgr::RunningLock>> (keepRunningLock);
1035 }
1036 }
1037 CHECK_AND_RETURN_RET_LOG(offloadRunningLockManager_ != nullptr, ERR_OPERATION_FAILED,
1038 "offloadRunningLockManager_ is null, playback can not work well!");
1039 CHECK_AND_RETURN_RET(!runninglocked, SUCCESS);
1040 runninglocked = true;
1041 offloadRunningLockManager_->Lock(RUNNINGLOCK_LOCK_TIMEOUTMS_LASTING); // -1 for lasting.
1042 #endif
1043
1044 return SUCCESS;
1045 }
1046
OffloadRunningLockUnlock(void)1047 int32_t OffloadAudioRendererSinkInner::OffloadRunningLockUnlock(void)
1048 {
1049 #ifdef FEATURE_POWER_MANAGER
1050 AUDIO_INFO_LOG("keepRunningLock UnLock");
1051 CHECK_AND_RETURN_RET_LOG(offloadRunningLockManager_ != nullptr, ERR_OPERATION_FAILED,
1052 "OffloadKeepRunningLock is null, playback can not work well!");
1053 CHECK_AND_RETURN_RET(runninglocked, SUCCESS);
1054 runninglocked = false;
1055 offloadRunningLockManager_->UnLock();
1056 #endif
1057
1058 return SUCCESS;
1059 }
1060
ResetOutputRouteForDisconnect(DeviceType device)1061 void OffloadAudioRendererSinkInner::ResetOutputRouteForDisconnect(DeviceType device)
1062 {
1063 AUDIO_WARNING_LOG("not supported.");
1064 }
1065
InitLatencyMeasurement()1066 void OffloadAudioRendererSinkInner::InitLatencyMeasurement()
1067 {
1068 if (!AudioLatencyMeasurement::CheckIfEnabled()) {
1069 return;
1070 }
1071 AUDIO_INFO_LOG("LatencyMeas OffloadRendererSinkInit");
1072 signalDetectAgent_ = std::make_shared<SignalDetectAgent>();
1073 CHECK_AND_RETURN_LOG(signalDetectAgent_ != nullptr, "LatencyMeas signalDetectAgent_ is nullptr");
1074 signalDetectAgent_->sampleFormat_ = attr_.format;
1075 signalDetectAgent_->formatByteSize_ = GetFormatByteSize(attr_.format);
1076 latencyMeasEnabled_ = true;
1077 signalDetected_ = false;
1078 }
1079
DeinitLatencyMeasurement()1080 void OffloadAudioRendererSinkInner::DeinitLatencyMeasurement()
1081 {
1082 signalDetectAgent_ = nullptr;
1083 latencyMeasEnabled_ = false;
1084 }
1085
CheckLatencySignal(uint8_t * data,size_t len)1086 void OffloadAudioRendererSinkInner::CheckLatencySignal(uint8_t *data, size_t len)
1087 {
1088 if (!latencyMeasEnabled_) {
1089 return;
1090 }
1091 CHECK_AND_RETURN_LOG(signalDetectAgent_ != nullptr, "LatencyMeas signalDetectAgent_ is nullptr");
1092 size_t byteSize = static_cast<size_t>(GetFormatByteSize(attr_.format));
1093 size_t newlyCheckedTime = len / (attr_.sampleRate / MILLISECOND_PER_SECOND) /
1094 (byteSize * sizeof(uint8_t) * attr_.channel);
1095 detectedTime_ += newlyCheckedTime;
1096 if (detectedTime_ >= MILLISECOND_PER_SECOND && signalDetectAgent_->signalDetected_ &&
1097 !signalDetectAgent_->dspTimestampGot_) {
1098 char value[GET_EXTRA_PARAM_LEN];
1099 AudioParamKey key = NONE;
1100 AudioExtParamKey hdiKey = AudioExtParamKey(key);
1101 std::string condition = "debug_audio_latency_measurement";
1102 int32_t ret = audioAdapter_->GetExtraParams(audioAdapter_, hdiKey,
1103 condition.c_str(), value, GET_EXTRA_PARAM_LEN);
1104 AUDIO_DEBUG_LOG("GetExtraParameter ret:%{public}d", ret);
1105 LatencyMonitor::GetInstance().UpdateDspTime(value);
1106 LatencyMonitor::GetInstance().UpdateSinkOrSourceTime(true,
1107 signalDetectAgent_->lastPeakBufferTime_);
1108 LatencyMonitor::GetInstance().ShowTimestamp(true);
1109 signalDetectAgent_->dspTimestampGot_ = true;
1110 signalDetectAgent_->signalDetected_ = false;
1111 }
1112 signalDetected_ = signalDetectAgent_->CheckAudioData(data, len);
1113 if (signalDetected_) {
1114 AUDIO_INFO_LOG("LatencyMeas offloadSink signal detected");
1115 detectedTime_ = 0;
1116 }
1117 }
1118
SetPaPower(int32_t flag)1119 int32_t OffloadAudioRendererSinkInner::SetPaPower(int32_t flag)
1120 {
1121 (void)flag;
1122 return ERR_NOT_SUPPORTED;
1123 }
1124
SetPriPaPower()1125 int32_t OffloadAudioRendererSinkInner::SetPriPaPower()
1126 {
1127 return ERR_NOT_SUPPORTED;
1128 }
1129
UpdateAppsUid(const int32_t appsUid[MAX_MIX_CHANNELS],const size_t size)1130 int32_t OffloadAudioRendererSinkInner::UpdateAppsUid(const int32_t appsUid[MAX_MIX_CHANNELS], const size_t size)
1131 {
1132 #ifdef FEATURE_POWER_MANAGER
1133 if (!offloadRunningLockManager_) {
1134 return ERROR;
1135 }
1136
1137 return offloadRunningLockManager_->UpdateAppsUid(appsUid, appsUid + size);
1138 #endif
1139
1140 return SUCCESS;
1141 }
1142
UpdateAppsUid(const std::vector<int32_t> & appsUid)1143 int32_t OffloadAudioRendererSinkInner::UpdateAppsUid(const std::vector<int32_t> &appsUid)
1144 {
1145 AUDIO_WARNING_LOG("not supported.");
1146 return SUCCESS;
1147 }
1148 // LCOV_EXCL_STOP
1149 } // namespace AudioStandard
1150 } // namespace OHOS
1151