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