1 /*
2 * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "audio_render_interface_impl.h"
17
18 #include <hdf_base.h>
19 #include <unistd.h>
20 #include "sys/time.h"
21
22 #include "cJSON.h"
23 #include "daudio_constants.h"
24 #include "daudio_events.h"
25 #include "daudio_log.h"
26 #include "daudio_utils.h"
27
28 #undef DH_LOG_TAG
29 #define DH_LOG_TAG "AudioRenderInterfaceImpl"
30
31 using namespace OHOS::DistributedHardware;
32 namespace OHOS {
33 namespace HDI {
34 namespace DistributedAudio {
35 namespace Audio {
36 namespace V1_0 {
AudioRenderInterfaceImpl(const std::string & adpName,const AudioDeviceDescriptor & desc,const AudioSampleAttributes & attrs,const sptr<IDAudioCallback> & callback,uint32_t renderId)37 AudioRenderInterfaceImpl::AudioRenderInterfaceImpl(const std::string &adpName, const AudioDeviceDescriptor &desc,
38 const AudioSampleAttributes &attrs, const sptr<IDAudioCallback> &callback, uint32_t renderId)
39 : adapterName_(adpName), devDesc_(desc),
40 devAttrs_(attrs), renderId_(renderId), audioExtCallback_(callback)
41 {
42 devAttrs_.frameSize = CalculateFrameSize(attrs.sampleRate, attrs.channelCount, attrs.format,
43 AUDIO_NORMAL_INTERVAL, false);
44 DHLOGD("Distributed audio render constructed, period(%{public}d), frameSize(%{public}d).",
45 attrs.period, devAttrs_.frameSize);
46 }
47
~AudioRenderInterfaceImpl()48 AudioRenderInterfaceImpl::~AudioRenderInterfaceImpl()
49 {
50 DHLOGD("Distributed audio render destructed, id(%{public}d).", devDesc_.pins);
51 }
52
GetAudioCallback()53 sptr<IAudioCallback> AudioRenderInterfaceImpl::GetAudioCallback()
54 {
55 return renderCallback_;
56 }
57
GetLatency(uint32_t & ms)58 int32_t AudioRenderInterfaceImpl::GetLatency(uint32_t &ms)
59 {
60 DHLOGD("Get render device latency.");
61 if (audioExtCallback_ == nullptr) {
62 DHLOGE("Callback is nullptr.");
63 return HDF_FAILURE;
64 }
65
66 if (audioExtCallback_->GetLatency(renderId_, ms) != HDF_SUCCESS) {
67 DHLOGE("Get render device latency failed.");
68 return HDF_FAILURE;
69 }
70 return HDF_SUCCESS;
71 }
72
GetFadeRate(uint32_t currentIndex,const uint32_t durationIndex)73 float AudioRenderInterfaceImpl::GetFadeRate(uint32_t currentIndex, const uint32_t durationIndex)
74 {
75 if (currentIndex > durationIndex || durationIndex == 0) {
76 return 1.0f;
77 }
78
79 float fadeRate = static_cast<float>(currentIndex) / durationIndex * DAUDIO_FADE_NORMALIZATION_FACTOR;
80 if (fadeRate < 1) {
81 return pow(fadeRate, DAUDIO_FADE_POWER_NUM) / DAUDIO_FADE_NORMALIZATION_FACTOR;
82 }
83 return -pow(fadeRate - DAUDIO_FADE_MAXIMUM_VALUE, DAUDIO_FADE_POWER_NUM) /
84 DAUDIO_FADE_NORMALIZATION_FACTOR + 1;
85 }
86
FadeInProcess(const uint32_t durationFrame,int8_t * frameData,const size_t frameLength)87 int32_t AudioRenderInterfaceImpl::FadeInProcess(const uint32_t durationFrame,
88 int8_t *frameData, const size_t frameLength)
89 {
90 if (frameLength > RENDER_MAX_FRAME_SIZE) {
91 DHLOGE("The frameLength is over max length.");
92 return HDF_ERR_INVALID_PARAM;
93 }
94 int16_t* frame = reinterpret_cast<int16_t *>(frameData);
95 const size_t newFrameLength = frameLength / 2;
96
97 for (size_t k = 0; k < newFrameLength; ++k) {
98 float rate = GetFadeRate(currentFrame_ * newFrameLength + k, durationFrame * newFrameLength);
99 frame[k] = currentFrame_ == durationFrame - 1 ? frame[k] : static_cast<int16_t>(rate * frame[k]);
100 }
101 if (currentFrame_ < durationFrame - 1) {
102 DHLOGD("Fade-in frame[currentFrame: %{public}d].", currentFrame_);
103 }
104 ++currentFrame_;
105 currentFrame_ = currentFrame_ >= durationFrame ? durationFrame - 1 : currentFrame_;
106
107 return HDF_SUCCESS;
108 }
109
RenderFrame(const std::vector<int8_t> & frame,uint64_t & replyBytes)110 int32_t AudioRenderInterfaceImpl::RenderFrame(const std::vector<int8_t> &frame, uint64_t &replyBytes)
111 {
112 DHLOGD("Render frame[sampleRate: %{public}u, channelCount: %{public}u, format: %{public}d, frameSize: %{public}u].",
113 devAttrs_.sampleRate, devAttrs_.channelCount, devAttrs_.format, devAttrs_.frameSize);
114
115 int64_t startTime = GetNowTimeUs();
116 std::lock_guard<std::mutex> renderLck(renderMtx_);
117 if (renderStatus_ != RENDER_STATUS_START) {
118 DHLOGE("Render status wrong, return false.");
119 return HDF_ERR_DEVICE_BUSY;
120 }
121
122 AudioParameter param = { devAttrs_.format, devAttrs_.channelCount, devAttrs_.sampleRate, 0,
123 devAttrs_.frameSize, devAttrs_.type};
124 AudioData data = { param, frame };
125 DumpFileUtil::WriteDumpFile(dumpFile_, static_cast<void *>(data.data.data()), frame.size());
126 if (enableFade_ && (currentFrame_ < DURATION_FRAMES_MINUS)) {
127 FadeInProcess(DURATION_FRAMES, data.data.data(), frame.size());
128 }
129 if (audioExtCallback_ == nullptr) {
130 DHLOGE("Callback is nullptr.");
131 return HDF_FAILURE;
132 }
133 #ifdef DAUDIO_SUPPORT_SHARED_BUFFER
134 if (WriteToShmem(data) != HDF_SUCCESS) {
135 DHLOGE("Write stream data failed.");
136 return HDF_FAILURE;
137 }
138 #else
139 if (audioExtCallback_->WriteStreamData(renderId_, data) != HDF_SUCCESS) {
140 DHLOGE("Write stream data failed.");
141 return HDF_FAILURE;
142 }
143 #endif
144
145 replyBytes = data.data.size();
146 ++frameIndex_;
147 DHLOGD("Render audio frame success.");
148 int64_t endTime = GetNowTimeUs();
149 if (IsOutDurationRange(startTime, endTime, lastRenderStartTime_)) {
150 DHLOGE("This frame spend: %{public}" PRId64" us, interval of two frames: %{public}" PRId64 " us",
151 endTime - startTime, startTime - lastRenderStartTime_);
152 }
153 lastRenderStartTime_ = startTime;
154 return HDF_SUCCESS;
155 }
156
GetRenderPosition(uint64_t & frames,AudioTimeStamp & time)157 int32_t AudioRenderInterfaceImpl::GetRenderPosition(uint64_t &frames, AudioTimeStamp &time)
158 {
159 DHLOGI("Get render position.");
160 if (audioExtCallback_ == nullptr) {
161 DHLOGE("Callback is nullptr.");
162 return HDF_FAILURE;
163 }
164
165 CurrentTime currentTime;
166 currentTime.tvSec = time.tvSec;
167 currentTime.tvNSec = time.tvNSec;
168 if (audioExtCallback_->GetRenderPosition(renderId_, frames, currentTime) != HDF_SUCCESS) {
169 DHLOGE("Get render position failed.");
170 return HDF_FAILURE;
171 }
172 time.tvSec = currentTime.tvSec;
173 time.tvNSec = currentTime.tvNSec;
174 return HDF_SUCCESS;
175 }
176
SetRenderSpeed(float speed)177 int32_t AudioRenderInterfaceImpl::SetRenderSpeed(float speed)
178 {
179 DHLOGI("Set render speed.");
180 if (audioExtCallback_ == nullptr) {
181 DHLOGE("Callback is nullptr.");
182 return HDF_FAILURE;
183 }
184
185 renderSpeed_ = speed;
186 std::string content = std::to_string(speed);
187 DAudioEvent event = { HDF_AUDIO_EVENT_SPEED_CHANGE, content};
188 if (audioExtCallback_->NotifyEvent(renderId_, event) != HDF_SUCCESS) {
189 DHLOGE("Set render speed failed.");
190 return HDF_FAILURE;
191 }
192 return HDF_SUCCESS;
193 }
194
GetRenderSpeed(float & speed)195 int32_t AudioRenderInterfaceImpl::GetRenderSpeed(float &speed)
196 {
197 DHLOGI("Get render speed, control render speed is not support yet.");
198 speed = renderSpeed_;
199 return HDF_SUCCESS;
200 }
201
SetChannelMode(AudioChannelMode mode)202 int32_t AudioRenderInterfaceImpl::SetChannelMode(AudioChannelMode mode)
203 {
204 DHLOGI("Set channel mode, control channel mode is not support yet.");
205 channelMode_ = mode;
206 return HDF_SUCCESS;
207 }
208
GetChannelMode(AudioChannelMode & mode)209 int32_t AudioRenderInterfaceImpl::GetChannelMode(AudioChannelMode &mode)
210 {
211 DHLOGI("Get channel mode, control channel mode is not support yet.");
212 mode = channelMode_;
213 return HDF_SUCCESS;
214 }
215
RegCallback(const sptr<IAudioCallback> & audioCallback,int8_t cookie)216 int32_t AudioRenderInterfaceImpl::RegCallback(const sptr<IAudioCallback> &audioCallback, int8_t cookie)
217 {
218 DHLOGI("Register render callback.");
219 (void)cookie;
220 renderCallback_ = audioCallback;
221 return HDF_SUCCESS;
222 }
223
DrainBuffer(AudioDrainNotifyType & type)224 int32_t AudioRenderInterfaceImpl::DrainBuffer(AudioDrainNotifyType &type)
225 {
226 DHLOGI("Drain audio buffer, not support yet.");
227 (void)type;
228 return HDF_SUCCESS;
229 }
230
IsSupportsDrain(bool & support)231 int32_t AudioRenderInterfaceImpl::IsSupportsDrain(bool &support)
232 {
233 DHLOGI("Check whether drain is supported, not support yet.");
234 (void)support;
235 return HDF_SUCCESS;
236 }
237
Start()238 int32_t AudioRenderInterfaceImpl::Start()
239 {
240 DHLOGI("Start render.");
241 if (firstOpenFlag_) {
242 firstOpenFlag_ = false;
243 } else {
244 cJSON *jParam = cJSON_CreateObject();
245 if (jParam == nullptr) {
246 DHLOGE("Failed to create cJSON object.");
247 return HDF_FAILURE;
248 }
249 cJSON_AddStringToObject(jParam, KEY_DH_ID, std::to_string(devDesc_.pins).c_str());
250 cJSON_AddStringToObject(jParam, "ChangeType", HDF_EVENT_RESTART.c_str());
251 char *jsonData = cJSON_PrintUnformatted(jParam);
252 if (jsonData == nullptr) {
253 DHLOGE("Failed to create JSON data.");
254 cJSON_Delete(jParam);
255 return HDF_FAILURE;
256 }
257 std::string content(jsonData);
258 cJSON_Delete(jParam);
259 cJSON_free(jsonData);
260 DAudioEvent event = { HDF_AUDIO_EVENT_CHANGE_PLAY_STATUS, content};
261 if (audioExtCallback_ == nullptr) {
262 DHLOGE("Callback is nullptr.");
263 return HDF_FAILURE;
264 }
265 int32_t ret = audioExtCallback_->NotifyEvent(renderId_, event);
266 if (ret != HDF_SUCCESS) {
267 DHLOGE("Restart failed.");
268 }
269 }
270 #ifdef DAUDIO_SUPPORT_SHARED_BUFFER
271 writeIndex_ = 0;
272 writeNum_ = 0;
273 if (NotifyFirstChangeEvent(HDF_AUDIO_EVENT_START) != HDF_SUCCESS) {
274 return HDF_FAILURE;
275 }
276 #endif
277
278 std::lock_guard<std::mutex> renderLck(renderMtx_);
279 renderStatus_ = RENDER_STATUS_START;
280 currentFrame_ = CUR_FRAME_INIT_VALUE;
281 frameIndex_ = 0;
282 DumpFileUtil::OpenDumpFile(DUMP_SERVER_PARA, DUMP_HDF_RENDER_To_SA, &dumpFile_);
283 return HDF_SUCCESS;
284 }
285
Stop()286 int32_t AudioRenderInterfaceImpl::Stop()
287 {
288 DHLOGI("Stop render.");
289 if (GetRenderStatus() != RENDER_STATUS_START) {
290 DHLOGI("Render has not been started.");
291 return HDF_SUCCESS;
292 }
293 #ifdef DAUDIO_SUPPORT_SHARED_BUFFER
294 writeIndex_ = 0;
295 writeNum_ = 0;
296 #endif
297 cJSON *jParam = cJSON_CreateObject();
298 if (jParam == nullptr) {
299 DHLOGE("Failed to create cJSON object.");
300 return HDF_FAILURE;
301 }
302 cJSON_AddStringToObject(jParam, KEY_DH_ID, std::to_string(devDesc_.pins).c_str());
303 cJSON_AddStringToObject(jParam, "ChangeType", HDF_EVENT_PAUSE.c_str());
304 char *jsonData = cJSON_PrintUnformatted(jParam);
305 if (jsonData == nullptr) {
306 DHLOGE("Failed to create JSON data.");
307 cJSON_Delete(jParam);
308 return HDF_FAILURE;
309 }
310 std::string content(jsonData);
311 cJSON_Delete(jParam);
312 cJSON_free(jsonData);
313 DAudioEvent event = { HDF_AUDIO_EVENT_CHANGE_PLAY_STATUS, content};
314 if (audioExtCallback_ == nullptr) {
315 DHLOGE("Callback is nullptr.");
316 return HDF_FAILURE;
317 }
318 int32_t ret = audioExtCallback_->NotifyEvent(renderId_, event);
319 if (ret != HDF_SUCCESS) {
320 DHLOGE("Pause and clear cache streams failed.");
321 }
322 std::lock_guard<std::mutex> renderLck(renderMtx_);
323 renderStatus_ = RENDER_STATUS_STOP;
324 DumpFileUtil::CloseDumpFile(&dumpFile_);
325 return HDF_SUCCESS;
326 }
327
Pause()328 int32_t AudioRenderInterfaceImpl::Pause()
329 {
330 DHLOGI("Pause render.");
331 std::lock_guard<std::mutex> renderLck(renderMtx_);
332 renderStatus_ = RENDER_STATUS_PAUSE;
333 return HDF_SUCCESS;
334 }
335
Resume()336 int32_t AudioRenderInterfaceImpl::Resume()
337 {
338 return HDF_SUCCESS;
339 }
340
Flush()341 int32_t AudioRenderInterfaceImpl::Flush()
342 {
343 DHLOGI("Flush.");
344 if (audioExtCallback_ == nullptr) {
345 DHLOGE("Callback is nullptr.");
346 return HDF_FAILURE;
347 }
348
349 std::string content;
350 DAudioEvent event = { HDF_AUDIO_EVENT_FLUSH, content};
351 if (audioExtCallback_->NotifyEvent(renderId_, event) != HDF_SUCCESS) {
352 DHLOGE("Flush failed.");
353 return HDF_FAILURE;
354 }
355 return HDF_SUCCESS;
356 }
357
TurnStandbyMode()358 int32_t AudioRenderInterfaceImpl::TurnStandbyMode()
359 {
360 DHLOGI("Turn stand by mode, not support yet.");
361 return HDF_SUCCESS;
362 }
363
AudioDevDump(int32_t range,int32_t fd)364 int32_t AudioRenderInterfaceImpl::AudioDevDump(int32_t range, int32_t fd)
365 {
366 DHLOGI("Dump audio info, not support yet.");
367 (void)range;
368 (void)fd;
369 return HDF_SUCCESS;
370 }
371
IsSupportsPauseAndResume(bool & supportPause,bool & supportResume)372 int32_t AudioRenderInterfaceImpl::IsSupportsPauseAndResume(bool &supportPause, bool &supportResume)
373 {
374 DHLOGI("Check whether pause and resume is supported, not support yet.");
375 (void)supportPause;
376 (void)supportResume;
377 return HDF_SUCCESS;
378 }
379
CheckSceneCapability(const AudioSceneDescriptor & scene,bool & supported)380 int32_t AudioRenderInterfaceImpl::CheckSceneCapability(const AudioSceneDescriptor &scene, bool &supported)
381 {
382 DHLOGI("Check scene capability.");
383 (void)scene;
384 (void)supported;
385 return HDF_SUCCESS;
386 }
387
SelectScene(const AudioSceneDescriptor & scene)388 int32_t AudioRenderInterfaceImpl::SelectScene(const AudioSceneDescriptor &scene)
389 {
390 DHLOGI("Select audio scene, not support yet.");
391 (void)scene;
392 return HDF_SUCCESS;
393 }
394
SetMute(bool mute)395 int32_t AudioRenderInterfaceImpl::SetMute(bool mute)
396 {
397 DHLOGI("Set mute, not support yet.");
398 (void)mute;
399 return HDF_SUCCESS;
400 }
401
GetMute(bool & mute)402 int32_t AudioRenderInterfaceImpl::GetMute(bool &mute)
403 {
404 DHLOGI("Get mute, not support yet.");
405 (void)mute;
406 return HDF_SUCCESS;
407 }
408
SetVolume(float volume)409 int32_t AudioRenderInterfaceImpl::SetVolume(float volume)
410 {
411 DHLOGI("Set volume.");
412 if (audioExtCallback_ == nullptr) {
413 DHLOGE("Callback is nullptr.");
414 return HDF_FAILURE;
415 }
416
417 std::string content = std::to_string(volume);
418 DAudioEvent event = { HDF_AUDIO_EVENT_VOLUME_CHANGE, content};
419 if (audioExtCallback_->NotifyEvent(renderId_, event) != HDF_SUCCESS) {
420 DHLOGE("Set volume failed.");
421 return HDF_FAILURE;
422 }
423 return HDF_SUCCESS;
424 }
425
GetVolume(float & volume)426 int32_t AudioRenderInterfaceImpl::GetVolume(float &volume)
427 {
428 DHLOGI("Can not get vol not by this interface.");
429 (void)volume;
430 return HDF_SUCCESS;
431 }
432
GetGainThreshold(float & min,float & max)433 int32_t AudioRenderInterfaceImpl::GetGainThreshold(float &min, float &max)
434 {
435 DHLOGI("Get gain threshold, not support yet.");
436 min = 0;
437 max = 0;
438 return HDF_SUCCESS;
439 }
440
SetGain(float gain)441 int32_t AudioRenderInterfaceImpl::SetGain(float gain)
442 {
443 DHLOGI("Set gain, not support yet.");
444 (void)gain;
445 return HDF_SUCCESS;
446 }
447
GetGain(float & gain)448 int32_t AudioRenderInterfaceImpl::GetGain(float &gain)
449 {
450 DHLOGI("Get gain, not support yet.");
451 gain = 1.0;
452 return HDF_SUCCESS;
453 }
454
GetFrameSize(uint64_t & size)455 int32_t AudioRenderInterfaceImpl::GetFrameSize(uint64_t &size)
456 {
457 (void)size;
458 return HDF_SUCCESS;
459 }
460
GetFrameCount(uint64_t & count)461 int32_t AudioRenderInterfaceImpl::GetFrameCount(uint64_t &count)
462 {
463 (void)count;
464 return HDF_SUCCESS;
465 }
466
SetSampleAttributes(const AudioSampleAttributes & attrs)467 int32_t AudioRenderInterfaceImpl::SetSampleAttributes(const AudioSampleAttributes &attrs)
468 {
469 DHLOGI("Set sample attributes.");
470 devAttrs_ = attrs;
471 return HDF_SUCCESS;
472 }
473
GetSampleAttributes(AudioSampleAttributes & attrs)474 int32_t AudioRenderInterfaceImpl::GetSampleAttributes(AudioSampleAttributes &attrs)
475 {
476 DHLOGI("Get sample attributes.");
477 attrs = devAttrs_;
478 return HDF_SUCCESS;
479 }
480
GetCurrentChannelId(uint32_t & channelId)481 int32_t AudioRenderInterfaceImpl::GetCurrentChannelId(uint32_t &channelId)
482 {
483 DHLOGI("Get current channel id, not support yet.");
484 (void)channelId;
485 return HDF_SUCCESS;
486 }
487
SetExtraParams(const std::string & keyValueList)488 int32_t AudioRenderInterfaceImpl::SetExtraParams(const std::string &keyValueList)
489 {
490 DHLOGI("Set extra parameters, not support yet.");
491 (void)keyValueList;
492 return HDF_SUCCESS;
493 }
494
GetExtraParams(std::string & keyValueList)495 int32_t AudioRenderInterfaceImpl::GetExtraParams(std::string &keyValueList)
496 {
497 DHLOGI("Get extra parameters, not support yet.");
498 (void)keyValueList;
499 return HDF_SUCCESS;
500 }
501
502 #ifdef DAUDIO_SUPPORT_SHARED_BUFFER
CreateAshmem(int32_t ashmemLength)503 int32_t AudioRenderInterfaceImpl::CreateAshmem(int32_t ashmemLength)
504 {
505 const std::string memory_name = "Normal Render";
506 if (ashmemLength < DAUDIO_MIN_ASHMEM_LEN || ashmemLength > DAUDIO_MAX_ASHMEM_LEN) {
507 DHLOGE("The length of shared memory is illegal.");
508 return HDF_FAILURE;
509 }
510 ashmem_ = OHOS::Ashmem::CreateAshmem(memory_name.c_str(), ashmemLength);
511 if (ashmem_ == nullptr) {
512 DHLOGE("Create ashmem failed.");
513 return HDF_FAILURE;
514 }
515 bool ret = ashmem_->MapReadAndWriteAshmem();
516 if (ret != true) {
517 DHLOGE("Mmap ashmem failed.");
518 return HDF_FAILURE;
519 }
520 fd_ = ashmem_->GetAshmemFd();
521 DHLOGI("Init Ashmem success, fd: %{public}d, length: %{public}d", fd_, ashmemLength);
522 return HDF_SUCCESS;
523 }
524
WriteToShmem(const AudioData & data)525 int32_t AudioRenderInterfaceImpl::WriteToShmem(const AudioData &data)
526 {
527 DHLOGD("Write to shared memory.");
528 if (ashmem_ == nullptr) {
529 DHLOGE("Share memory is null");
530 return HDF_FAILURE;
531 }
532 if (data.param.frameSize != static_cast<uint32_t>(lengthPerTrans_)) {
533 DHLOGE("The param:framsize is invalid.");
534 return HDF_FAILURE;
535 }
536 const auto &audioData = data.data;
537 bool writeRet = ashmem_->WriteToAshmem(audioData.data(), audioData.size(), writeIndex_);
538 if (writeRet) {
539 DHLOGD("Write to ashmem success! write index: %{public}d, writeLength: %{public}d.",
540 writeIndex_, lengthPerTrans_);
541 } else {
542 DHLOGE("Write data to ashmem failed.");
543 }
544 writeIndex_ += lengthPerTrans_;
545 if (writeIndex_ >= ashmemLength_) {
546 writeIndex_ = 0;
547 }
548 writeNum_ += CalculateSampleNum(devAttrs_.sampleRate, timeInterval_);
549 return HDF_SUCCESS;
550 }
551
NotifyFirstChangeEvent(EXT_PARAM_EVENT evetType)552 int32_t AudioRenderInterfaceImpl::NotifyFirstChangeEvent(EXT_PARAM_EVENT evetType)
553 {
554 if (audioExtCallback_ == nullptr) {
555 DHLOGE("Ext callback is null.");
556 return HDF_FAILURE;
557 }
558 std::string content;
559 std::initializer_list<std::pair<std::string, std::string>> items = { {KEY_DH_ID, std::to_string(devDesc_.pins)} };
560 if (WrapCJsonItem(items, content) != HDF_SUCCESS) {
561 DHLOGE("Wrap the event failed.");
562 return HDF_FAILURE;
563 }
564 DAudioEvent event = { evetType, content };
565 int32_t ret = audioExtCallback_->NotifyEvent(renderId_, event);
566 if (ret != HDF_SUCCESS) {
567 DHLOGE("Start render mmap failed.");
568 return HDF_FAILURE;
569 }
570 return HDF_SUCCESS;
571 }
572 #endif
573
ReqMmapBuffer(int32_t reqSize,AudioMmapBufferDescriptor & desc)574 int32_t AudioRenderInterfaceImpl::ReqMmapBuffer(int32_t reqSize, AudioMmapBufferDescriptor &desc)
575 {
576 #ifdef DAUDIO_SUPPORT_SHARED_BUFFER
577 DHLOGI("Request mmap buffer.");
578 int32_t minSize = CalculateSampleNum(devAttrs_.sampleRate, minTimeInterval_);
579 int32_t maxSize = CalculateSampleNum(devAttrs_.sampleRate, maxTimeInterval_);
580 int32_t realSize = reqSize;
581 if (reqSize < minSize) {
582 realSize = minSize;
583 } else if (reqSize > maxSize) {
584 realSize = maxSize;
585 }
586 DHLOGI("ReqMmap buffer realsize : %{public}d, minsize: %{public}d, maxsize:%{public}d.",
587 realSize, minSize, maxSize);
588 desc.totalBufferFrames = realSize;
589 ashmemLength_ = realSize * static_cast<int32_t>(devAttrs_.channelCount) * devAttrs_.format;
590 DHLOGI("Init ashmem real sample size : %{public}d, length: %{public}d.", realSize, ashmemLength_);
591 int32_t ret = CreateAshmem(ashmemLength_);
592 if (ret != HDF_SUCCESS) {
593 DHLOGE("Init ashmem error..");
594 return HDF_FAILURE;
595 }
596 desc.memoryFd = fd_;
597 desc.transferFrameSize = static_cast<int32_t>(CalculateSampleNum(devAttrs_.sampleRate, timeInterval_));
598 lengthPerTrans_ = desc.transferFrameSize * static_cast<int32_t>(devAttrs_.channelCount) * devAttrs_.format;
599 desc.isShareable = false;
600 if (audioExtCallback_ == nullptr) {
601 DHLOGE("Callback is nullptr.");
602 return HDF_FAILURE;
603 }
604 ret = audioExtCallback_->RefreshAshmemInfo(renderId_, fd_, ashmemLength_, lengthPerTrans_);
605 if (ret != HDF_SUCCESS) {
606 DHLOGE("Refresh ashmem info failed.");
607 return HDF_FAILURE;
608 }
609 #else
610 DHLOGI("Request mmap buffer.");
611 if (audioExtCallback_ == nullptr) {
612 DHLOGE("Callback is nullptr.");
613 return HDF_FAILURE;
614 }
615
616 std::string content = std::to_string(reqSize);
617 DAudioEvent event = { HDF_AUDIO_OFFLOAD_BUF_SIZE_CHANGE, content};
618 if (audioExtCallback_->NotifyEvent(renderId_, event) != HDF_SUCCESS) {
619 DHLOGE("Set volume failed.");
620 return HDF_FAILURE;
621 }
622 #endif
623 return HDF_SUCCESS;
624 }
625
GetMmapPosition(uint64_t & frames,AudioTimeStamp & time)626 int32_t AudioRenderInterfaceImpl::GetMmapPosition(uint64_t &frames, AudioTimeStamp &time)
627 {
628 DHLOGI("Get mmap position, not support yet.");
629 (void)frames;
630 (void)time;
631 return HDF_SUCCESS;
632 }
633
AddAudioEffect(uint64_t effectid)634 int32_t AudioRenderInterfaceImpl::AddAudioEffect(uint64_t effectid)
635 {
636 DHLOGI("Add audio effect, not support yet.");
637 (void)effectid;
638 return HDF_SUCCESS;
639 }
640
RemoveAudioEffect(uint64_t effectid)641 int32_t AudioRenderInterfaceImpl::RemoveAudioEffect(uint64_t effectid)
642 {
643 DHLOGI("Remove audio effect, not support yet.");
644 (void)effectid;
645 return HDF_SUCCESS;
646 }
647
GetFrameBufferSize(uint64_t & bufferSize)648 int32_t AudioRenderInterfaceImpl::GetFrameBufferSize(uint64_t &bufferSize)
649 {
650 DHLOGI("Get frame buffer size, not support yet.");
651 (void)bufferSize;
652 return HDF_SUCCESS;
653 }
654
GetRenderDesc()655 const AudioDeviceDescriptor &AudioRenderInterfaceImpl::GetRenderDesc()
656 {
657 return devDesc_;
658 }
659
SetVolumeInner(const uint32_t vol)660 void AudioRenderInterfaceImpl::SetVolumeInner(const uint32_t vol)
661 {
662 std::lock_guard<std::mutex> volLck(volMtx_);
663 vol_ = vol;
664 }
665
SetVolumeRangeInner(const uint32_t volMax,const uint32_t volMin)666 void AudioRenderInterfaceImpl::SetVolumeRangeInner(const uint32_t volMax, const uint32_t volMin)
667 {
668 std::lock_guard<std::mutex> volLck(volMtx_);
669 volMin_ = volMin;
670 volMax_ = volMax;
671 }
672
GetVolumeInner()673 uint32_t AudioRenderInterfaceImpl::GetVolumeInner()
674 {
675 std::lock_guard<std::mutex> volLck(volMtx_);
676 return vol_;
677 }
678
GetMaxVolumeInner()679 uint32_t AudioRenderInterfaceImpl::GetMaxVolumeInner()
680 {
681 std::lock_guard<std::mutex> volLck(volMtx_);
682 return volMax_;
683 }
684
GetMinVolumeInner()685 uint32_t AudioRenderInterfaceImpl::GetMinVolumeInner()
686 {
687 std::lock_guard<std::mutex> volLck(volMtx_);
688 return volMin_;
689 }
690
SetAttrs(const std::string & adpName,const AudioDeviceDescriptor & desc,const AudioSampleAttributes & attrs,const sptr<IDAudioCallback> & callback,const int32_t dhId)691 void AudioRenderInterfaceImpl::SetAttrs(const std::string &adpName, const AudioDeviceDescriptor &desc,
692 const AudioSampleAttributes &attrs, const sptr<IDAudioCallback> &callback, const int32_t dhId)
693 {
694 DHLOGI("Set attrs, not support yet.");
695 }
696
SetDumpFlagInner()697 void AudioRenderInterfaceImpl::SetDumpFlagInner()
698 {
699 dumpFlag_ = true;
700 }
701
GetRenderStatus()702 AudioRenderStatus AudioRenderInterfaceImpl::GetRenderStatus()
703 {
704 std::lock_guard<std::mutex> renderLck(renderMtx_);
705 DHLOGI("Get renderstatus: %{public}d", static_cast<int32_t>(renderStatus_));
706 return renderStatus_;
707 }
708
SetRenderStatus(AudioRenderStatus status)709 void AudioRenderInterfaceImpl::SetRenderStatus(AudioRenderStatus status)
710 {
711 std::lock_guard<std::mutex> renderLck(renderMtx_);
712 renderStatus_ = status;
713 DHLOGI("Set renderstatus: %{public}d", static_cast<int32_t>(status));
714 }
715 } // V1_0
716 } // Audio
717 } // Distributedaudio
718 } // HDI
719 } // OHOS
720