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