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 #ifndef LOG_TAG
16 #define LOG_TAG "RemoteFastAudioCapturerSourceInner"
17 #endif
18
19 #include "remote_fast_audio_capturer_source.h"
20
21 #include <cinttypes>
22 #include <dlfcn.h>
23 #include <sstream>
24 #include "securec.h"
25
26 #include "audio_errors.h"
27 #include "audio_hdi_log.h"
28 #include "audio_utils.h"
29 #include "i_audio_device_adapter.h"
30 #include "i_audio_device_manager.h"
31
32 using OHOS::HDI::DistributedAudio::Audio::V1_0::IAudioAdapter;
33 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioAdapterDescriptor;
34 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioFormat;
35 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioPort;
36 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioPortDirection;
37 using OHOS::HDI::DistributedAudio::Audio::V1_0::IAudioManager;
38 using OHOS::HDI::DistributedAudio::Audio::V1_0::IAudioCapture;
39 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioSampleAttributes;
40 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioDeviceDescriptor;
41 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioCategory;
42 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioRouteNode;
43 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioExtParamKey;
44 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioRoute;
45 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioSceneDescriptor;
46 using OHOS::HDI::DistributedAudio::Audio::V1_0::IAudioCallback;
47 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioPortPin;
48 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioPortType;
49 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioPortRole;
50 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioMmapBufferDescriptor;
51 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioTimeStamp;
52
53 namespace OHOS {
54 namespace AudioStandard {
55 class RemoteFastAudioCapturerSourceInner : public RemoteFastAudioCapturerSource, public IAudioDeviceAdapterCallback {
56 public:
57 explicit RemoteFastAudioCapturerSourceInner(const std::string &deviceNetworkId);
58 ~RemoteFastAudioCapturerSourceInner();
59
60 int32_t Init(const IAudioSourceAttr &attr) override;
61 bool IsInited(void) override;
62 void DeInit(void) override;
63
64 int32_t Start(void) override;
65 int32_t Stop(void) override;
66 int32_t Flush(void) override;
67 int32_t Reset(void) override;
68 int32_t Pause(void) override;
69 int32_t Resume(void) override;
70 int32_t CaptureFrame(char *frame, uint64_t requestBytes, uint64_t &replyBytes) override;
71 int32_t SetVolume(float left, float right) override;
72 int32_t GetVolume(float &left, float &right) override;
73 int32_t SetMute(bool isMute) override;
74 int32_t GetMute(bool &isMute) override;
75 int32_t SetAudioScene(AudioScene audioScene, DeviceType activeDevice) override;
76 int32_t SetInputRoute(DeviceType inputDevice) override;
77 uint64_t GetTransactionId() override;
78 int32_t GetPresentationPosition(uint64_t& frames, int64_t& timeSec, int64_t& timeNanoSec) override;
79 std::string GetAudioParameter(const AudioParamKey key, const std::string &condition) override;
80 void RegisterWakeupCloseCallback(IAudioSourceCallback *callback) override;
81 void RegisterAudioCapturerSourceCallback(std::unique_ptr<ICapturerStateCallback> callback) override;
82 void RegisterParameterCallback(IAudioSourceCallback *callback) override;
83 int32_t GetMmapBufferInfo(int &fd, uint32_t &totalSizeInframe, uint32_t &spanSizeInframe,
84 uint32_t &byteSizePerFrame) override;
85 int32_t GetMmapHandlePosition(uint64_t &frames, int64_t &timeSec, int64_t &timeNanoSec) override;
86 int32_t CheckPositionTime();
87
88 void OnAudioParamChange(const std::string &adapterName, const AudioParamKey key, const std::string &condition,
89 const std::string &value) override;
90
91 float GetMaxAmplitude() override;
92
93 int32_t UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE], const size_t size) final;
94 int32_t UpdateAppsUid(const std::vector<int32_t> &appsUid) final;
95
96 private:
97 int32_t CreateCapture(const struct AudioPort &capturePort);
98 void InitAttrs(struct AudioSampleAttributes &attrs);
99 AudioFormat ConvertToHdiFormat(HdiAdapterFormat format);
100 int32_t InitAshmem(const struct AudioSampleAttributes &attrs);
101 AudioCategory GetAudioCategory(AudioScene audioScene);
102 int32_t SetInputPortPin(DeviceType inputDevice, AudioRouteNode &source);
103 uint32_t PcmFormatToBits(HdiAdapterFormat format);
104 void ClearCapture();
105
106 private:
107 static constexpr int32_t INVALID_FD = -1;
108 static constexpr int32_t INVALID_INDEX = -1;
109 static constexpr int32_t HALF_FACTOR = 2;
110 static constexpr uint32_t CAPTURE_INTERLEAVED = 1;
111 static constexpr uint32_t AUDIO_SAMPLE_RATE_48K = 48000;
112 static constexpr uint32_t DEEP_BUFFER_CAPTURER_PERIOD_SIZE = 3840;
113 static constexpr uint32_t INT_32_MAX = 0x7fffffff;
114 static constexpr uint32_t REMOTE_FAST_INPUT_STREAM_ID = 38; // 14 + 3 * 8
115 static constexpr int32_t EVENT_DES_SIZE = 60;
116 static constexpr int64_t SECOND_TO_NANOSECOND = 1000000000;
117 static constexpr int64_t CAPTURE_FIRST_FRIME_WAIT_NANO = 20000000; // 20ms
118 static constexpr int64_t CAPTURE_RESYNC_SLEEP_NANO = 2000000; // 2ms
119 static constexpr uint32_t PCM_8_BIT = 8;
120 static constexpr uint32_t PCM_16_BIT = 16;
121 static constexpr uint32_t PCM_24_BIT = 24;
122 static constexpr uint32_t PCM_32_BIT = 32;
123
124 std::atomic<bool> micMuteState_ = false;
125 std::atomic<bool> capturerInited_ = false;
126 std::atomic<bool> isCapturerCreated_ = false;
127 std::atomic<bool> started_ = false;
128 std::atomic<bool> paused_ = false;
129 float leftVolume_ = 0;
130 float rightVolume_ = 0;
131 int32_t bufferFd_ = -1;
132 uint32_t bufferTotalFrameSize_ = 0;
133 uint32_t eachReadFrameSize_ = 0;
134 std::shared_ptr<IAudioDeviceManager> audioManager_ = nullptr;
135 std::shared_ptr<IAudioDeviceAdapter> audioAdapter_ = nullptr;
136 IAudioSourceCallback *paramCb_ = nullptr;
137 sptr<IAudioCapture> audioCapture_ = nullptr;
138 struct AudioPort audioPort_ = {};
139 IAudioSourceAttr attr_ = {};
140 std::string deviceNetworkId_ = "";
141 uint32_t captureId_ = 0;
142
143 #ifdef DEBUG_DIRECT_USE_HDI
144 sptr<Ashmem> ashmemSource_ = nullptr;
145 int32_t ashmemLen_ = 0;
146 int32_t lenPerRead_ = 0;
147 const char *audioFilePath = "/data/local/tmp/remote_fast_audio_capture.pcm";
148 FILE *pfd_ = nullptr;
149 #endif // DEBUG_DIRECT_USE_HDI
150 };
151
152 std::mutex g_remoteFastSourcesMutex;
153 std::map<std::string, RemoteFastAudioCapturerSourceInner *> allRFSources;
GetInstance(const std::string & deviceNetworkId)154 IMmapAudioCapturerSource *RemoteFastAudioCapturerSource::GetInstance(const std::string &deviceNetworkId)
155 {
156 std::lock_guard<std::mutex> lock(g_remoteFastSourcesMutex);
157 AUDIO_INFO_LOG("GetInstance.");
158 bool isEmpty = deviceNetworkId.empty();
159 CHECK_AND_RETURN_RET_LOG(!isEmpty, nullptr, "Remote capture device networkId is null.");
160
161 if (allRFSources.count(deviceNetworkId)) {
162 return allRFSources[deviceNetworkId];
163 }
164 RemoteFastAudioCapturerSourceInner *rfCapturer =
165 new(std::nothrow) RemoteFastAudioCapturerSourceInner(deviceNetworkId);
166 AUDIO_DEBUG_LOG("New daudio remote fast capture device networkId: [%{public}s].", deviceNetworkId.c_str());
167 allRFSources[deviceNetworkId] = rfCapturer;
168 return rfCapturer;
169 }
170
RemoteFastAudioCapturerSourceInner(const std::string & deviceNetworkId)171 RemoteFastAudioCapturerSourceInner::RemoteFastAudioCapturerSourceInner(const std::string &deviceNetworkId)
172 : deviceNetworkId_(deviceNetworkId)
173 {
174 AUDIO_INFO_LOG("RemoteFastAudioCapturerSource Constract.");
175 }
176
~RemoteFastAudioCapturerSourceInner()177 RemoteFastAudioCapturerSourceInner::~RemoteFastAudioCapturerSourceInner()
178 {
179 if (capturerInited_.load()) {
180 RemoteFastAudioCapturerSourceInner::DeInit();
181 }
182 AUDIO_INFO_LOG("~RemoteFastAudioCapturerSource end.");
183 }
184
IsInited()185 bool RemoteFastAudioCapturerSourceInner::IsInited()
186 {
187 return capturerInited_.load();
188 }
189
ClearCapture()190 void RemoteFastAudioCapturerSourceInner::ClearCapture()
191 {
192 AUDIO_INFO_LOG("Clear capture enter.");
193 capturerInited_.store(false);
194 isCapturerCreated_.store(false);
195 started_.store(false);
196 paused_.store(false);
197 micMuteState_.store(false);
198
199 #ifdef DEBUG_DIRECT_USE_HDI
200 if (pfd_) {
201 fclose(pfd_);
202 pfd_ = nullptr;
203 }
204 if (ashmemSource_ != nullptr) {
205 ashmemSource_->UnmapAshmem();
206 ashmemSource_->CloseAshmem();
207 ashmemSource_ = nullptr;
208 AUDIO_DEBUG_LOG("ClearCapture: Uninit source ashmem OK.");
209 }
210 #endif // DEBUG_DIRECT_USE_HDI
211
212 if (bufferFd_ != INVALID_FD) {
213 CloseFd(bufferFd_);
214 bufferFd_ = INVALID_FD;
215 }
216
217 if (audioAdapter_ != nullptr) {
218 audioAdapter_->DestroyCapture(audioCapture_, captureId_);
219 audioAdapter_->Release();
220 }
221 audioCapture_ = nullptr;
222 audioAdapter_ = nullptr;
223
224 if (audioManager_ != nullptr) {
225 audioManager_->UnloadAdapter(deviceNetworkId_);
226 }
227 audioManager_ = nullptr;
228
229 AudioDeviceManagerFactory::GetInstance().DestoryDeviceManager(REMOTE_DEV_MGR);
230 AUDIO_DEBUG_LOG("Clear capture end.");
231 }
232
DeInit()233 void RemoteFastAudioCapturerSourceInner::DeInit()
234 {
235 std::lock_guard<std::mutex> lock(g_remoteFastSourcesMutex);
236 AUDIO_INFO_LOG("RemoteFastAudioCapturerSourceInner::DeInit");
237 ClearCapture();
238
239 // remove map recorder.
240 CHECK_AND_RETURN_LOG(allRFSources.count(this->deviceNetworkId_) > 0,
241 "not find %{public}s", this->deviceNetworkId_.c_str());
242 RemoteFastAudioCapturerSource *temp = allRFSources[this->deviceNetworkId_];
243 allRFSources.erase(this->deviceNetworkId_);
244 if (temp == nullptr) {
245 AUDIO_ERR_LOG("temp is nullptr");
246 } else {
247 delete temp;
248 }
249 }
250
Init(const IAudioSourceAttr & attr)251 int32_t RemoteFastAudioCapturerSourceInner::Init(const IAudioSourceAttr &attr)
252 {
253 AUDIO_INFO_LOG("RemoteFastAudioCapturerSource::Init");
254 attr_ = attr;
255 audioManager_ = AudioDeviceManagerFactory::GetInstance().CreatDeviceManager(REMOTE_DEV_MGR);
256 CHECK_AND_RETURN_RET_LOG(audioManager_ != nullptr, ERR_NOT_STARTED, "Init audio manager fail.");
257
258 struct AudioAdapterDescriptor *desc = audioManager_->GetTargetAdapterDesc(deviceNetworkId_, true);
259 CHECK_AND_RETURN_RET_LOG(desc != nullptr, ERR_NOT_STARTED, "Get target adapters descriptor fail.");
260 for (uint32_t port = 0; port < desc->ports.size(); port++) {
261 if (desc->ports[port].portId == AudioPortPin::PIN_IN_MIC) {
262 audioPort_ = desc->ports[port];
263 break;
264 }
265 CHECK_AND_RETURN_RET_LOG(port != (desc->ports.size() - 1), ERR_INVALID_INDEX,
266 "Not found the audio mic port.");
267 }
268
269 audioAdapter_ = audioManager_->LoadAdapters(deviceNetworkId_, true);
270 CHECK_AND_RETURN_RET_LOG(audioAdapter_ != nullptr, ERR_NOT_STARTED, "Load audio device adapter failed.");
271
272 int32_t ret = audioAdapter_->Init();
273 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Audio adapter init fail, ret %{public}d.", ret);
274
275 if (!isCapturerCreated_.load()) {
276 CHECK_AND_RETURN_RET_LOG(CreateCapture(audioPort_) == SUCCESS, ERR_NOT_STARTED,
277 "Create capture failed, Audio Port: %{public}d.", audioPort_.portId);
278 }
279 capturerInited_.store(true);
280
281 #ifdef DEBUG_DIRECT_USE_HDI
282 AUDIO_INFO_LOG("Dump audio source attr: [%{public}s]", PrintRemoteAttr(attr_).c_str());
283 pfd_ = fopen(audioFilePath, "a+"); // here will not create a file if not exit.
284 AUDIO_INFO_LOG("Init dump file [%{public}s]", audioFilePath);
285 if (pfd_ == nullptr) {
286 AUDIO_WARNING_LOG("Opening remote pcm file [%{public}s] fail.", audioFilePath);
287 }
288 #endif // DEBUG_DIRECT_USE_HDI
289
290 AUDIO_INFO_LOG("Init end.");
291 return SUCCESS;
292 }
293
CreateCapture(const struct AudioPort & capturePort)294 int32_t RemoteFastAudioCapturerSourceInner::CreateCapture(const struct AudioPort &capturePort)
295 {
296 CHECK_AND_RETURN_RET_LOG(audioAdapter_ != nullptr, ERR_INVALID_HANDLE, "CreateCapture: audio adapter is null.");
297 struct AudioSampleAttributes param;
298 InitAttrs(param);
299 param.type = attr_.audioStreamFlag == AUDIO_FLAG_VOIP_FAST ? AudioCategory::AUDIO_MMAP_VOIP :
300 AudioCategory::AUDIO_MMAP_NOIRQ;
301
302 struct AudioDeviceDescriptor deviceDesc;
303 deviceDesc.portId = capturePort.portId;
304 deviceDesc.pins = AudioPortPin::PIN_IN_MIC;
305 deviceDesc.desc = "";
306 int32_t ret = audioAdapter_->CreateCapture(deviceDesc, param, audioCapture_, this, captureId_);
307 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS && audioCapture_ != nullptr, ret,
308 "Create capture fail, ret %{public}d.", ret);
309 if (param.type == AudioCategory::AUDIO_MMAP_NOIRQ || param.type == AudioCategory::AUDIO_MMAP_VOIP) {
310 InitAshmem(param); // The remote fast source first start
311 }
312
313 isCapturerCreated_.store(true);
314 AUDIO_INFO_LOG("Create capture end, capture format: %{public}d.", param.format);
315 return SUCCESS;
316 }
317
InitAshmem(const struct AudioSampleAttributes & attrs)318 int32_t RemoteFastAudioCapturerSourceInner::InitAshmem(const struct AudioSampleAttributes &attrs)
319 {
320 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "InitAshmem: Audio capture is null.");
321
322 int32_t totalBufferInMs = 40; // 5 * (6 + 2 * (1)) = 40ms, the buffer size, not latency.
323 int32_t reqSize = totalBufferInMs * static_cast<int32_t>(attr_.sampleRate / 1000);
324
325 struct AudioMmapBufferDescriptor desc;
326 int32_t ret = audioCapture_->ReqMmapBuffer(reqSize, desc);
327 CHECK_AND_RETURN_RET_LOG((ret == 0), ERR_OPERATION_FAILED,
328 "InitAshmem require mmap buffer failed, ret %{public}d.", ret);
329 AUDIO_DEBUG_LOG("InitAshmem audio capture mmap buffer info, memoryFd[%{public}d] "
330 "totalBufferFrames [%{public}d] transferFrameSize[%{public}d] isShareable[%{public}d] offset[%{public}d]",
331 desc.memoryFd, desc.totalBufferFrames, desc.transferFrameSize,
332 desc.isShareable, desc.offset);
333
334 bufferFd_ = desc.memoryFd;
335 int32_t periodFrameMaxSize = 1920000; // 192khz * 10s
336 CHECK_AND_RETURN_RET_LOG(desc.totalBufferFrames >= 0 && desc.transferFrameSize >= 0 &&
337 desc.transferFrameSize <= periodFrameMaxSize, ERR_OPERATION_FAILED,
338 "ReqMmapBuffer invalid values: totalBufferFrames[%{public}d] transferFrameSize[%{public}d]",
339 desc.totalBufferFrames, desc.transferFrameSize);
340 bufferTotalFrameSize_ = static_cast<uint32_t>(desc.totalBufferFrames);
341 eachReadFrameSize_ = static_cast<uint32_t>(desc.transferFrameSize);
342
343 #ifdef DEBUG_DIRECT_USE_HDI
344 ashmemLen_ = desc.totalBufferFrames * attrs.channelCount * attrs.format;
345 ashmemSource_ = new Ashmem(bufferFd_, ashmemLen_);
346 AUDIO_DEBUG_LOG("InitAshmem creat ashmem source OK, ashmemLen %{public}d.", ashmemLen_);
347 bool tmp = ashmemSource_->MapReadAndWriteAshmem();
348 CHECK_AND_RETURN_RET_LOG(tmp, ERR_OPERATION_FAILED, "InitAshmem map ashmem source failed.");
349 lenPerRead_ = desc.transferFrameSize * attrs.channelCount * attrs.format;
350 AUDIO_DEBUG_LOG("InitAshmem map ashmem source OK, lenPerWrite %{public}d.", lenPerRead_);
351 #endif
352 return SUCCESS;
353 }
354
InitAttrs(struct AudioSampleAttributes & attrs)355 void RemoteFastAudioCapturerSourceInner::InitAttrs(struct AudioSampleAttributes &attrs)
356 {
357 /* Initialization of audio parameters for playback */
358 attrs.interleaved = CAPTURE_INTERLEAVED;
359 attrs.format = ConvertToHdiFormat(attr_.format);
360 attrs.sampleRate = attr_.sampleRate;
361 attrs.channelCount = attr_.channel;
362 attrs.period = DEEP_BUFFER_CAPTURER_PERIOD_SIZE;
363 attrs.frameSize = attrs.format * attrs.channelCount;
364 attrs.isBigEndian = attr_.isBigEndian;
365 attrs.isSignedData = true;
366 attrs.startThreshold = DEEP_BUFFER_CAPTURER_PERIOD_SIZE / (attrs.frameSize);
367 attrs.stopThreshold = INT_32_MAX;
368 attrs.silenceThreshold = attr_.bufferSize;
369 attrs.streamId = REMOTE_FAST_INPUT_STREAM_ID;
370 }
371
ConvertToHdiFormat(HdiAdapterFormat format)372 AudioFormat RemoteFastAudioCapturerSourceInner::ConvertToHdiFormat(HdiAdapterFormat format)
373 {
374 AudioFormat hdiFormat;
375 switch (format) {
376 case SAMPLE_U8:
377 hdiFormat = AudioFormat::AUDIO_FORMAT_TYPE_PCM_8_BIT;
378 break;
379 case SAMPLE_S16:
380 hdiFormat = AudioFormat::AUDIO_FORMAT_TYPE_PCM_16_BIT;
381 break;
382 case SAMPLE_S24:
383 hdiFormat = AudioFormat::AUDIO_FORMAT_TYPE_PCM_24_BIT;
384 break;
385 case SAMPLE_S32:
386 hdiFormat = AudioFormat::AUDIO_FORMAT_TYPE_PCM_32_BIT;
387 break;
388 default:
389 hdiFormat = AudioFormat::AUDIO_FORMAT_TYPE_PCM_16_BIT;
390 break;
391 }
392 return hdiFormat;
393 }
394
PrintRemoteAttr(const IAudioSourceAttr & attr)395 inline std::string PrintRemoteAttr(const IAudioSourceAttr &attr)
396 {
397 std::stringstream value;
398 value << "adapterName[" << attr.adapterName << "] openMicSpeaker[" << attr.openMicSpeaker << "] ";
399 value << "format[" << static_cast<int32_t>(attr.format) << "]";
400 value << "sampleRate[" << attr.sampleRate << "] channel[" << attr.channel << "] ";
401 value << "volume[" << attr.volume << "] filePath[" << attr.filePath << "] ";
402 value << "deviceNetworkId[" << attr.deviceNetworkId << "] device_type[" << attr.deviceType << "]";
403 return value.str();
404 }
405
GetMmapBufferInfo(int & fd,uint32_t & totalSizeInframe,uint32_t & spanSizeInframe,uint32_t & byteSizePerFrame)406 int32_t RemoteFastAudioCapturerSourceInner::GetMmapBufferInfo(int &fd, uint32_t &totalSizeInframe,
407 uint32_t &spanSizeInframe, uint32_t &byteSizePerFrame)
408 {
409 CHECK_AND_RETURN_RET_LOG(bufferFd_ != INVALID_FD, ERR_INVALID_HANDLE,
410 "buffer fd has been released!");
411 fd = bufferFd_;
412 totalSizeInframe = bufferTotalFrameSize_;
413 spanSizeInframe = eachReadFrameSize_;
414 byteSizePerFrame = PcmFormatToBits(attr_.format) * attr_.channel / PCM_8_BIT;
415 return SUCCESS;
416 }
417
GetMmapHandlePosition(uint64_t & frames,int64_t & timeSec,int64_t & timeNanoSec)418 int32_t RemoteFastAudioCapturerSourceInner::GetMmapHandlePosition(uint64_t &frames, int64_t &timeSec,
419 int64_t &timeNanoSec)
420 {
421 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE,
422 "GetMmapHandlePosition: Audio capture is null.");
423
424 struct AudioTimeStamp timestamp;
425 int32_t ret = audioCapture_->GetMmapPosition(frames, timestamp);
426 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "Hdi GetMmapPosition filed, ret:%{public}d!", ret);
427
428 int64_t maxSec = 9223372036; // (9223372036 + 1) * 10^9 > INT64_MAX, seconds should not bigger than it.
429 CHECK_AND_RETURN_RET_LOG(timestamp.tvSec >= 0 && timestamp.tvSec <= maxSec && timestamp.tvNSec >= 0 &&
430 timestamp.tvNSec <= SECOND_TO_NANOSECOND, ERR_OPERATION_FAILED,
431 "Hdi GetMmapPosition get invaild second:%{public}" PRId64 " or nanosecond:%{public}" PRId64 " !",
432 timestamp.tvSec, timestamp.tvNSec);
433 timeSec = timestamp.tvSec;
434 timeNanoSec = timestamp.tvNSec;
435
436 return SUCCESS;
437 }
438
CaptureFrame(char * frame,uint64_t requestBytes,uint64_t & replyBytes)439 int32_t RemoteFastAudioCapturerSourceInner::CaptureFrame(char *frame, uint64_t requestBytes, uint64_t &replyBytes)
440 {
441 AUDIO_DEBUG_LOG("Capture frame is not supported.");
442 return SUCCESS;
443 }
444
CheckPositionTime()445 int32_t RemoteFastAudioCapturerSourceInner::CheckPositionTime()
446 {
447 int32_t tryCount = 10;
448 uint64_t frames = 0;
449 int64_t timeSec = 0;
450 int64_t timeNanoSec = 0;
451 int64_t maxHandleCost = 10000000; // ns
452 int64_t waitTime = 10000000; // 10ms
453 while (tryCount-- > 0) {
454 ClockTime::RelativeSleep(waitTime); // us
455 int32_t ret = GetMmapHandlePosition(frames, timeSec, timeNanoSec);
456 int64_t curTime = ClockTime::GetCurNano();
457 int64_t curSec = curTime / AUDIO_NS_PER_SECOND;
458 int64_t curNanoSec = curTime - curSec * AUDIO_NS_PER_SECOND;
459 if (ret != SUCCESS || curSec != timeSec || curNanoSec - timeNanoSec > maxHandleCost) {
460 AUDIO_WARNING_LOG("CheckPositionTime[%{public}d]:ret %{public}d", tryCount, ret);
461 continue;
462 } else {
463 AUDIO_INFO_LOG("CheckPositionTime end, position and time is ok.");
464 return SUCCESS;
465 }
466 }
467 return ERROR;
468 }
469
Start(void)470 int32_t RemoteFastAudioCapturerSourceInner::Start(void)
471 {
472 AUDIO_INFO_LOG("RemoteFastAudioCapturerSourceInner::Start");
473 if (!isCapturerCreated_.load()) {
474 int32_t err = CreateCapture(audioPort_);
475 CHECK_AND_RETURN_RET_LOG(err == SUCCESS, ERR_NOT_STARTED,
476 "Create capture failed, Audio Port: %{public}d.", audioPort_.portId);
477 }
478
479 if (started_.load()) {
480 AUDIO_INFO_LOG("Remote fast capturer is already start.");
481 return SUCCESS;
482 }
483
484 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "Start: Audio capture is null.");
485 int32_t ret = audioCapture_->Start();
486 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_NOT_STARTED, "Remote fast capturer start fail, ret %{public}d.", ret);
487
488 ret = CheckPositionTime();
489 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_NOT_STARTED,
490 "Remote fast capturer check position time fail, ret %{public}d.", ret);
491 started_.store(true);
492
493 AUDIO_DEBUG_LOG("Start OK.");
494 return SUCCESS;
495 }
496
Stop(void)497 int32_t RemoteFastAudioCapturerSourceInner::Stop(void)
498 {
499 AUDIO_INFO_LOG("RemoteFastAudioCapturerSourceInner::Stop");
500 if (!started_.load()) {
501 AUDIO_INFO_LOG("Remote capture is already stopped.");
502 return SUCCESS;
503 }
504
505 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "Stop: Audio capture is null.");
506 int32_t ret = audioCapture_->Stop();
507 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "Stop fail, ret %{public}d.", ret);
508 started_.store(false);
509 return SUCCESS;
510 }
511
Pause(void)512 int32_t RemoteFastAudioCapturerSourceInner::Pause(void)
513 {
514 AUDIO_INFO_LOG("RemoteFastAudioCapturerSourceInner::Pause");
515 CHECK_AND_RETURN_RET_LOG(started_.load(), ERR_ILLEGAL_STATE, "Pause invalid state!");
516
517 if (paused_.load()) {
518 AUDIO_INFO_LOG("Remote render is already paused.");
519 return SUCCESS;
520 }
521
522 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "Pause: Audio capture is null.");
523 int32_t ret = audioCapture_->Pause();
524 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "Pause fail, ret %{public}d.", ret);
525 paused_.store(true);
526 return SUCCESS;
527 }
528
Resume(void)529 int32_t RemoteFastAudioCapturerSourceInner::Resume(void)
530 {
531 AUDIO_INFO_LOG("RemoteFastAudioCapturerSourceInner::Resume");
532 CHECK_AND_RETURN_RET_LOG(started_.load(), ERR_ILLEGAL_STATE, "Resume invalid state!");
533
534 if (!paused_.load()) {
535 AUDIO_INFO_LOG("Remote render is already resumed.");
536 return SUCCESS;
537 }
538
539 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "Resume: Audio capture is null.");
540 int32_t ret = audioCapture_->Resume();
541 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "Resume fail, ret %{public}d.", ret);
542 paused_.store(false);
543 return SUCCESS;
544 }
545
Reset(void)546 int32_t RemoteFastAudioCapturerSourceInner::Reset(void)
547 {
548 AUDIO_INFO_LOG("RemoteFastAudioCapturerSourceInner::Reset");
549 CHECK_AND_RETURN_RET_LOG(started_.load(), ERR_ILLEGAL_STATE, "Reset invalid state!");
550
551 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "Reset: Audio capture is null.");
552 int32_t ret = audioCapture_->Flush();
553 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "Reset fail, ret %{public}d.", ret);
554 return SUCCESS;
555 }
556
Flush(void)557 int32_t RemoteFastAudioCapturerSourceInner::Flush(void)
558 {
559 AUDIO_INFO_LOG("RemoteFastAudioCapturerSourceInner::Flush");
560 CHECK_AND_RETURN_RET_LOG(started_.load(), ERR_ILLEGAL_STATE, "Flush invalid state!");
561
562 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "Flush: Audio capture is null.");
563
564 int32_t ret = audioCapture_->Flush();
565 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "Flush fail, ret %{public}d.", ret);
566 return SUCCESS;
567 }
568
SetVolume(float left,float right)569 int32_t RemoteFastAudioCapturerSourceInner::SetVolume(float left, float right)
570 {
571 AUDIO_INFO_LOG("Set volume enter, left %{public}f, right %{public}f.", left, right);
572 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "SetVolume: Audio capture is null.");
573
574 float volume;
575 leftVolume_ = left;
576 rightVolume_ = right;
577 if ((leftVolume_ == 0) && (rightVolume_ != 0)) {
578 volume = rightVolume_;
579 } else if ((leftVolume_ != 0) && (rightVolume_ == 0)) {
580 volume = leftVolume_;
581 } else {
582 volume = (leftVolume_ + rightVolume_) / HALF_FACTOR;
583 }
584
585 int32_t ret = audioCapture_->SetVolume(volume);
586 if (ret) {
587 AUDIO_ERR_LOG("Remote fast capturer set volume fail, ret %{public}d.", ret);
588 }
589 return ret;
590 }
591
GetVolume(float & left,float & right)592 int32_t RemoteFastAudioCapturerSourceInner::GetVolume(float &left, float &right)
593 {
594 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "GetVolume: Audio capture is null.");
595 float val = 0;
596 audioCapture_->GetVolume(val);
597 left = val;
598 right = val;
599 return SUCCESS;
600 }
601
SetMute(bool isMute)602 int32_t RemoteFastAudioCapturerSourceInner::SetMute(bool isMute)
603 {
604 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "SetMute: Audio capture is null.");
605 int32_t ret = audioCapture_->SetMute(isMute);
606 if (ret != 0) {
607 AUDIO_ERR_LOG("Remote fast capturer set mute fail, ret %{public}d.", ret);
608 }
609
610 micMuteState_ = isMute;
611 return SUCCESS;
612 }
613
GetMute(bool & isMute)614 int32_t RemoteFastAudioCapturerSourceInner::GetMute(bool &isMute)
615 {
616 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "GetMute: Audio capture is null.");
617 bool isHdiMute = false;
618 int32_t ret = audioCapture_->GetMute(isHdiMute);
619 if (ret != 0) {
620 AUDIO_ERR_LOG("Remote fast capturer get mute fail, ret %{public}d.", ret);
621 }
622
623 isMute = micMuteState_;
624 return SUCCESS;
625 }
626
GetTransactionId()627 uint64_t RemoteFastAudioCapturerSourceInner::GetTransactionId()
628 {
629 return ERR_NOT_SUPPORTED;
630 }
631
GetPresentationPosition(uint64_t & frames,int64_t & timeSec,int64_t & timeNanoSec)632 int32_t RemoteFastAudioCapturerSourceInner::GetPresentationPosition(uint64_t& frames, int64_t& timeSec,
633 int64_t& timeNanoSec)
634 {
635 return ERR_OPERATION_FAILED;
636 }
637
GetAudioParameter(const AudioParamKey key,const std::string & condition)638 std::string RemoteFastAudioCapturerSourceInner::GetAudioParameter(const AudioParamKey key,
639 const std::string &condition)
640 {
641 AUDIO_WARNING_LOG("not supported yet");
642 return "";
643 }
644
SetInputPortPin(DeviceType inputDevice,AudioRouteNode & source)645 int32_t RemoteFastAudioCapturerSourceInner::SetInputPortPin(DeviceType inputDevice, AudioRouteNode &source)
646 {
647 int32_t ret = SUCCESS;
648 switch (inputDevice) {
649 case DEVICE_TYPE_MIC:
650 source.ext.device.type = AudioPortPin::PIN_IN_MIC;
651 source.ext.device.desc = "pin_in_mic";
652 break;
653 case DEVICE_TYPE_WIRED_HEADSET:
654 source.ext.device.type = AudioPortPin::PIN_IN_HS_MIC;
655 source.ext.device.desc = "pin_in_hs_mic";
656 break;
657 case DEVICE_TYPE_USB_HEADSET:
658 source.ext.device.type = AudioPortPin::PIN_IN_USB_EXT;
659 source.ext.device.desc = "pin_in_usb_ext";
660 break;
661 default:
662 ret = ERR_NOT_SUPPORTED;
663 break;
664 }
665 return ret;
666 }
667
SetInputRoute(DeviceType inputDevice)668 int32_t RemoteFastAudioCapturerSourceInner::SetInputRoute(DeviceType inputDevice)
669 {
670 AudioRouteNode source = {};
671 AudioRouteNode sink = {};
672 int32_t ret = SetInputPortPin(inputDevice, source);
673 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Set input port pin fail, ret %{public}d", ret);
674
675 source.portId = static_cast<int32_t>(audioPort_.portId);
676 source.role = AudioPortRole::AUDIO_PORT_SOURCE_ROLE;
677 source.type = AudioPortType::AUDIO_PORT_DEVICE_TYPE;
678 source.ext.device.moduleId = 0;
679
680 sink.portId = 0;
681 sink.role = AudioPortRole::AUDIO_PORT_SINK_ROLE;
682 sink.type = AudioPortType::AUDIO_PORT_MIX_TYPE;
683 sink.ext.mix.moduleId = 0;
684 sink.ext.mix.streamId = REMOTE_FAST_INPUT_STREAM_ID;
685
686 AudioRoute route;
687 route.sources.push_back(source);
688 route.sinks.push_back(sink);
689
690 CHECK_AND_RETURN_RET_LOG(audioAdapter_ != nullptr, ERR_INVALID_HANDLE, "SetInputRoute: Audio adapter is null.");
691 ret = audioAdapter_->UpdateAudioRoute(route);
692 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Update audio route fail, ret %{public}d", ret);
693 return SUCCESS;
694 }
695
GetAudioCategory(AudioScene audioScene)696 AudioCategory RemoteFastAudioCapturerSourceInner::GetAudioCategory(AudioScene audioScene)
697 {
698 AudioCategory audioCategory;
699 switch (audioScene) {
700 case AUDIO_SCENE_DEFAULT:
701 audioCategory = AudioCategory::AUDIO_IN_MEDIA;
702 break;
703 case AUDIO_SCENE_RINGING:
704 case AUDIO_SCENE_VOICE_RINGING:
705 audioCategory = AudioCategory::AUDIO_IN_RINGTONE;
706 break;
707 case AUDIO_SCENE_PHONE_CALL:
708 audioCategory = AudioCategory::AUDIO_IN_CALL;
709 break;
710 case AUDIO_SCENE_PHONE_CHAT:
711 audioCategory = AudioCategory::AUDIO_IN_COMMUNICATION;
712 break;
713 default:
714 audioCategory = AudioCategory::AUDIO_IN_MEDIA;
715 break;
716 }
717 AUDIO_DEBUG_LOG("RemoteFastAudioCapturerSource: Audio category returned is: %{public}d", audioCategory);
718
719 return audioCategory;
720 }
721
SetAudioScene(AudioScene audioScene,DeviceType activeDevice)722 int32_t RemoteFastAudioCapturerSourceInner::SetAudioScene(AudioScene audioScene, DeviceType activeDevice)
723 {
724 AUDIO_INFO_LOG("SetAudioScene enter: scene: %{public}d, device %{public}d.", audioScene, activeDevice);
725 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "SetAudioScene: Audio capture is null.");
726 struct AudioSceneDescriptor scene;
727 scene.scene.id = GetAudioCategory(audioScene);
728 scene.desc.pins = AudioPortPin::PIN_IN_MIC;
729 CHECK_AND_RETURN_RET_LOG(audioScene >= AUDIO_SCENE_DEFAULT && audioScene < AUDIO_SCENE_MAX,
730 ERR_INVALID_PARAM, "invalid audioScene");
731
732 AUDIO_DEBUG_LOG("AudioCapturerSource::SelectScene start");
733 int32_t ret = audioCapture_->SelectScene(scene);
734 AUDIO_DEBUG_LOG("AudioCapturerSource::SelectScene over");
735 CHECK_AND_RETURN_RET_LOG(ret >= 0, ERR_OPERATION_FAILED,
736 "AudioCapturerSource: Select scene FAILED: %{public}d", ret);
737 AUDIO_DEBUG_LOG("AudioCapturerSource::Select audio scene SUCCESS: %{public}d", audioScene);
738 return SUCCESS;
739 }
740
PcmFormatToBits(HdiAdapterFormat format)741 uint32_t RemoteFastAudioCapturerSourceInner::PcmFormatToBits(HdiAdapterFormat format)
742 {
743 switch (format) {
744 case HdiAdapterFormat::SAMPLE_U8:
745 return PCM_8_BIT;
746 case HdiAdapterFormat::SAMPLE_S16:
747 return PCM_16_BIT;
748 case HdiAdapterFormat::SAMPLE_S24:
749 return PCM_24_BIT;
750 case HdiAdapterFormat::SAMPLE_S32:
751 return PCM_32_BIT;
752 case HdiAdapterFormat::SAMPLE_F32:
753 return PCM_32_BIT;
754 default:
755 return PCM_16_BIT;
756 }
757 }
758
RegisterWakeupCloseCallback(IAudioSourceCallback * callback)759 void RemoteFastAudioCapturerSourceInner::RegisterWakeupCloseCallback(IAudioSourceCallback *callback)
760 {
761 AUDIO_WARNING_LOG("RegisterWakeupCloseCallback FAILED");
762 }
763
RegisterAudioCapturerSourceCallback(std::unique_ptr<ICapturerStateCallback> callback)764 void RemoteFastAudioCapturerSourceInner::RegisterAudioCapturerSourceCallback(
765 std::unique_ptr<ICapturerStateCallback> callback)
766 {
767 AUDIO_WARNING_LOG("RegisterAudioCapturerSourceCallback FAILED");
768 }
769
RegisterParameterCallback(IAudioSourceCallback * callback)770 void RemoteFastAudioCapturerSourceInner::RegisterParameterCallback(IAudioSourceCallback *callback)
771 {
772 AUDIO_INFO_LOG("register params callback");
773 paramCb_ = callback;
774
775 #ifdef FEATURE_DISTRIBUTE_AUDIO
776 CHECK_AND_RETURN_LOG(audioAdapter_ != nullptr, "RegisterParameterCallback: Audio adapter is null.");
777 int32_t ret = audioAdapter_->RegExtraParamObserver();
778 CHECK_AND_RETURN_LOG(ret == SUCCESS, "RegisterParameterCallback failed, ret %{public}d.", ret);
779 #endif
780 }
781
OnAudioParamChange(const std::string & adapterName,const AudioParamKey key,const std::string & condition,const std::string & value)782 void RemoteFastAudioCapturerSourceInner::OnAudioParamChange(const std::string &adapterName, const AudioParamKey key,
783 const std::string &condition, const std::string &value)
784 {
785 AUDIO_INFO_LOG("Audio param change event, key:%{public}d, condition:%{public}s, value:%{public}s",
786 key, condition.c_str(), value.c_str());
787 if (key == AudioParamKey::PARAM_KEY_STATE) {
788 ClearCapture();
789 }
790
791 CHECK_AND_RETURN_LOG(paramCb_ != nullptr, "Sink audio param callback is null.");
792 paramCb_->OnAudioSourceParamChange(adapterName, key, condition, value);
793 }
794
GetMaxAmplitude()795 float RemoteFastAudioCapturerSourceInner::GetMaxAmplitude()
796 {
797 AUDIO_WARNING_LOG("getMaxAmplitude in remote fast audio cap not support");
798 return 0;
799 }
800
UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE],const size_t size)801 int32_t RemoteFastAudioCapturerSourceInner::UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE],
802 const size_t size)
803 {
804 AUDIO_WARNING_LOG("not supported.");
805 return ERR_NOT_SUPPORTED;
806 }
807
UpdateAppsUid(const std::vector<int32_t> & appsUid)808 int32_t RemoteFastAudioCapturerSourceInner::UpdateAppsUid(const std::vector<int32_t> &appsUid)
809 {
810 AUDIO_WARNING_LOG("not supported.");
811 return ERR_NOT_SUPPORTED;
812 }
813 } // namespace AudioStandard
814 } // namesapce OHOS
815