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