1 /*
2 * Copyright (c) 2022-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
16 #include "audio_capture_interface_impl.h"
17
18 #include <hdf_base.h>
19 #include <unistd.h>
20 #include "sys/time.h"
21 #include <securec.h>
22
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 "AudioCaptureInterfaceImpl"
30
31 using namespace OHOS::DistributedHardware;
32 namespace OHOS {
33 namespace HDI {
34 namespace DistributedAudio {
35 namespace Audio {
36 namespace V1_0 {
AudioCaptureInterfaceImpl(const std::string & adpName,const AudioDeviceDescriptor & desc,const AudioSampleAttributes & attrs,const sptr<IDAudioCallback> & callback)37 AudioCaptureInterfaceImpl::AudioCaptureInterfaceImpl(const std::string &adpName, const AudioDeviceDescriptor &desc,
38 const AudioSampleAttributes &attrs, const sptr<IDAudioCallback> &callback)
39 : adapterName_(adpName), devDesc_(desc),
40 devAttrs_(attrs), audioExtCallback_(callback)
41 {
42 devAttrs_.frameSize = CalculateFrameSize(attrs.sampleRate, attrs.channelCount, attrs.format, timeInterval_, false);
43 const int32_t sizePerSec = static_cast<int32_t>(attrs.sampleRate * attrs.channelCount) *attrs.format;
44 framePeriodNs_ = (static_cast<int64_t>(devAttrs_.frameSize) * AUDIO_NS_PER_SECOND) / sizePerSec;
45 DHLOGD("Distributed audio capture constructed, period(%d),frameSize(%d), framePeriodNs_(%d).",
46 attrs.period, devAttrs_.frameSize, framePeriodNs_);
47 DHLOGD("Distributed audio capture constructed, id(%d).", desc.pins);
48 }
49
~AudioCaptureInterfaceImpl()50 AudioCaptureInterfaceImpl::~AudioCaptureInterfaceImpl()
51 {
52 DHLOGD("Distributed audio capture destructed, id(%d).", devDesc_.pins);
53 }
54
GetCapturePosition(uint64_t & frames,AudioTimeStamp & time)55 int32_t AudioCaptureInterfaceImpl::GetCapturePosition(uint64_t &frames, AudioTimeStamp &time)
56 {
57 DHLOGI("Get capture position, not support yet.");
58 (void)frames;
59 (void)time;
60 return HDF_SUCCESS;
61 }
62
CaptureFrame(std::vector<int8_t> & frame,uint64_t requestBytes)63 int32_t AudioCaptureInterfaceImpl::CaptureFrame(std::vector<int8_t> &frame, uint64_t requestBytes)
64 {
65 DHLOGD("Capture frame[sampleRate: %d, channelCount: %d, format: %d, frameSize: %d].", devAttrs_.sampleRate,
66 devAttrs_.channelCount, devAttrs_.format, devAttrs_.frameSize);
67 int64_t timeOffset = UpdateTimeOffset(frameIndex_, framePeriodNs_, startTime_);
68 DHLOGD("Capture framIndex: %lld, timeOffset: %lld.", frameIndex_, timeOffset);
69
70 std::lock_guard<std::mutex> captureLck(captureMtx_);
71 if (captureStatus_ != CAPTURE_STATUS_START) {
72 DHLOGE("Capture status wrong, return false.");
73 return HDF_FAILURE;
74 }
75 if (audioExtCallback_ == nullptr) {
76 DHLOGE("Callback is nullptr.");
77 return HDF_FAILURE;
78 }
79
80 AudioData audioData;
81 int32_t ret = audioExtCallback_->ReadStreamData(adapterName_, devDesc_.pins, audioData);
82 if (ret != HDF_SUCCESS) {
83 DHLOGE("Read stream data failed.");
84 return HDF_FAILURE;
85 }
86
87 frame.resize(devAttrs_.frameSize);
88 ret = memcpy_s(frame.data(), frame.size(), audioData.data.data(), audioData.data.size());
89 if (ret != EOK) {
90 DHLOGE("Copy capture frame failed, error code %d.", ret);
91 return HDF_FAILURE;
92 }
93 ++frameIndex_;
94 AbsoluteSleep(startTime_ + frameIndex_ * framePeriodNs_ - timeOffset);
95 DHLOGD("Capture audio frame success.");
96 return HDF_SUCCESS;
97 }
98
Start()99 int32_t AudioCaptureInterfaceImpl::Start()
100 {
101 DHLOGI("Start capture.");
102 DAudioEvent event = { HDF_AUDIO_EVENT_START, "" };
103 if (audioExtCallback_ == nullptr) {
104 DHLOGE("Callback is nullptr.");
105 return HDF_FAILURE;
106 }
107 if (audioExtCallback_->NotifyEvent(adapterName_, devDesc_.pins, event) != HDF_SUCCESS) {
108 DHLOGE("Notify start event failed.");
109 return HDF_FAILURE;
110 }
111 std::lock_guard<std::mutex> captureLck(captureMtx_);
112 captureStatus_ = CAPTURE_STATUS_START;
113 frameIndex_ = 0;
114 startTime_ = 0;
115 return HDF_SUCCESS;
116 }
117
Stop()118 int32_t AudioCaptureInterfaceImpl::Stop()
119 {
120 DHLOGI("Stop capture.");
121 DAudioEvent event = { HDF_AUDIO_EVENT_STOP, "" };
122 if (audioExtCallback_ == nullptr) {
123 DHLOGE("Callback is nullptr.");
124 return HDF_FAILURE;
125 }
126 if (audioExtCallback_->NotifyEvent(adapterName_, devDesc_.pins, event) != HDF_SUCCESS) {
127 DHLOGE("Notify stop event failed.");
128 return HDF_FAILURE;
129 }
130 std::lock_guard<std::mutex> captureLck(captureMtx_);
131 captureStatus_ = CAPTURE_STATUS_STOP;
132 return HDF_SUCCESS;
133 }
134
Pause()135 int32_t AudioCaptureInterfaceImpl::Pause()
136 {
137 DHLOGI("Pause capture.");
138 std::lock_guard<std::mutex> captureLck(captureMtx_);
139 captureStatus_ = CAPTURE_STATUS_PAUSE;
140 return HDF_SUCCESS;
141 }
142
Resume()143 int32_t AudioCaptureInterfaceImpl::Resume()
144 {
145 return HDF_SUCCESS;
146 }
147
Flush()148 int32_t AudioCaptureInterfaceImpl::Flush()
149 {
150 return HDF_SUCCESS;
151 }
152
TurnStandbyMode()153 int32_t AudioCaptureInterfaceImpl::TurnStandbyMode()
154 {
155 DHLOGI("Turn stand by mode, not support yet.");
156 return HDF_SUCCESS;
157 }
158
AudioDevDump(int32_t range,int32_t fd)159 int32_t AudioCaptureInterfaceImpl::AudioDevDump(int32_t range, int32_t fd)
160 {
161 DHLOGI("Dump audio info, not support yet.");
162 (void)range;
163 (void)fd;
164 return HDF_SUCCESS;
165 }
166
IsSupportsPauseAndResume(bool & supportPause,bool & supportResume)167 int32_t AudioCaptureInterfaceImpl::IsSupportsPauseAndResume(bool &supportPause, bool &supportResume)
168 {
169 DHLOGI("Check whether pause and resume is supported, not support yet.");
170 (void)supportPause;
171 (void)supportResume;
172 return HDF_SUCCESS;
173 }
174
CheckSceneCapability(const AudioSceneDescriptor & scene,bool & supported)175 int32_t AudioCaptureInterfaceImpl::CheckSceneCapability(const AudioSceneDescriptor &scene, bool &supported)
176 {
177 DHLOGI("Check scene capability.");
178 (void)scene;
179 supported = false;
180 return HDF_SUCCESS;
181 }
182
SelectScene(const AudioSceneDescriptor & scene)183 int32_t AudioCaptureInterfaceImpl::SelectScene(const AudioSceneDescriptor &scene)
184 {
185 DHLOGI("Select audio scene, not support yet.");
186 (void)scene;
187 return HDF_SUCCESS;
188 }
189
SetMute(bool mute)190 int32_t AudioCaptureInterfaceImpl::SetMute(bool mute)
191 {
192 DHLOGI("Set mute, not support yet.");
193 (void)mute;
194 return HDF_SUCCESS;
195 }
196
GetMute(bool & mute)197 int32_t AudioCaptureInterfaceImpl::GetMute(bool &mute)
198 {
199 DHLOGI("Get mute, not support yet.");
200 (void)mute;
201 return HDF_SUCCESS;
202 }
203
SetVolume(float volume)204 int32_t AudioCaptureInterfaceImpl::SetVolume(float volume)
205 {
206 DHLOGI("Can not set vol not by this interface.");
207 (void)volume;
208 return HDF_SUCCESS;
209 }
210
GetVolume(float & volume)211 int32_t AudioCaptureInterfaceImpl::GetVolume(float &volume)
212 {
213 DHLOGI("Can not get vol not by this interface.");
214 (void)volume;
215 return HDF_SUCCESS;
216 }
217
GetGainThreshold(float & min,float & max)218 int32_t AudioCaptureInterfaceImpl::GetGainThreshold(float &min, float &max)
219 {
220 DHLOGI("Get gain threshold, not support yet.");
221 min = 0;
222 max = 0;
223 return HDF_SUCCESS;
224 }
225
SetGain(float gain)226 int32_t AudioCaptureInterfaceImpl::SetGain(float gain)
227 {
228 DHLOGI("Set gain, not support yet.");
229 (void)gain;
230 return HDF_SUCCESS;
231 }
232
GetGain(float & gain)233 int32_t AudioCaptureInterfaceImpl::GetGain(float &gain)
234 {
235 DHLOGI("Get gain, not support yet.");
236 gain = 1.0;
237 return HDF_SUCCESS;
238 }
239
GetFrameSize(uint64_t & size)240 int32_t AudioCaptureInterfaceImpl::GetFrameSize(uint64_t &size)
241 {
242 (void)size;
243 return HDF_SUCCESS;
244 }
245
GetFrameCount(uint64_t & count)246 int32_t AudioCaptureInterfaceImpl::GetFrameCount(uint64_t &count)
247 {
248 (void)count;
249 return HDF_SUCCESS;
250 }
251
SetSampleAttributes(const AudioSampleAttributes & attrs)252 int32_t AudioCaptureInterfaceImpl::SetSampleAttributes(const AudioSampleAttributes &attrs)
253 {
254 DHLOGI("Set sample attributes.");
255 devAttrs_ = attrs;
256 return HDF_SUCCESS;
257 }
258
GetSampleAttributes(AudioSampleAttributes & attrs)259 int32_t AudioCaptureInterfaceImpl::GetSampleAttributes(AudioSampleAttributes &attrs)
260 {
261 DHLOGI("Get sample attributes.");
262 attrs = devAttrs_;
263 return HDF_SUCCESS;
264 }
265
GetCurrentChannelId(uint32_t & channelId)266 int32_t AudioCaptureInterfaceImpl::GetCurrentChannelId(uint32_t &channelId)
267 {
268 DHLOGI("Get current channel id, not support yet.");
269 (void)channelId;
270 return HDF_SUCCESS;
271 }
272
SetExtraParams(const std::string & keyValueList)273 int32_t AudioCaptureInterfaceImpl::SetExtraParams(const std::string &keyValueList)
274 {
275 DHLOGI("Set extra parameters, not support yet.");
276 (void)keyValueList;
277 return HDF_SUCCESS;
278 }
279
GetExtraParams(std::string & keyValueList)280 int32_t AudioCaptureInterfaceImpl::GetExtraParams(std::string &keyValueList)
281 {
282 DHLOGI("Get extra parameters, not support yet.");
283 (void)keyValueList;
284 return HDF_SUCCESS;
285 }
286
ReqMmapBuffer(int32_t reqSize,AudioMmapBufferDescriptor & desc)287 int32_t AudioCaptureInterfaceImpl::ReqMmapBuffer(int32_t reqSize, AudioMmapBufferDescriptor &desc)
288 {
289 DHLOGI("Request mmap buffer, not support yet.");
290 (void)reqSize;
291 (void)desc;
292 return HDF_SUCCESS;
293 }
294
GetMmapPosition(uint64_t & frames,AudioTimeStamp & time)295 int32_t AudioCaptureInterfaceImpl::GetMmapPosition(uint64_t &frames, AudioTimeStamp &time)
296 {
297 DHLOGI("Get mmap position, not support yet.");
298 (void)frames;
299 (void)time;
300 return HDF_SUCCESS;
301 }
302
AddAudioEffect(uint64_t effectid)303 int32_t AudioCaptureInterfaceImpl::AddAudioEffect(uint64_t effectid)
304 {
305 DHLOGI("Add audio effect, not support yet.");
306 (void)effectid;
307 return HDF_SUCCESS;
308 }
309
RemoveAudioEffect(uint64_t effectid)310 int32_t AudioCaptureInterfaceImpl::RemoveAudioEffect(uint64_t effectid)
311 {
312 DHLOGI("Remove audio effect, not support yet.");
313 (void)effectid;
314 return HDF_SUCCESS;
315 }
316
GetFrameBufferSize(uint64_t & bufferSize)317 int32_t AudioCaptureInterfaceImpl::GetFrameBufferSize(uint64_t &bufferSize)
318 {
319 DHLOGI("Get frame buffer size, not support yet.");
320 (void)bufferSize;
321 return HDF_SUCCESS;
322 }
323
SetAttrs(const std::string & adpName,const AudioDeviceDescriptor & desc,const AudioSampleAttributes & attrs,const sptr<IDAudioCallback> & callback)324 void AudioCaptureInterfaceImpl::SetAttrs(const std::string &adpName, const AudioDeviceDescriptor &desc,
325 const AudioSampleAttributes &attrs, const sptr<IDAudioCallback> &callback)
326 {
327 DHLOGI("Set attrs, not support yet.");
328 }
329
GetCaptureDesc()330 const AudioDeviceDescriptor &AudioCaptureInterfaceImpl::GetCaptureDesc()
331 {
332 return devDesc_;
333 }
334 } // V1_0
335 } // Audio
336 } // Distributedaudio
337 } // HDI
338 } // OHOS
339