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
16 #include <string>
17 #include <cinttypes>
18 #include "power_mgr_client.h"
19 #include "running_lock.h"
20
21 #include "audio_errors.h"
22 #include "audio_log.h"
23 #include "audio_utils.h"
24
25 #include "v1_0/iaudio_manager.h"
26 #include "fast_audio_capturer_source.h"
27
28 using namespace std;
29
30 namespace OHOS {
31 namespace AudioStandard {
32 class FastAudioCapturerSourceInner : public FastAudioCapturerSource {
33 public:
34 int32_t Init(IAudioSourceAttr &attr) override;
35 bool IsInited(void) override;
36 void DeInit(void) override;
37
38 int32_t Start(void) override;
39 int32_t Stop(void) override;
40 int32_t Flush(void) override;
41 int32_t Reset(void) override;
42 int32_t Pause(void) override;
43 int32_t Resume(void) override;
44 int32_t CaptureFrame(char *frame, uint64_t requestBytes, uint64_t &replyBytes) override;
45 int32_t SetVolume(float left, float right) override;
46 int32_t GetVolume(float &left, float &right) override;
47 int32_t SetMute(bool isMute) override;
48 int32_t GetMute(bool &isMute) override;
49
50 int32_t SetAudioScene(AudioScene audioScene, DeviceType activeDevice) override;
51
52 int32_t SetInputRoute(DeviceType inputDevice, AudioPortPin &inputPortPin);
53
54 int32_t SetInputRoute(DeviceType inputDevice) override;
55
56 uint64_t GetTransactionId() override;
57 void RegisterWakeupCloseCallback(IAudioSourceCallback* callback) override;
58 void RegisterAudioCapturerSourceCallback(IAudioSourceCallback* callback) override;
59
60 int32_t GetMmapBufferInfo(int &fd, uint32_t &totalSizeInframe, uint32_t &spanSizeInframe,
61 uint32_t &byteSizePerFrame) override;
62 int32_t GetMmapHandlePosition(uint64_t &frames, int64_t &timeSec, int64_t &timeNanoSec) override;
63
64 FastAudioCapturerSourceInner();
65 ~FastAudioCapturerSourceInner() override;
66 private:
67 static constexpr int32_t INVALID_FD = -1;
68 static constexpr int32_t HALF_FACTOR = 2;
69 static constexpr uint32_t MAX_AUDIO_ADAPTER_NUM = 5;
70 static constexpr float MAX_VOLUME_LEVEL = 15.0f;
71 static constexpr int64_t SECOND_TO_NANOSECOND = 1000000000;
72 static constexpr uint32_t PCM_8_BIT = 8;
73 static constexpr uint32_t PCM_16_BIT = 16;
74 static constexpr uint32_t PCM_24_BIT = 24;
75 static constexpr uint32_t PCM_32_BIT = 32;
76 static constexpr uint32_t AUDIO_CHANNELCOUNT = 2;
77 static constexpr uint32_t AUDIO_SAMPLE_RATE_48K = 48000;
78 static constexpr uint32_t INT_32_MAX = 0x7fffffff;
79 static constexpr uint32_t FAST_INPUT_STREAM_ID = 22; // 14 + 1 * 8
80
81 IAudioSourceAttr attr_;
82 bool capturerInited_;
83 bool started_;
84 bool paused_;
85
86 uint32_t captureId_ = 0;
87 uint32_t openMic_;
88 std::string adapterNameCase_;
89 struct IAudioManager *audioManager_ = nullptr;
90 struct IAudioAdapter *audioAdapter_ = nullptr;
91 struct IAudioCapture *audioCapture_ = nullptr;
92 struct AudioAdapterDescriptor adapterDesc_;
93 struct AudioPort audioPort;
94
95 size_t bufferSize_ = 0;
96 uint32_t bufferTotalFrameSize_ = 0;
97
98 int bufferFd_ = INVALID_FD;
99 uint32_t eachReadFrameSize_ = 0;
100
101 std::shared_ptr<PowerMgr::RunningLock> keepRunningLock_;
102 private:
103 void InitAttrsCapture(struct AudioSampleAttributes &attrs);
104 int32_t SwitchAdapterCapture(struct AudioAdapterDescriptor *descs, uint32_t size,
105 const std::string &adapterNameCase, enum AudioPortDirection portFlag, struct AudioPort &capturePort);
106 int32_t CreateCapture(const struct AudioPort &capturePort);
107 int32_t PrepareMmapBuffer();
108 int32_t InitAudioManager();
109 uint32_t PcmFormatToBits(AudioSampleFormat format);
110 AudioFormat ConverToHdiFormat(AudioSampleFormat format);
111 int32_t CheckPositionTime();
112 };
113
114 constexpr int32_t RUNNINGLOCK_LOCK_TIMEOUTMS_LASTING = -1;
115
FastAudioCapturerSourceInner()116 FastAudioCapturerSourceInner::FastAudioCapturerSourceInner() : attr_({}), capturerInited_(false), started_(false),
117 paused_(false), openMic_(0), audioManager_(nullptr), audioAdapter_(nullptr), audioCapture_(nullptr)
118 {}
119
~FastAudioCapturerSourceInner()120 FastAudioCapturerSourceInner::~FastAudioCapturerSourceInner()
121 {
122 AUDIO_ERR_LOG("~FastAudioCapturerSourceInner");
123 }
GetInstance()124 FastAudioCapturerSource *FastAudioCapturerSource::GetInstance()
125 {
126 static FastAudioCapturerSourceInner audioCapturer;
127 return &audioCapturer;
128 }
129
IsInited(void)130 bool FastAudioCapturerSourceInner::IsInited(void)
131 {
132 return capturerInited_;
133 }
134
DeInit()135 void FastAudioCapturerSourceInner::DeInit()
136 {
137 started_ = false;
138 capturerInited_ = false;
139
140 if (audioAdapter_ != nullptr) {
141 audioAdapter_->DestroyCapture(audioAdapter_, captureId_);
142 }
143 audioCapture_ = nullptr;
144
145 if (audioManager_ != nullptr) {
146 audioManager_->UnloadAdapter(audioManager_, adapterDesc_.adapterName);
147 }
148 audioAdapter_ = nullptr;
149 audioManager_ = nullptr;
150 }
151
InitAttrsCapture(struct AudioSampleAttributes & attrs)152 void FastAudioCapturerSourceInner::InitAttrsCapture(struct AudioSampleAttributes &attrs)
153 {
154 /* Initialization of audio parameters for playback */
155 attrs.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
156 attrs.channelCount = AUDIO_CHANNELCOUNT;
157 attrs.sampleRate = AUDIO_SAMPLE_RATE_48K;
158 attrs.interleaved = true;
159 attrs.streamId = FAST_INPUT_STREAM_ID;
160 attrs.type = AUDIO_MMAP_NOIRQ; // enable mmap!
161 attrs.period = 0;
162 attrs.frameSize = PCM_16_BIT * attrs.channelCount / PCM_8_BIT;
163 attrs.isBigEndian = false;
164 attrs.isSignedData = true;
165 attrs.startThreshold = 0;
166 attrs.stopThreshold = INT_32_MAX;
167 /* 16 * 1024 */
168 attrs.silenceThreshold = 0;
169 }
170
SwitchAdapterCapture(struct AudioAdapterDescriptor * descs,uint32_t size,const std::string & adapterNameCase,enum AudioPortDirection portFlag,struct AudioPort & capturePort)171 int32_t FastAudioCapturerSourceInner::SwitchAdapterCapture(struct AudioAdapterDescriptor *descs, uint32_t size,
172 const std::string &adapterNameCase, enum AudioPortDirection portFlag, struct AudioPort &capturePort)
173 {
174 if (descs == nullptr) {
175 return ERROR;
176 }
177
178 for (uint32_t index = 0; index < size; index++) {
179 struct AudioAdapterDescriptor *desc = &descs[index];
180 if (desc == nullptr || desc->adapterName == nullptr) {
181 continue;
182 }
183 if (adapterNameCase.compare(desc->adapterName) != 0) {
184 AUDIO_WARNING_LOG("not equal: %{public}s <-> %{public}s", adapterNameCase.c_str(), desc->adapterName);
185 continue;
186 }
187 AUDIO_INFO_LOG("adapter name: %{public}s <-> %{public}s", adapterNameCase.c_str(), desc->adapterName);
188 for (uint32_t port = 0; port < desc->portsLen; port++) {
189 // Only find out the port of out in the sound card
190 if (desc->ports[port].dir == portFlag) {
191 capturePort = desc->ports[port];
192 return index;
193 }
194 }
195 }
196 AUDIO_ERR_LOG("SwitchAdapterCapture Fail");
197
198 return ERR_INVALID_INDEX;
199 }
200
InitAudioManager()201 int32_t FastAudioCapturerSourceInner::InitAudioManager()
202 {
203 AUDIO_INFO_LOG("FastAudioCapturerSourceInner: Initialize audio proxy manager");
204
205 audioManager_ = IAudioManagerGet(false);
206 if (audioManager_ == nullptr) {
207 return ERR_INVALID_HANDLE;
208 }
209
210 return 0;
211 }
212
213
ConverToHdiFormat(AudioSampleFormat format)214 AudioFormat FastAudioCapturerSourceInner::ConverToHdiFormat(AudioSampleFormat format)
215 {
216 AudioFormat hdiFormat;
217 switch (format) {
218 case SAMPLE_U8:
219 hdiFormat = AUDIO_FORMAT_TYPE_PCM_8_BIT;
220 break;
221 case SAMPLE_S16LE:
222 hdiFormat = AUDIO_FORMAT_TYPE_PCM_16_BIT;
223 break;
224 case SAMPLE_S24LE:
225 hdiFormat = AUDIO_FORMAT_TYPE_PCM_24_BIT;
226 break;
227 case SAMPLE_S32LE:
228 hdiFormat = AUDIO_FORMAT_TYPE_PCM_32_BIT;
229 break;
230 default:
231 hdiFormat = AUDIO_FORMAT_TYPE_PCM_16_BIT;
232 break;
233 }
234
235 return hdiFormat;
236 }
237
CreateCapture(const struct AudioPort & capturePort)238 int32_t FastAudioCapturerSourceInner::CreateCapture(const struct AudioPort &capturePort)
239 {
240 int32_t ret;
241 struct AudioSampleAttributes param;
242 // User needs to set
243 InitAttrsCapture(param);
244 param.sampleRate = attr_.sampleRate;
245 param.format = ConverToHdiFormat(attr_.format);
246 param.isBigEndian = attr_.isBigEndian;
247 param.channelCount = attr_.channel;
248 param.silenceThreshold = attr_.bufferSize;
249 param.frameSize = param.format * param.channelCount;
250 param.startThreshold = 0;
251
252 struct AudioDeviceDescriptor deviceDesc;
253 deviceDesc.portId = capturePort.portId;
254 deviceDesc.pins = PIN_IN_MIC;
255 char desc[] = "";
256 deviceDesc.desc = desc;
257
258 ret = audioAdapter_->CreateCapture(audioAdapter_, &deviceDesc, ¶m, &audioCapture_, &captureId_);
259 if (audioCapture_ == nullptr || ret < 0) {
260 AUDIO_ERR_LOG("Create capture failed");
261 return ERR_NOT_STARTED;
262 }
263
264 return 0;
265 }
266
PcmFormatToBits(AudioSampleFormat format)267 uint32_t FastAudioCapturerSourceInner::PcmFormatToBits(AudioSampleFormat format)
268 {
269 switch (format) {
270 case SAMPLE_U8:
271 return PCM_8_BIT;
272 case SAMPLE_S16LE:
273 return PCM_16_BIT;
274 case SAMPLE_S24LE:
275 return PCM_24_BIT;
276 case SAMPLE_S32LE:
277 return PCM_32_BIT;
278 case SAMPLE_F32LE:
279 return PCM_32_BIT;
280 default:
281 return PCM_24_BIT;
282 }
283 }
GetMmapBufferInfo(int & fd,uint32_t & totalSizeInframe,uint32_t & spanSizeInframe,uint32_t & byteSizePerFrame)284 int32_t FastAudioCapturerSourceInner::GetMmapBufferInfo(int &fd, uint32_t &totalSizeInframe, uint32_t &spanSizeInframe,
285 uint32_t &byteSizePerFrame)
286 {
287 if (bufferFd_ == INVALID_FD) {
288 AUDIO_ERR_LOG("buffer fd has been released!");
289 return ERR_INVALID_HANDLE;
290 }
291 fd = bufferFd_;
292 totalSizeInframe = bufferTotalFrameSize_;
293 spanSizeInframe = eachReadFrameSize_;
294 byteSizePerFrame = PcmFormatToBits(attr_.format) * attr_.channel / PCM_8_BIT;
295 return SUCCESS;
296 }
297
GetMmapHandlePosition(uint64_t & frames,int64_t & timeSec,int64_t & timeNanoSec)298 int32_t FastAudioCapturerSourceInner::GetMmapHandlePosition(uint64_t &frames, int64_t &timeSec, int64_t &timeNanoSec)
299 {
300 if (audioCapture_ == nullptr) {
301 AUDIO_ERR_LOG("Audio render is null!");
302 return ERR_INVALID_HANDLE;
303 }
304
305 struct AudioTimeStamp timestamp = {};
306 int32_t ret = audioCapture_->GetMmapPosition(audioCapture_, &frames, ×tamp);
307 if (ret != 0) {
308 AUDIO_ERR_LOG("Hdi GetMmapPosition filed, ret:%{public}d!", ret);
309 return ERR_OPERATION_FAILED;
310 }
311
312 int64_t maxSec = 9223372036; // (9223372036 + 1) * 10^9 > INT64_MAX, seconds should not bigger than it.
313 if (timestamp.tvSec < 0 || timestamp.tvSec > maxSec || timestamp.tvNSec < 0 ||
314 timestamp.tvNSec > SECOND_TO_NANOSECOND) {
315 AUDIO_ERR_LOG("Hdi GetMmapPosition get invaild second:%{public}" PRId64 " or nanosecond:%{public}" PRId64 " !",
316 timestamp.tvSec, timestamp.tvNSec);
317 return ERR_OPERATION_FAILED;
318 }
319 timeSec = timestamp.tvSec;
320 timeNanoSec = timestamp.tvNSec;
321
322 return SUCCESS;
323 }
324
PrepareMmapBuffer()325 int32_t FastAudioCapturerSourceInner::PrepareMmapBuffer()
326 {
327 int32_t totalBifferInMs = 40; // 5 * (6 + 2 * (1)) = 40ms, the buffer size, not latency.
328 uint32_t frameSizeInByte = PcmFormatToBits(attr_.format) * attr_.channel / PCM_8_BIT;
329 int32_t reqBufferFrameSize = totalBifferInMs * (attr_.sampleRate / 1000);
330
331 struct AudioMmapBufferDescriptor desc = {0};
332 int32_t ret = audioCapture_->ReqMmapBuffer(audioCapture_, reqBufferFrameSize, &desc);
333 if (ret != 0) {
334 AUDIO_ERR_LOG("ReqMmapBuffer failed, ret:%{public}d", ret);
335 return ERR_OPERATION_FAILED;
336 }
337 AUDIO_INFO_LOG("AudioMmapBufferDescriptor memoryAddress[%{private}p] memoryFd[%{public}d] totalBufferFrames"
338 "[%{public}d] transferFrameSize[%{public}d] isShareable[%{public}d] offset[%{public}d]", desc.memoryAddress,
339 desc.memoryFd, desc.totalBufferFrames, desc.transferFrameSize, desc.isShareable, desc.offset);
340
341 bufferFd_ = desc.memoryFd; // fcntl(fd, 1030,3) after dup?
342 int32_t periodFrameMaxSize = 1920000; // 192khz * 10s
343 if (desc.totalBufferFrames < 0 || desc.transferFrameSize < 0 || desc.transferFrameSize > periodFrameMaxSize) {
344 AUDIO_ERR_LOG("ReqMmapBuffer invalid values: totalBufferFrames[%{public}d] transferFrameSize[%{public}d]",
345 desc.totalBufferFrames, desc.transferFrameSize);
346 return ERR_OPERATION_FAILED;
347 }
348 bufferTotalFrameSize_ = desc.totalBufferFrames; // 1440 ~ 3840
349 eachReadFrameSize_ = desc.transferFrameSize; // 240
350
351 if (frameSizeInByte > ULLONG_MAX / bufferTotalFrameSize_) {
352 AUDIO_ERR_LOG("BufferSize will overflow!");
353 return ERR_OPERATION_FAILED;
354 }
355 bufferSize_ = bufferTotalFrameSize_ * frameSizeInByte;
356
357 return SUCCESS;
358 }
359
Init(IAudioSourceAttr & attr)360 int32_t FastAudioCapturerSourceInner::Init(IAudioSourceAttr &attr)
361 {
362 if (InitAudioManager() != 0) {
363 AUDIO_ERR_LOG("Init audio manager Fail");
364 return ERR_INVALID_HANDLE;
365 }
366 attr_ = attr;
367 int32_t ret;
368 int32_t index;
369 uint32_t size = MAX_AUDIO_ADAPTER_NUM;
370 AudioAdapterDescriptor descs[MAX_AUDIO_ADAPTER_NUM];
371 ret = audioManager_->GetAllAdapters(audioManager_, (struct AudioAdapterDescriptor *)&descs, &size);
372 if (size > MAX_AUDIO_ADAPTER_NUM || size == 0 || ret != 0) {
373 AUDIO_ERR_LOG("Get adapters Fail");
374 return ERR_NOT_STARTED;
375 }
376 // Get qualified sound card and port
377 adapterNameCase_ = attr_.adapterName;
378 openMic_ = attr_.open_mic_speaker;
379 index = SwitchAdapterCapture((struct AudioAdapterDescriptor *)&descs, size, adapterNameCase_, PORT_IN, audioPort);
380 if (index < 0) {
381 AUDIO_ERR_LOG("Switch Adapter Capture Fail");
382 return ERR_NOT_STARTED;
383 }
384 adapterDesc_ = descs[index];
385 if (audioManager_->LoadAdapter(audioManager_, &adapterDesc_, &audioAdapter_) != 0) {
386 AUDIO_ERR_LOG("Load Adapter Fail");
387 return ERR_NOT_STARTED;
388 }
389 CHECK_AND_RETURN_RET_LOG(audioAdapter_ != nullptr, ERR_NOT_STARTED, "Load audio device failed");
390
391 // Inittialization port information, can fill through mode and other parameters
392 if (audioAdapter_->InitAllPorts(audioAdapter_) != 0) {
393 AUDIO_ERR_LOG("InitAllPorts failed");
394 return ERR_DEVICE_INIT;
395 }
396 if (CreateCapture(audioPort) != SUCCESS || PrepareMmapBuffer() != SUCCESS) {
397 AUDIO_ERR_LOG("Create capture failed");
398 return ERR_NOT_STARTED;
399 }
400 if (openMic_) {
401 ret = SetInputRoute(DEVICE_TYPE_MIC);
402 if (ret < 0) {
403 AUDIO_ERR_LOG("FastAudioCapturerSourceInner:update route FAILED: %{public}d", ret);
404 }
405 }
406 capturerInited_ = true;
407
408 return SUCCESS;
409 }
410
CaptureFrame(char * frame,uint64_t requestBytes,uint64_t & replyBytes)411 int32_t FastAudioCapturerSourceInner::CaptureFrame(char *frame, uint64_t requestBytes, uint64_t &replyBytes)
412 {
413 AUDIO_ERR_LOG("CaptureFrame in fast mode is not supported!");
414 return ERR_DEVICE_NOT_SUPPORTED;
415 }
416
CheckPositionTime()417 int32_t FastAudioCapturerSourceInner::CheckPositionTime()
418 {
419 int32_t tryCount = 10;
420 uint64_t frames = 0;
421 int64_t timeSec = 0;
422 int64_t timeNanoSec = 0;
423 int64_t maxHandleCost = 10000000; // ns
424 int64_t waitTime = 2000000; // 2ms
425 while (tryCount-- > 0) {
426 ClockTime::RelativeSleep(waitTime); // us
427 int32_t ret = GetMmapHandlePosition(frames, timeSec, timeNanoSec);
428 int64_t curTime = ClockTime::GetCurNano();
429 int64_t curSec = curTime / AUDIO_NS_PER_SECOND;
430 int64_t curNanoSec = curTime - curSec * AUDIO_NS_PER_SECOND;
431 if (ret != SUCCESS || curSec != timeSec || curNanoSec - timeNanoSec > maxHandleCost) {
432 AUDIO_WARNING_LOG("CheckPositionTime[%{public}d]:ret %{public}d", tryCount, ret);
433 continue;
434 } else {
435 AUDIO_INFO_LOG("CheckPositionTime end, position and time is ok.");
436 return SUCCESS;
437 }
438 }
439 return ERROR;
440 }
441
Start(void)442 int32_t FastAudioCapturerSourceInner::Start(void)
443 {
444 AUDIO_INFO_LOG("Start.");
445 if (keepRunningLock_ == nullptr) {
446 keepRunningLock_ = PowerMgr::PowerMgrClient::GetInstance().CreateRunningLock("AudioFastCapturer",
447 PowerMgr::RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO);
448 }
449 if (keepRunningLock_ != nullptr) {
450 AUDIO_INFO_LOG("FastAudioCapturerSourceInner call KeepRunningLock lock");
451 keepRunningLock_->Lock(RUNNINGLOCK_LOCK_TIMEOUTMS_LASTING); // -1 for lasting.
452 } else {
453 AUDIO_ERR_LOG("keepRunningLock_ is null, start can not work well!");
454 }
455
456 if (!started_) {
457 int32_t ret = audioCapture_->Start(audioCapture_);
458 if (ret < 0) {
459 return ERR_NOT_STARTED;
460 }
461 if (CheckPositionTime() != SUCCESS) {
462 AUDIO_ERR_LOG("FastAudioCapturerSource::CheckPositionTime failed!");
463 return ERR_NOT_STARTED;
464 }
465 started_ = true;
466 }
467
468 return SUCCESS;
469 }
470
SetVolume(float left,float right)471 int32_t FastAudioCapturerSourceInner::SetVolume(float left, float right)
472 {
473 return ERR_DEVICE_NOT_SUPPORTED;
474 }
475
GetVolume(float & left,float & right)476 int32_t FastAudioCapturerSourceInner::GetVolume(float &left, float &right)
477 {
478 return ERR_DEVICE_NOT_SUPPORTED;
479 }
480
SetMute(bool isMute)481 int32_t FastAudioCapturerSourceInner::SetMute(bool isMute)
482 {
483 AUDIO_ERR_LOG("SetMute in fast mode is not supported!");
484 return ERR_DEVICE_NOT_SUPPORTED;
485 }
486
GetMute(bool & isMute)487 int32_t FastAudioCapturerSourceInner::GetMute(bool &isMute)
488 {
489 AUDIO_ERR_LOG("SetMute in fast mode is not supported!");
490 return ERR_DEVICE_NOT_SUPPORTED;
491 }
492
SetInputRoute(DeviceType inputDevice)493 int32_t FastAudioCapturerSourceInner::SetInputRoute(DeviceType inputDevice)
494 {
495 return ERR_DEVICE_NOT_SUPPORTED;
496 }
497
SetInputRoute(DeviceType inputDevice,AudioPortPin & inputPortPin)498 int32_t FastAudioCapturerSourceInner::SetInputRoute(DeviceType inputDevice, AudioPortPin &inputPortPin)
499 {
500 return ERR_DEVICE_NOT_SUPPORTED;
501 }
502
SetAudioScene(AudioScene audioScene,DeviceType activeDevice)503 int32_t FastAudioCapturerSourceInner::SetAudioScene(AudioScene audioScene, DeviceType activeDevice)
504 {
505 return ERR_DEVICE_NOT_SUPPORTED;
506 }
507
GetTransactionId()508 uint64_t FastAudioCapturerSourceInner::GetTransactionId()
509 {
510 AUDIO_INFO_LOG("FastAudioCapturerSourceInner::GetTransactionId in");
511 return reinterpret_cast<uint64_t>(audioCapture_);
512 }
513
RegisterWakeupCloseCallback(IAudioSourceCallback * callback)514 void FastAudioCapturerSourceInner::RegisterWakeupCloseCallback(IAudioSourceCallback* callback)
515 {
516 AUDIO_ERR_LOG("RegisterWakeupCloseCallback FAILED");
517 }
518
RegisterAudioCapturerSourceCallback(IAudioSourceCallback * callback)519 void FastAudioCapturerSourceInner::RegisterAudioCapturerSourceCallback(IAudioSourceCallback* callback)
520 {
521 AUDIO_ERR_LOG("RegisterAudioCapturerSourceCallback FAILED");
522 }
523
Stop(void)524 int32_t FastAudioCapturerSourceInner::Stop(void)
525 {
526 AUDIO_INFO_LOG("Stop.");
527
528 if (keepRunningLock_ != nullptr) {
529 AUDIO_INFO_LOG("FastAudioCapturerSourceInner call KeepRunningLock UnLock");
530 keepRunningLock_->UnLock();
531 } else {
532 AUDIO_ERR_LOG("keepRunningLock_ is null, stop can not work well!");
533 }
534
535 if (started_ && audioCapture_ != nullptr) {
536 int32_t ret = audioCapture_->Stop(audioCapture_);
537 if (ret < 0) {
538 AUDIO_ERR_LOG("Stop capture Failed");
539 return ERR_OPERATION_FAILED;
540 }
541 }
542 started_ = false;
543
544 return SUCCESS;
545 }
546
Pause(void)547 int32_t FastAudioCapturerSourceInner::Pause(void)
548 {
549 if (started_ && audioCapture_ != nullptr) {
550 int32_t ret = audioCapture_->Pause(audioCapture_);
551 if (ret != 0) {
552 AUDIO_ERR_LOG("pause capture Failed");
553 return ERR_OPERATION_FAILED;
554 }
555 }
556 paused_ = true;
557
558 return SUCCESS;
559 }
560
Resume(void)561 int32_t FastAudioCapturerSourceInner::Resume(void)
562 {
563 if (paused_ && audioCapture_ != nullptr) {
564 int32_t ret = audioCapture_->Resume(audioCapture_);
565 if (ret != 0) {
566 AUDIO_ERR_LOG("resume capture Failed");
567 return ERR_OPERATION_FAILED;
568 }
569 }
570 paused_ = false;
571
572 return SUCCESS;
573 }
574
Reset(void)575 int32_t FastAudioCapturerSourceInner::Reset(void)
576 {
577 if (started_ && audioCapture_ != nullptr) {
578 audioCapture_->Flush(audioCapture_);
579 }
580
581 return SUCCESS;
582 }
583
Flush(void)584 int32_t FastAudioCapturerSourceInner::Flush(void)
585 {
586 if (started_ && audioCapture_ != nullptr) {
587 audioCapture_->Flush(audioCapture_);
588 }
589
590 return SUCCESS;
591 }
592 } // namespace AudioStandard
593 } // namesapce OHOS
594