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_, &timestamp);
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, &param, &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     float thevolume;
798     int32_t ret;
799     if (audioRender_ == nullptr) {
800         AUDIO_PRERELEASE_LOGW("OffloadAudioRendererSinkInner::SetVolume failed, audioRender_ null, "
801                           "this will happen when set volume on devices which offload not available");
802         return ERR_INVALID_HANDLE;
803     }
804 
805     if ((left == 0) && (right != 0)) {
806         thevolume = right;
807     } else if ((left != 0) && (right == 0)) {
808         thevolume = left;
809     } else {
810         thevolume = (left + right) / HALF_FACTOR;
811     }
812 
813     ret = audioRender_->SetVolume(audioRender_, thevolume);
814     if (ret) {
815         AUDIO_ERR_LOG("Set volume failed!");
816     }
817     return ret;
818 }
819 
GetVolume(float & left,float & right)820 int32_t OffloadAudioRendererSinkInner::GetVolume(float &left, float &right)
821 {
822     std::lock_guard<std::mutex> lock(volumeMutex_);
823     left = leftVolume_;
824     right = rightVolume_;
825     return SUCCESS;
826 }
827 
SetVoiceVolume(float volume)828 int32_t OffloadAudioRendererSinkInner::SetVoiceVolume(float volume)
829 {
830     CHECK_AND_RETURN_RET_LOG(audioAdapter_ != nullptr, ERR_INVALID_HANDLE,
831         "failed, audioAdapter_ is null");
832     AUDIO_DEBUG_LOG("Set void volume %{public}f", volume);
833     return audioAdapter_->SetVoiceVolume(audioAdapter_, volume);
834 }
835 
GetLatency(uint32_t * latency)836 int32_t OffloadAudioRendererSinkInner::GetLatency(uint32_t *latency)
837 {
838     Trace trace("OffloadSink::GetLatency");
839     CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE,
840         "GetLatency failed audio render null");
841 
842     CHECK_AND_RETURN_RET_LOG(latency, ERR_INVALID_PARAM,
843         "GetLatency failed latency null");
844 
845     // bytewidth is 4
846     uint64_t hdiLatency = renderPos_ * SECOND_TO_MICROSECOND / (AUDIO_SAMPLE_RATE_48K * 4 * STEREO_CHANNEL_COUNT);
847     uint64_t frames = 0;
848     int64_t timeSec = 0;
849     int64_t timeNanoSec = 0;
850     CHECK_AND_RETURN_RET_LOG(GetPresentationPosition(frames, timeSec, timeNanoSec) == SUCCESS, ERR_OPERATION_FAILED,
851         "get latency failed!");
852 
853     *latency = hdiLatency > frames ? (hdiLatency - frames) / MICROSECOND_TO_MILLISECOND : 0;
854     return SUCCESS;
855 }
856 
SetOutputRoutes(std::vector<DeviceType> & outputDevices)857 int32_t OffloadAudioRendererSinkInner::SetOutputRoutes(std::vector<DeviceType> &outputDevices)
858 {
859     AUDIO_DEBUG_LOG("SetOutputRoutes not supported.");
860     return ERR_NOT_SUPPORTED;
861 }
862 
SetAudioScene(AudioScene audioScene,std::vector<DeviceType> & activeDevices)863 int32_t OffloadAudioRendererSinkInner::SetAudioScene(AudioScene audioScene, std::vector<DeviceType> &activeDevices)
864 {
865     AUDIO_WARNING_LOG("not supported.");
866     return ERR_NOT_SUPPORTED;
867 }
868 
GetTransactionId(uint64_t * transactionId)869 int32_t OffloadAudioRendererSinkInner::GetTransactionId(uint64_t *transactionId)
870 {
871     CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE,
872         " failed audio render null");
873 
874     CHECK_AND_RETURN_RET_LOG(transactionId, ERR_INVALID_PARAM,
875         "failed transaction Id null");
876 
877     *transactionId = reinterpret_cast<uint64_t>(audioRender_);
878     return SUCCESS;
879 }
880 
Drain(AudioDrainType type)881 int32_t OffloadAudioRendererSinkInner::Drain(AudioDrainType type)
882 {
883     Trace trace("OffloadSink::Drain");
884     int32_t ret;
885     CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE,
886         "failed audio render null");
887 
888     ret = audioRender_->DrainBuffer(audioRender_, (AudioDrainNotifyType*)&type);
889     if (!ret) {
890         return SUCCESS;
891     } else {
892         AUDIO_ERR_LOG("DrainBuffer failed!");
893         return ERR_OPERATION_FAILED;
894     }
895 
896     return SUCCESS;
897 }
898 
Stop(void)899 int32_t OffloadAudioRendererSinkInner::Stop(void)
900 {
901     Trace trace("OffloadSink::Stop");
902     AUDIO_INFO_LOG("Stop");
903 
904     CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE,
905         "failed audio render null");
906 
907     DeinitLatencyMeasurement();
908 
909     if (started_) {
910         CHECK_AND_RETURN_RET_LOG(!Flush(), ERR_OPERATION_FAILED, "Flush failed!");
911         AudioXCollie audioXCollie("audioRender_->Stop", TIME_OUT_SECONDS);
912         int32_t ret = audioRender_->Stop(audioRender_);
913         if (!ret) {
914             started_ = false;
915             return SUCCESS;
916         } else {
917             AUDIO_ERR_LOG("Stop failed!");
918             return ERR_OPERATION_FAILED;
919         }
920     }
921     OffloadRunningLockUnlock();
922     AUDIO_WARNING_LOG("Stop duplicate");
923 
924     return SUCCESS;
925 }
926 
Pause(void)927 int32_t OffloadAudioRendererSinkInner::Pause(void)
928 {
929     AUDIO_ERR_LOG("Pause not use yet");
930     return ERR_NOT_SUPPORTED;
931 }
932 
Resume(void)933 int32_t OffloadAudioRendererSinkInner::Resume(void)
934 {
935     AUDIO_ERR_LOG("Resume not use yet");
936     return ERR_NOT_SUPPORTED;
937 }
938 
Reset(void)939 int32_t OffloadAudioRendererSinkInner::Reset(void)
940 {
941     Trace trace("OffloadSink::Reset");
942     if (started_ && audioRender_ != nullptr) {
943         startDuringFlush_ = true;
944         if (!Flush()) {
945             return SUCCESS;
946         } else {
947             startDuringFlush_ = false;
948             AUDIO_ERR_LOG("Reset failed!");
949             return ERR_OPERATION_FAILED;
950         }
951     }
952 
953     return ERR_OPERATION_FAILED;
954 }
955 
Flush(void)956 int32_t OffloadAudioRendererSinkInner::Flush(void)
957 {
958     Trace trace("OffloadSink::Flush");
959     CHECK_AND_RETURN_RET_LOG(!isFlushing_, ERR_OPERATION_FAILED,
960         "failed call flush during flushing");
961     CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE,
962         "failed audio render null");
963     CHECK_AND_RETURN_RET_LOG(started_, ERR_INVALID_HANDLE,
964         "failed state is not started");
965     isFlushing_ = true;
966     thread([&] {
967         auto future = async(launch::async, [&] {
968             std::lock_guard<std::mutex> lock(renderMutex_);
969             CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE,
970                 "failed audio render null");
971             return audioRender_->Flush(audioRender_);
972         });
973         if (future.wait_for(250ms) == future_status::timeout) { // max wait 250ms
974             AUDIO_ERR_LOG("Flush failed! timeout of 250ms");
975         } else {
976             int32_t ret = future.get();
977             if (ret) {
978                 AUDIO_ERR_LOG("Flush failed! ret %{public}d", ret);
979             }
980         }
981         isFlushing_ = false;
982         if (startDuringFlush_) {
983             startDuringFlush_ = false;
984             Start();
985         }
986     }).detach();
987     renderPos_ = 0;
988     return SUCCESS;
989 }
990 
SuspendRenderSink(void)991 int32_t OffloadAudioRendererSinkInner::SuspendRenderSink(void)
992 {
993     return SUCCESS;
994 }
995 
RestoreRenderSink(void)996 int32_t OffloadAudioRendererSinkInner::RestoreRenderSink(void)
997 {
998     return SUCCESS;
999 }
1000 
SetBufferSize(uint32_t sizeMs)1001 int32_t OffloadAudioRendererSinkInner::SetBufferSize(uint32_t sizeMs)
1002 {
1003     Trace trace("OffloadSink::SetBufferSize");
1004     CHECK_AND_RETURN_RET_LOG(!isFlushing_, ERR_OPERATION_FAILED, "failed! during flushing");
1005     int32_t ret;
1006     // bytewidth is 4
1007     uint32_t size = (uint64_t) sizeMs * AUDIO_SAMPLE_RATE_48K * 4 * STEREO_CHANNEL_COUNT / SECOND_TO_MILLISECOND;
1008     CHECK_AND_RETURN_RET_LOG(audioRender_ != nullptr, ERR_INVALID_HANDLE,
1009         "failed audio render null");
1010 
1011     ret = audioRender_->SetBufferSize(audioRender_, size);
1012     CHECK_AND_RETURN_RET_LOG(!ret, ERR_OPERATION_FAILED,
1013         "SetBufferSize failed!");
1014 
1015     return SUCCESS;
1016 }
1017 
OffloadRunningLockInit(void)1018 int32_t OffloadAudioRendererSinkInner::OffloadRunningLockInit(void)
1019 {
1020 #ifdef FEATURE_POWER_MANAGER
1021     CHECK_AND_RETURN_RET_LOG(offloadRunningLockManager_ == nullptr, ERR_OPERATION_FAILED,
1022         "OffloadKeepRunningLock is not null, init failed!");
1023     std::shared_ptr<PowerMgr::RunningLock> keepRunningLock;
1024     WatchTimeout guard("PowerMgr::PowerMgrClient::GetInstance().CreateRunningLock:OffloadRunningLockInit");
1025     keepRunningLock = PowerMgr::PowerMgrClient::GetInstance().CreateRunningLock("AudioOffloadBackgroudPlay",
1026         PowerMgr::RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO);
1027     guard.CheckCurrTimeout();
1028 
1029     CHECK_AND_RETURN_RET_LOG(keepRunningLock != nullptr, ERR_OPERATION_FAILED, "keepRunningLock is nullptr");
1030     offloadRunningLockManager_ = std::make_shared<AudioRunningLockManager<PowerMgr::RunningLock>> (keepRunningLock);
1031 
1032 #endif
1033     return SUCCESS;
1034 }
1035 
OffloadRunningLockLock(void)1036 int32_t OffloadAudioRendererSinkInner::OffloadRunningLockLock(void)
1037 {
1038 #ifdef FEATURE_POWER_MANAGER
1039     AUDIO_INFO_LOG("keepRunningLock Lock");
1040     std::shared_ptr<PowerMgr::RunningLock> keepRunningLock;
1041     if (offloadRunningLockManager_ == nullptr) {
1042         WatchTimeout guard("PowerMgr::PowerMgrClient::GetInstance().CreateRunningLock:OffloadRunningLockLock");
1043         keepRunningLock = PowerMgr::PowerMgrClient::GetInstance().CreateRunningLock("AudioOffloadBackgroudPlay",
1044             PowerMgr::RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO);
1045         guard.CheckCurrTimeout();
1046         if (keepRunningLock) {
1047             offloadRunningLockManager_ =
1048                 std::make_shared<AudioRunningLockManager<PowerMgr::RunningLock>> (keepRunningLock);
1049         }
1050     }
1051     CHECK_AND_RETURN_RET_LOG(offloadRunningLockManager_ != nullptr, ERR_OPERATION_FAILED,
1052         "offloadRunningLockManager_ is null, playback can not work well!");
1053     CHECK_AND_RETURN_RET(!runninglocked, SUCCESS);
1054     runninglocked = true;
1055     offloadRunningLockManager_->Lock(RUNNINGLOCK_LOCK_TIMEOUTMS_LASTING); // -1 for lasting.
1056 #endif
1057 
1058     return SUCCESS;
1059 }
1060 
OffloadRunningLockUnlock(void)1061 int32_t OffloadAudioRendererSinkInner::OffloadRunningLockUnlock(void)
1062 {
1063 #ifdef FEATURE_POWER_MANAGER
1064     AUDIO_INFO_LOG("keepRunningLock UnLock");
1065     CHECK_AND_RETURN_RET_LOG(offloadRunningLockManager_ != nullptr, ERR_OPERATION_FAILED,
1066         "OffloadKeepRunningLock is null, playback can not work well!");
1067     CHECK_AND_RETURN_RET(runninglocked, SUCCESS);
1068     runninglocked = false;
1069     offloadRunningLockManager_->UnLock();
1070 #endif
1071 
1072     return SUCCESS;
1073 }
1074 
ResetOutputRouteForDisconnect(DeviceType device)1075 void OffloadAudioRendererSinkInner::ResetOutputRouteForDisconnect(DeviceType device)
1076 {
1077     AUDIO_WARNING_LOG("not supported.");
1078 }
1079 
InitLatencyMeasurement()1080 void OffloadAudioRendererSinkInner::InitLatencyMeasurement()
1081 {
1082     if (!AudioLatencyMeasurement::CheckIfEnabled()) {
1083         return;
1084     }
1085     AUDIO_INFO_LOG("LatencyMeas OffloadRendererSinkInit");
1086     signalDetectAgent_ = std::make_shared<SignalDetectAgent>();
1087     CHECK_AND_RETURN_LOG(signalDetectAgent_ != nullptr, "LatencyMeas signalDetectAgent_ is nullptr");
1088     signalDetectAgent_->sampleFormat_ = attr_.format;
1089     signalDetectAgent_->formatByteSize_ = GetFormatByteSize(attr_.format);
1090     latencyMeasEnabled_ = true;
1091     signalDetected_ = false;
1092 }
1093 
DeinitLatencyMeasurement()1094 void OffloadAudioRendererSinkInner::DeinitLatencyMeasurement()
1095 {
1096     signalDetectAgent_ = nullptr;
1097     latencyMeasEnabled_ = false;
1098 }
1099 
CheckLatencySignal(uint8_t * data,size_t len)1100 void OffloadAudioRendererSinkInner::CheckLatencySignal(uint8_t *data, size_t len)
1101 {
1102     if (!latencyMeasEnabled_) {
1103         return;
1104     }
1105     CHECK_AND_RETURN_LOG(signalDetectAgent_ != nullptr, "LatencyMeas signalDetectAgent_ is nullptr");
1106     size_t byteSize = static_cast<size_t>(GetFormatByteSize(attr_.format));
1107     size_t newlyCheckedTime = len / (attr_.sampleRate / MILLISECOND_PER_SECOND) /
1108         (byteSize * sizeof(uint8_t) * attr_.channel);
1109     detectedTime_ += newlyCheckedTime;
1110     if (detectedTime_ >= MILLISECOND_PER_SECOND && signalDetectAgent_->signalDetected_ &&
1111         !signalDetectAgent_->dspTimestampGot_) {
1112             char value[GET_EXTRA_PARAM_LEN];
1113             AudioParamKey key = NONE;
1114             AudioExtParamKey hdiKey = AudioExtParamKey(key);
1115             std::string condition = "debug_audio_latency_measurement";
1116             int32_t ret = audioAdapter_->GetExtraParams(audioAdapter_, hdiKey,
1117                 condition.c_str(), value, GET_EXTRA_PARAM_LEN);
1118             AUDIO_DEBUG_LOG("GetExtraParameter ret:%{public}d", ret);
1119             LatencyMonitor::GetInstance().UpdateDspTime(value);
1120             LatencyMonitor::GetInstance().UpdateSinkOrSourceTime(true,
1121                 signalDetectAgent_->lastPeakBufferTime_);
1122             LatencyMonitor::GetInstance().ShowTimestamp(true);
1123             signalDetectAgent_->dspTimestampGot_ = true;
1124             signalDetectAgent_->signalDetected_ = false;
1125     }
1126     signalDetected_ = signalDetectAgent_->CheckAudioData(data, len);
1127     if (signalDetected_) {
1128         AUDIO_INFO_LOG("LatencyMeas offloadSink signal detected");
1129         detectedTime_ = 0;
1130     }
1131 }
1132 
SetPaPower(int32_t flag)1133 int32_t OffloadAudioRendererSinkInner::SetPaPower(int32_t flag)
1134 {
1135     (void)flag;
1136     return ERR_NOT_SUPPORTED;
1137 }
1138 
SetPriPaPower()1139 int32_t OffloadAudioRendererSinkInner::SetPriPaPower()
1140 {
1141     return ERR_NOT_SUPPORTED;
1142 }
1143 
UpdateAppsUid(const int32_t appsUid[MAX_MIX_CHANNELS],const size_t size)1144 int32_t OffloadAudioRendererSinkInner::UpdateAppsUid(const int32_t appsUid[MAX_MIX_CHANNELS], const size_t size)
1145 {
1146 #ifdef FEATURE_POWER_MANAGER
1147     if (!offloadRunningLockManager_) {
1148         return ERROR;
1149     }
1150 
1151     return offloadRunningLockManager_->UpdateAppsUid(appsUid, appsUid + size);
1152 #endif
1153 
1154     return SUCCESS;
1155 }
1156 
UpdateAppsUid(const std::vector<int32_t> & appsUid)1157 int32_t OffloadAudioRendererSinkInner::UpdateAppsUid(const std::vector<int32_t> &appsUid)
1158 {
1159     AUDIO_WARNING_LOG("not supported.");
1160     return SUCCESS;
1161 }
1162 // LCOV_EXCL_STOP
1163 } // namespace AudioStandard
1164 } // namespace OHOS
1165