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
GetLatency(uint32_t & ms)53 int32_t AudioRenderInterfaceImpl::GetLatency(uint32_t &ms)
54 {
55 DHLOGI("Get render device latency, not support yet.");
56 ms = 0;
57 return HDF_SUCCESS;
58 }
59
GetFadeRate(uint32_t currentIndex,const uint32_t durationIndex)60 float AudioRenderInterfaceImpl::GetFadeRate(uint32_t currentIndex, const uint32_t durationIndex)
61 {
62 if (currentIndex > durationIndex || durationIndex == 0) {
63 return 1.0f;
64 }
65
66 float fadeRate = static_cast<float>(currentIndex) / durationIndex * DAUDIO_FADE_NORMALIZATION_FACTOR;
67 if (fadeRate < 1) {
68 return pow(fadeRate, DAUDIO_FADE_POWER_NUM) / DAUDIO_FADE_NORMALIZATION_FACTOR;
69 }
70 return -pow(fadeRate - DAUDIO_FADE_MAXIMUM_VALUE, DAUDIO_FADE_POWER_NUM) /
71 DAUDIO_FADE_NORMALIZATION_FACTOR + 1;
72 }
73
FadeInProcess(const uint32_t durationFrame,int8_t * frameData,const size_t frameLength)74 int32_t AudioRenderInterfaceImpl::FadeInProcess(const uint32_t durationFrame,
75 int8_t *frameData, const size_t frameLength)
76 {
77 if (frameLength > RENDER_MAX_FRAME_SIZE) {
78 DHLOGE("The frameLength is over max length.");
79 return HDF_ERR_INVALID_PARAM;
80 }
81 int16_t* frame = reinterpret_cast<int16_t *>(frameData);
82 const size_t newFrameLength = frameLength / 2;
83
84 for (size_t k = 0; k < newFrameLength; ++k) {
85 float rate = GetFadeRate(currentFrame_ * newFrameLength + k, durationFrame * newFrameLength);
86 frame[k] = currentFrame_ == durationFrame - 1 ? frame[k] : static_cast<int16_t>(rate * frame[k]);
87 }
88 if (currentFrame_ < durationFrame - 1) {
89 DHLOGD("Fade-in frame[currentFrame: %{public}d].", currentFrame_);
90 }
91 ++currentFrame_;
92 currentFrame_ = currentFrame_ >= durationFrame ? durationFrame - 1 : currentFrame_;
93
94 return HDF_SUCCESS;
95 }
96
RenderFrame(const std::vector<int8_t> & frame,uint64_t & replyBytes)97 int32_t AudioRenderInterfaceImpl::RenderFrame(const std::vector<int8_t> &frame, uint64_t &replyBytes)
98 {
99 DHLOGD("Render frame[sampleRate: %{public}u, channelCount: %{public}u, format: %{public}d, frameSize: %{public}u].",
100 devAttrs_.sampleRate, devAttrs_.channelCount, devAttrs_.format, devAttrs_.frameSize);
101
102 int64_t startTime = GetNowTimeUs();
103 std::lock_guard<std::mutex> renderLck(renderMtx_);
104 if (renderStatus_ != RENDER_STATUS_START) {
105 DHLOGE("Render status wrong, return false.");
106 return HDF_FAILURE;
107 }
108
109 AudioParameter param = { devAttrs_.format, devAttrs_.channelCount, devAttrs_.sampleRate, 0,
110 devAttrs_.frameSize, devAttrs_.type};
111 AudioData data = { param, frame };
112 DumpFileUtil::WriteDumpFile(dumpFile_, static_cast<void *>(data.data.data()), frame.size());
113 if (enableFade_ && (currentFrame_ < DURATION_FRAMES_MINUS)) {
114 FadeInProcess(DURATION_FRAMES, data.data.data(), frame.size());
115 }
116 if (audioExtCallback_ == nullptr) {
117 DHLOGE("Callback is nullptr.");
118 return HDF_FAILURE;
119 }
120 #ifdef DAUDIO_SUPPORT_SHARED_BUFFER
121 if (WriteToShmem(data) != HDF_SUCCESS) {
122 DHLOGE("Write stream data failed.");
123 return HDF_FAILURE;
124 }
125 #else
126 if (audioExtCallback_->WriteStreamData(renderId_, data) != HDF_SUCCESS) {
127 DHLOGE("Write stream data failed.");
128 return HDF_FAILURE;
129 }
130 #endif
131
132 ++frameIndex_;
133 DHLOGD("Render audio frame success.");
134 int64_t endTime = GetNowTimeUs();
135 if (IsOutDurationRange(startTime, endTime, lastRenderStartTime_)) {
136 DHLOGE("This frame spend: %{public}" PRId64" us, interval of two frames: %{public}" PRId64 " us",
137 endTime - startTime, startTime - lastRenderStartTime_);
138 }
139 lastRenderStartTime_ = startTime;
140 return HDF_SUCCESS;
141 }
142
GetRenderPosition(uint64_t & frames,AudioTimeStamp & time)143 int32_t AudioRenderInterfaceImpl::GetRenderPosition(uint64_t &frames, AudioTimeStamp &time)
144 {
145 DHLOGI("Get render position, not support yet.");
146 (void)frames;
147 (void)time;
148 return HDF_SUCCESS;
149 }
150
SetRenderSpeed(float speed)151 int32_t AudioRenderInterfaceImpl::SetRenderSpeed(float speed)
152 {
153 DHLOGI("Set render speed, control render speed is not support yet.");
154 renderSpeed_ = speed;
155 return HDF_SUCCESS;
156 }
157
GetRenderSpeed(float & speed)158 int32_t AudioRenderInterfaceImpl::GetRenderSpeed(float &speed)
159 {
160 DHLOGI("Get render speed, control render speed is not support yet.");
161 speed = renderSpeed_;
162 return HDF_SUCCESS;
163 }
164
SetChannelMode(AudioChannelMode mode)165 int32_t AudioRenderInterfaceImpl::SetChannelMode(AudioChannelMode mode)
166 {
167 DHLOGI("Set channel mode, control channel mode is not support yet.");
168 channelMode_ = mode;
169 return HDF_SUCCESS;
170 }
171
GetChannelMode(AudioChannelMode & mode)172 int32_t AudioRenderInterfaceImpl::GetChannelMode(AudioChannelMode &mode)
173 {
174 DHLOGI("Get channel mode, control channel mode is not support yet.");
175 mode = channelMode_;
176 return HDF_SUCCESS;
177 }
178
RegCallback(const sptr<IAudioCallback> & audioCallback,int8_t cookie)179 int32_t AudioRenderInterfaceImpl::RegCallback(const sptr<IAudioCallback> &audioCallback, int8_t cookie)
180 {
181 DHLOGI("Register render callback.");
182 (void)cookie;
183 renderCallback_ = audioCallback;
184 return HDF_SUCCESS;
185 }
186
DrainBuffer(AudioDrainNotifyType & type)187 int32_t AudioRenderInterfaceImpl::DrainBuffer(AudioDrainNotifyType &type)
188 {
189 DHLOGI("Drain audio buffer, not support yet.");
190 (void)type;
191 return HDF_SUCCESS;
192 }
193
IsSupportsDrain(bool & support)194 int32_t AudioRenderInterfaceImpl::IsSupportsDrain(bool &support)
195 {
196 DHLOGI("Check whether drain is supported, not support yet.");
197 (void)support;
198 return HDF_SUCCESS;
199 }
200
Start()201 int32_t AudioRenderInterfaceImpl::Start()
202 {
203 DHLOGI("Start render.");
204 if (firstOpenFlag_) {
205 firstOpenFlag_ = false;
206 } else {
207 cJSON *jParam = cJSON_CreateObject();
208 if (jParam == nullptr) {
209 DHLOGE("Failed to create cJSON object.");
210 return HDF_FAILURE;
211 }
212 cJSON_AddStringToObject(jParam, KEY_DH_ID, std::to_string(devDesc_.pins).c_str());
213 cJSON_AddStringToObject(jParam, "ChangeType", HDF_EVENT_RESTART.c_str());
214 char *jsonData = cJSON_PrintUnformatted(jParam);
215 if (jsonData == nullptr) {
216 DHLOGE("Failed to create JSON data.");
217 cJSON_Delete(jParam);
218 return HDF_FAILURE;
219 }
220 std::string content(jsonData);
221 cJSON_Delete(jParam);
222 cJSON_free(jsonData);
223 DAudioEvent event = { HDF_AUDIO_EVENT_CHANGE_PLAY_STATUS, content};
224 if (audioExtCallback_ == nullptr) {
225 DHLOGE("Callback is nullptr.");
226 return HDF_FAILURE;
227 }
228 int32_t ret = audioExtCallback_->NotifyEvent(renderId_, event);
229 if (ret != HDF_SUCCESS) {
230 DHLOGE("Restart failed.");
231 }
232 }
233 #ifdef DAUDIO_SUPPORT_SHARED_BUFFER
234 writeIndex_ = 0;
235 writeNum_ = 0;
236 if (NotifyFirstChangeEvent(HDF_AUDIO_EVENT_START) != HDF_SUCCESS) {
237 return HDF_FAILURE;
238 }
239 #endif
240
241 std::lock_guard<std::mutex> renderLck(renderMtx_);
242 renderStatus_ = RENDER_STATUS_START;
243 currentFrame_ = CUR_FRAME_INIT_VALUE;
244 frameIndex_ = 0;
245 DumpFileUtil::OpenDumpFile(DUMP_SERVER_PARA, DUMP_HDF_RENDER_To_SA, &dumpFile_);
246 return HDF_SUCCESS;
247 }
248
Stop()249 int32_t AudioRenderInterfaceImpl::Stop()
250 {
251 DHLOGI("Stop render.");
252 #ifdef DAUDIO_SUPPORT_SHARED_BUFFER
253 writeIndex_ = 0;
254 writeNum_ = 0;
255 #endif
256 cJSON *jParam = cJSON_CreateObject();
257 if (jParam == nullptr) {
258 DHLOGE("Failed to create cJSON object.");
259 return HDF_FAILURE;
260 }
261 cJSON_AddStringToObject(jParam, KEY_DH_ID, std::to_string(devDesc_.pins).c_str());
262 cJSON_AddStringToObject(jParam, "ChangeType", HDF_EVENT_PAUSE.c_str());
263 char *jsonData = cJSON_PrintUnformatted(jParam);
264 if (jsonData == nullptr) {
265 DHLOGE("Failed to create JSON data.");
266 cJSON_Delete(jParam);
267 return HDF_FAILURE;
268 }
269 std::string content(jsonData);
270 cJSON_Delete(jParam);
271 cJSON_free(jsonData);
272 DAudioEvent event = { HDF_AUDIO_EVENT_CHANGE_PLAY_STATUS, content};
273 if (audioExtCallback_ == nullptr) {
274 DHLOGE("Callback is nullptr.");
275 return HDF_FAILURE;
276 }
277 int32_t ret = audioExtCallback_->NotifyEvent(renderId_, event);
278 if (ret != HDF_SUCCESS) {
279 DHLOGE("Pause and clear cache streams failed.");
280 }
281 std::lock_guard<std::mutex> renderLck(renderMtx_);
282 renderStatus_ = RENDER_STATUS_STOP;
283 DumpFileUtil::CloseDumpFile(&dumpFile_);
284 return HDF_SUCCESS;
285 }
286
Pause()287 int32_t AudioRenderInterfaceImpl::Pause()
288 {
289 DHLOGI("Pause render.");
290 std::lock_guard<std::mutex> renderLck(renderMtx_);
291 renderStatus_ = RENDER_STATUS_PAUSE;
292 return HDF_SUCCESS;
293 }
294
Resume()295 int32_t AudioRenderInterfaceImpl::Resume()
296 {
297 return HDF_SUCCESS;
298 }
299
Flush()300 int32_t AudioRenderInterfaceImpl::Flush()
301 {
302 return HDF_SUCCESS;
303 }
304
TurnStandbyMode()305 int32_t AudioRenderInterfaceImpl::TurnStandbyMode()
306 {
307 DHLOGI("Turn stand by mode, not support yet.");
308 return HDF_SUCCESS;
309 }
310
AudioDevDump(int32_t range,int32_t fd)311 int32_t AudioRenderInterfaceImpl::AudioDevDump(int32_t range, int32_t fd)
312 {
313 DHLOGI("Dump audio info, not support yet.");
314 (void)range;
315 (void)fd;
316 return HDF_SUCCESS;
317 }
318
IsSupportsPauseAndResume(bool & supportPause,bool & supportResume)319 int32_t AudioRenderInterfaceImpl::IsSupportsPauseAndResume(bool &supportPause, bool &supportResume)
320 {
321 DHLOGI("Check whether pause and resume is supported, not support yet.");
322 (void)supportPause;
323 (void)supportResume;
324 return HDF_SUCCESS;
325 }
326
CheckSceneCapability(const AudioSceneDescriptor & scene,bool & supported)327 int32_t AudioRenderInterfaceImpl::CheckSceneCapability(const AudioSceneDescriptor &scene, bool &supported)
328 {
329 DHLOGI("Check scene capability.");
330 (void)scene;
331 (void)supported;
332 return HDF_SUCCESS;
333 }
334
SelectScene(const AudioSceneDescriptor & scene)335 int32_t AudioRenderInterfaceImpl::SelectScene(const AudioSceneDescriptor &scene)
336 {
337 DHLOGI("Select audio scene, not support yet.");
338 (void)scene;
339 return HDF_SUCCESS;
340 }
341
SetMute(bool mute)342 int32_t AudioRenderInterfaceImpl::SetMute(bool mute)
343 {
344 DHLOGI("Set mute, not support yet.");
345 (void)mute;
346 return HDF_SUCCESS;
347 }
348
GetMute(bool & mute)349 int32_t AudioRenderInterfaceImpl::GetMute(bool &mute)
350 {
351 DHLOGI("Get mute, not support yet.");
352 (void)mute;
353 return HDF_SUCCESS;
354 }
355
SetVolume(float volume)356 int32_t AudioRenderInterfaceImpl::SetVolume(float volume)
357 {
358 DHLOGI("Can not set vol not by this interface.");
359 (void)volume;
360 return HDF_SUCCESS;
361 }
362
GetVolume(float & volume)363 int32_t AudioRenderInterfaceImpl::GetVolume(float &volume)
364 {
365 DHLOGI("Can not get vol not by this interface.");
366 (void)volume;
367 return HDF_SUCCESS;
368 }
369
GetGainThreshold(float & min,float & max)370 int32_t AudioRenderInterfaceImpl::GetGainThreshold(float &min, float &max)
371 {
372 DHLOGI("Get gain threshold, not support yet.");
373 min = 0;
374 max = 0;
375 return HDF_SUCCESS;
376 }
377
SetGain(float gain)378 int32_t AudioRenderInterfaceImpl::SetGain(float gain)
379 {
380 DHLOGI("Set gain, not support yet.");
381 (void)gain;
382 return HDF_SUCCESS;
383 }
384
GetGain(float & gain)385 int32_t AudioRenderInterfaceImpl::GetGain(float &gain)
386 {
387 DHLOGI("Get gain, not support yet.");
388 gain = 1.0;
389 return HDF_SUCCESS;
390 }
391
GetFrameSize(uint64_t & size)392 int32_t AudioRenderInterfaceImpl::GetFrameSize(uint64_t &size)
393 {
394 (void)size;
395 return HDF_SUCCESS;
396 }
397
GetFrameCount(uint64_t & count)398 int32_t AudioRenderInterfaceImpl::GetFrameCount(uint64_t &count)
399 {
400 (void)count;
401 return HDF_SUCCESS;
402 }
403
SetSampleAttributes(const AudioSampleAttributes & attrs)404 int32_t AudioRenderInterfaceImpl::SetSampleAttributes(const AudioSampleAttributes &attrs)
405 {
406 DHLOGI("Set sample attributes.");
407 devAttrs_ = attrs;
408 return HDF_SUCCESS;
409 }
410
GetSampleAttributes(AudioSampleAttributes & attrs)411 int32_t AudioRenderInterfaceImpl::GetSampleAttributes(AudioSampleAttributes &attrs)
412 {
413 DHLOGI("Get sample attributes.");
414 attrs = devAttrs_;
415 return HDF_SUCCESS;
416 }
417
GetCurrentChannelId(uint32_t & channelId)418 int32_t AudioRenderInterfaceImpl::GetCurrentChannelId(uint32_t &channelId)
419 {
420 DHLOGI("Get current channel id, not support yet.");
421 (void)channelId;
422 return HDF_SUCCESS;
423 }
424
SetExtraParams(const std::string & keyValueList)425 int32_t AudioRenderInterfaceImpl::SetExtraParams(const std::string &keyValueList)
426 {
427 DHLOGI("Set extra parameters, not support yet.");
428 (void)keyValueList;
429 return HDF_SUCCESS;
430 }
431
GetExtraParams(std::string & keyValueList)432 int32_t AudioRenderInterfaceImpl::GetExtraParams(std::string &keyValueList)
433 {
434 DHLOGI("Get extra parameters, not support yet.");
435 (void)keyValueList;
436 return HDF_SUCCESS;
437 }
438
439 #ifdef DAUDIO_SUPPORT_SHARED_BUFFER
CreateAshmem(int32_t ashmemLength)440 int32_t AudioRenderInterfaceImpl::CreateAshmem(int32_t ashmemLength)
441 {
442 const std::string memory_name = "Normal Render";
443 if (ashmemLength < DAUDIO_MIN_ASHMEM_LEN || ashmemLength > DAUDIO_MAX_ASHMEM_LEN) {
444 DHLOGE("The length of shared memory is illegal.");
445 return HDF_FAILURE;
446 }
447 ashmem_ = OHOS::Ashmem::CreateAshmem(memory_name.c_str(), ashmemLength);
448 if (ashmem_ == nullptr) {
449 DHLOGE("Create ashmem failed.");
450 return HDF_FAILURE;
451 }
452 bool ret = ashmem_->MapReadAndWriteAshmem();
453 if (ret != true) {
454 DHLOGE("Mmap ashmem failed.");
455 return HDF_FAILURE;
456 }
457 fd_ = ashmem_->GetAshmemFd();
458 DHLOGI("Init Ashmem success, fd: %{public}d, length: %{public}d", fd_, ashmemLength);
459 return HDF_SUCCESS;
460 }
461
WriteToShmem(const AudioData & data)462 int32_t AudioRenderInterfaceImpl::WriteToShmem(const AudioData &data)
463 {
464 DHLOGD("Write to shared memory.");
465 if (ashmem_ == nullptr) {
466 DHLOGE("Share memory is null");
467 return HDF_FAILURE;
468 }
469 if (data.param.frameSize != static_cast<uint32_t>(lengthPerTrans_)) {
470 DHLOGE("The param:framsize is invalid.");
471 return HDF_FAILURE;
472 }
473 const auto &audioData = data.data;
474 bool writeRet = ashmem_->WriteToAshmem(audioData.data(), audioData.size(), writeIndex_);
475 if (writeRet) {
476 DHLOGD("Write to ashmem success! write index: %{public}d, writeLength: %{public}d.",
477 writeIndex_, lengthPerTrans_);
478 } else {
479 DHLOGE("Write data to ashmem failed.");
480 }
481 writeIndex_ += lengthPerTrans_;
482 if (writeIndex_ >= ashmemLength_) {
483 writeIndex_ = 0;
484 }
485 writeNum_ += CalculateSampleNum(devAttrs_.sampleRate, timeInterval_);
486 return HDF_SUCCESS;
487 }
488
NotifyFirstChangeEvent(EXT_PARAM_EVENT evetType)489 int32_t AudioRenderInterfaceImpl::NotifyFirstChangeEvent(EXT_PARAM_EVENT evetType)
490 {
491 if (audioExtCallback_ == nullptr) {
492 DHLOGE("Ext callback is null.");
493 return HDF_FAILURE;
494 }
495 std::string content;
496 std::initializer_list<std::pair<std::string, std::string>> items = { {KEY_DH_ID, std::to_string(devDesc_.pins)} };
497 if (WrapCJsonItem(items, content) != HDF_SUCCESS) {
498 DHLOGE("Wrap the event failed.");
499 return HDF_FAILURE;
500 }
501 DAudioEvent event = { evetType, content };
502 int32_t ret = audioExtCallback_->NotifyEvent(renderId_, event);
503 if (ret != HDF_SUCCESS) {
504 DHLOGE("Start render mmap failed.");
505 return HDF_FAILURE;
506 }
507 return HDF_SUCCESS;
508 }
509 #endif
510
ReqMmapBuffer(int32_t reqSize,AudioMmapBufferDescriptor & desc)511 int32_t AudioRenderInterfaceImpl::ReqMmapBuffer(int32_t reqSize, AudioMmapBufferDescriptor &desc)
512 {
513 #ifdef DAUDIO_SUPPORT_SHARED_BUFFER
514 DHLOGI("Request mmap buffer.");
515 int32_t minSize = CalculateSampleNum(devAttrs_.sampleRate, minTimeInterval_);
516 int32_t maxSize = CalculateSampleNum(devAttrs_.sampleRate, maxTimeInterval_);
517 int32_t realSize = reqSize;
518 if (reqSize < minSize) {
519 realSize = minSize;
520 } else if (reqSize > maxSize) {
521 realSize = maxSize;
522 }
523 DHLOGI("ReqMmap buffer realsize : %{public}d, minsize: %{public}d, maxsize:%{public}d.",
524 realSize, minSize, maxSize);
525 desc.totalBufferFrames = realSize;
526 ashmemLength_ = realSize * static_cast<int32_t>(devAttrs_.channelCount) * devAttrs_.format;
527 DHLOGI("Init ashmem real sample size : %{public}d, length: %{public}d.", realSize, ashmemLength_);
528 int32_t ret = CreateAshmem(ashmemLength_);
529 if (ret != HDF_SUCCESS) {
530 DHLOGE("Init ashmem error..");
531 return HDF_FAILURE;
532 }
533 desc.memoryFd = fd_;
534 desc.transferFrameSize = static_cast<int32_t>(CalculateSampleNum(devAttrs_.sampleRate, timeInterval_));
535 lengthPerTrans_ = desc.transferFrameSize * static_cast<int32_t>(devAttrs_.channelCount) * devAttrs_.format;
536 desc.isShareable = false;
537 if (audioExtCallback_ == nullptr) {
538 DHLOGE("Callback is nullptr.");
539 return HDF_FAILURE;
540 }
541 ret = audioExtCallback_->RefreshAshmemInfo(renderId_, fd_, ashmemLength_, lengthPerTrans_);
542 if (ret != HDF_SUCCESS) {
543 DHLOGE("Refresh ashmem info failed.");
544 return HDF_FAILURE;
545 }
546 #else
547 DHLOGI("Request mmap buffer, not support yet.");
548 (void)reqSize;
549 (void)desc;
550 #endif
551 return HDF_SUCCESS;
552 }
553
GetMmapPosition(uint64_t & frames,AudioTimeStamp & time)554 int32_t AudioRenderInterfaceImpl::GetMmapPosition(uint64_t &frames, AudioTimeStamp &time)
555 {
556 DHLOGI("Get mmap position, not support yet.");
557 (void)frames;
558 (void)time;
559 return HDF_SUCCESS;
560 }
561
AddAudioEffect(uint64_t effectid)562 int32_t AudioRenderInterfaceImpl::AddAudioEffect(uint64_t effectid)
563 {
564 DHLOGI("Add audio effect, not support yet.");
565 (void)effectid;
566 return HDF_SUCCESS;
567 }
568
RemoveAudioEffect(uint64_t effectid)569 int32_t AudioRenderInterfaceImpl::RemoveAudioEffect(uint64_t effectid)
570 {
571 DHLOGI("Remove audio effect, not support yet.");
572 (void)effectid;
573 return HDF_SUCCESS;
574 }
575
GetFrameBufferSize(uint64_t & bufferSize)576 int32_t AudioRenderInterfaceImpl::GetFrameBufferSize(uint64_t &bufferSize)
577 {
578 DHLOGI("Get frame buffer size, not support yet.");
579 (void)bufferSize;
580 return HDF_SUCCESS;
581 }
582
GetRenderDesc()583 const AudioDeviceDescriptor &AudioRenderInterfaceImpl::GetRenderDesc()
584 {
585 return devDesc_;
586 }
587
SetVolumeInner(const uint32_t vol)588 void AudioRenderInterfaceImpl::SetVolumeInner(const uint32_t vol)
589 {
590 std::lock_guard<std::mutex> volLck(volMtx_);
591 vol_ = vol;
592 }
593
SetVolumeRangeInner(const uint32_t volMax,const uint32_t volMin)594 void AudioRenderInterfaceImpl::SetVolumeRangeInner(const uint32_t volMax, const uint32_t volMin)
595 {
596 std::lock_guard<std::mutex> volLck(volMtx_);
597 volMin_ = volMin;
598 volMax_ = volMax;
599 }
600
GetVolumeInner()601 uint32_t AudioRenderInterfaceImpl::GetVolumeInner()
602 {
603 std::lock_guard<std::mutex> volLck(volMtx_);
604 return vol_;
605 }
606
GetMaxVolumeInner()607 uint32_t AudioRenderInterfaceImpl::GetMaxVolumeInner()
608 {
609 std::lock_guard<std::mutex> volLck(volMtx_);
610 return volMax_;
611 }
612
GetMinVolumeInner()613 uint32_t AudioRenderInterfaceImpl::GetMinVolumeInner()
614 {
615 std::lock_guard<std::mutex> volLck(volMtx_);
616 return volMin_;
617 }
618
SetAttrs(const std::string & adpName,const AudioDeviceDescriptor & desc,const AudioSampleAttributes & attrs,const sptr<IDAudioCallback> & callback,const int32_t dhId)619 void AudioRenderInterfaceImpl::SetAttrs(const std::string &adpName, const AudioDeviceDescriptor &desc,
620 const AudioSampleAttributes &attrs, const sptr<IDAudioCallback> &callback, const int32_t dhId)
621 {
622 DHLOGI("Set attrs, not support yet.");
623 }
624
SetDumpFlagInner()625 void AudioRenderInterfaceImpl::SetDumpFlagInner()
626 {
627 dumpFlag_ = true;
628 }
629 } // V1_0
630 } // Audio
631 } // Distributedaudio
632 } // HDI
633 } // OHOS
634