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