1 /*
2  * Copyright (c) 2022 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_capturer_adapter_impl.h"
17 
18 #include <unordered_map>
19 
20 #include "application_context.h"
21 #include "audio_errors.h"
22 #include "nweb_log.h"
23 
24 namespace OHOS::NWeb {
25 
26 constexpr int64_t NANOSECONDS_PER_SECOND = 1000000000;
27 
28 const std::unordered_map<AudioAdapterSamplingRate, AudioSamplingRate> SAMPLING_RATE_MAP = {
29     {AudioAdapterSamplingRate::SAMPLE_RATE_8000, AudioSamplingRate::SAMPLE_RATE_8000},
30     {AudioAdapterSamplingRate::SAMPLE_RATE_11025, AudioSamplingRate::SAMPLE_RATE_11025},
31     {AudioAdapterSamplingRate::SAMPLE_RATE_12000, AudioSamplingRate::SAMPLE_RATE_12000},
32     {AudioAdapterSamplingRate::SAMPLE_RATE_16000, AudioSamplingRate::SAMPLE_RATE_16000},
33     {AudioAdapterSamplingRate::SAMPLE_RATE_22050, AudioSamplingRate::SAMPLE_RATE_22050},
34     {AudioAdapterSamplingRate::SAMPLE_RATE_24000, AudioSamplingRate::SAMPLE_RATE_24000},
35     {AudioAdapterSamplingRate::SAMPLE_RATE_32000, AudioSamplingRate::SAMPLE_RATE_32000},
36     {AudioAdapterSamplingRate::SAMPLE_RATE_44100, AudioSamplingRate::SAMPLE_RATE_44100},
37     {AudioAdapterSamplingRate::SAMPLE_RATE_48000, AudioSamplingRate::SAMPLE_RATE_48000},
38     {AudioAdapterSamplingRate::SAMPLE_RATE_64000, AudioSamplingRate::SAMPLE_RATE_64000},
39     {AudioAdapterSamplingRate::SAMPLE_RATE_96000, AudioSamplingRate::SAMPLE_RATE_96000},
40 };
41 
42 const std::unordered_map<AudioAdapterEncodingType, AudioEncodingType> ENCODING_TYPE_MAP = {
43     {AudioAdapterEncodingType::ENCODING_PCM, AudioEncodingType::ENCODING_PCM},
44     {AudioAdapterEncodingType::ENCODING_INVALID, AudioEncodingType::ENCODING_INVALID}
45 };
46 
47 const std::unordered_map<AudioAdapterSampleFormat, AudioSampleFormat> SAMPLE_FORMAT_MAP = {
48     {AudioAdapterSampleFormat::SAMPLE_U8, AudioSampleFormat::SAMPLE_U8},
49     {AudioAdapterSampleFormat::SAMPLE_S16LE, AudioSampleFormat::SAMPLE_S16LE},
50     {AudioAdapterSampleFormat::SAMPLE_S24LE, AudioSampleFormat::SAMPLE_S24LE},
51     {AudioAdapterSampleFormat::SAMPLE_S32LE, AudioSampleFormat::SAMPLE_S32LE},
52     {AudioAdapterSampleFormat::SAMPLE_F32LE, AudioSampleFormat::SAMPLE_F32LE},
53 };
54 
55 const std::unordered_map<AudioAdapterChannel, AudioChannel> AUDIO_CHANNEL_MAP = {
56     {AudioAdapterChannel::MONO, AudioChannel::MONO},
57     {AudioAdapterChannel::STEREO, AudioChannel::STEREO},
58     {AudioAdapterChannel::CHANNEL_3, AudioChannel::CHANNEL_3},
59     {AudioAdapterChannel::CHANNEL_4, AudioChannel::CHANNEL_4},
60     {AudioAdapterChannel::CHANNEL_5, AudioChannel::CHANNEL_5},
61     {AudioAdapterChannel::CHANNEL_6, AudioChannel::CHANNEL_6},
62     {AudioAdapterChannel::CHANNEL_7, AudioChannel::CHANNEL_7},
63     {AudioAdapterChannel::CHANNEL_8, AudioChannel::CHANNEL_8},
64 };
65 
66 const std::unordered_map<AudioAdapterSourceType, SourceType> SOURCE_TYPE_MAP = {
67     {AudioAdapterSourceType::SOURCE_TYPE_INVALID, SourceType::SOURCE_TYPE_INVALID},
68     {AudioAdapterSourceType::SOURCE_TYPE_MIC, SourceType::SOURCE_TYPE_MIC},
69     {AudioAdapterSourceType::SOURCE_TYPE_VOICE_RECOGNITION, SourceType::SOURCE_TYPE_VOICE_RECOGNITION},
70     {AudioAdapterSourceType::SOURCE_TYPE_VOICE_COMMUNICATION, SourceType::SOURCE_TYPE_VOICE_COMMUNICATION},
71     {AudioAdapterSourceType::SOURCE_TYPE_ULTRASONIC, SourceType::SOURCE_TYPE_ULTRASONIC},
72 };
73 
AudioCapturerReadCallbackImpl(std::shared_ptr<AudioCapturerReadCallbackAdapter> cb)74 AudioCapturerReadCallbackImpl::AudioCapturerReadCallbackImpl(
75     std::shared_ptr<AudioCapturerReadCallbackAdapter> cb) : cb_(cb) {};
76 
OnReadData(size_t length)77 void AudioCapturerReadCallbackImpl::OnReadData(size_t length)
78 {
79     if (!cb_) {
80         WVLOG_E("Get AudioCapturerReadCallbackAdapter failed.");
81         return;
82     }
83     cb_->OnReadData(length);
84 }
85 
Create(const std::shared_ptr<AudioCapturerOptionsAdapter> capturerOptions,std::string cachePath)86 int32_t AudioCapturerAdapterImpl::Create(
87     const std::shared_ptr<AudioCapturerOptionsAdapter> capturerOptions,
88     std::string cachePath)
89 {
90     std::string audioCachePath = cachePath;
91     if (audioCachePath.empty()) {
92         std::shared_ptr<AbilityRuntime::ApplicationContext> context =
93             AbilityRuntime::ApplicationContext::GetApplicationContext();
94         if (!context) {
95             WVLOG_E("application context get failed");
96             return AUDIO_ERROR;
97         }
98         audioCachePath = context->GetCacheDir();
99         if (audioCachePath.empty()) {
100             WVLOG_E("application cache path get failed");
101             return AUDIO_ERROR;
102         }
103     }
104 
105     if (!capturerOptions) {
106         WVLOG_E("capturerOptions is nullptr");
107         return AUDIO_ERROR;
108     }
109 
110     AudioCapturerOptions options;
111     options.streamInfo.samplingRate = GetAudioSamplingRate(capturerOptions->GetSamplingRate());
112     options.streamInfo.encoding = GetAudioEncodingType(capturerOptions->GetEncoding());
113     options.streamInfo.format = GetAudioSampleFormat(capturerOptions->GetSampleFormat());
114     options.streamInfo.channels = GetAudioChannel(capturerOptions->GetChannels());
115     options.capturerInfo.sourceType = GetAudioSourceType(capturerOptions->GetSourceType());
116     options.capturerInfo.capturerFlags = capturerOptions->GetCapturerFlags();
117 
118     audio_capturer_ = AudioCapturer::Create(options, audioCachePath);
119     if (audio_capturer_ == nullptr) {
120         WVLOG_E("audio capturer create failed");
121         return AUDIO_NULL_ERROR;
122     }
123     audio_capturer_->SetCaptureMode(AudioCaptureMode::CAPTURE_MODE_CALLBACK);
124     return AUDIO_OK;
125 }
126 
Start()127 bool AudioCapturerAdapterImpl::Start()
128 {
129     if (audio_capturer_ == nullptr) {
130         WVLOG_E("audio capturer is nullptr");
131         return false;
132     }
133     return audio_capturer_->Start();
134 }
135 
Stop()136 bool AudioCapturerAdapterImpl::Stop()
137 {
138     if (audio_capturer_ == nullptr) {
139         WVLOG_E("audio capturer is nullptr");
140         return false;
141     }
142     return audio_capturer_->Stop();
143 }
144 
Release()145 bool AudioCapturerAdapterImpl::Release()
146 {
147     if (audio_capturer_ == nullptr) {
148         WVLOG_E("audio capturer is nullptr");
149         return false;
150     }
151     return audio_capturer_->Release();
152 }
153 
SetCapturerReadCallback(std::shared_ptr<AudioCapturerReadCallbackAdapter> callback)154 int32_t AudioCapturerAdapterImpl::SetCapturerReadCallback(
155     std::shared_ptr<AudioCapturerReadCallbackAdapter> callback)
156 {
157     if (callback == nullptr) {
158         WVLOG_E("audio capturer callback is nullptr");
159         return AUDIO_NULL_ERROR;
160     }
161 
162     if (audio_capturer_ == nullptr) {
163         WVLOG_E("audio capturer is nullptr");
164         return AUDIO_NULL_ERROR;
165     }
166     auto capturerReadCallback = std::make_shared<AudioCapturerReadCallbackImpl>(callback);
167     if (capturerReadCallback == nullptr) {
168         WVLOG_E("audio capturerReadCallback is nullptr");
169         return AUDIO_NULL_ERROR;
170     }
171     return audio_capturer_->SetCapturerReadCallback(capturerReadCallback);
172 }
173 
GetBufferDesc(std::shared_ptr<BufferDescAdapter> bufferDesc)174 int32_t AudioCapturerAdapterImpl::GetBufferDesc(std::shared_ptr<BufferDescAdapter> bufferDesc)
175 {
176     if (audio_capturer_ == nullptr) {
177         WVLOG_E("audio capturer is nullptr");
178         return AUDIO_NULL_ERROR;
179     }
180 
181     if (!bufferDesc) {
182         WVLOG_E("bufferDesc is nullptr");
183         return AUDIO_NULL_ERROR;
184     }
185 
186     BufferDesc bufDesc;
187     audio_capturer_->GetBufferDesc(bufDesc);
188     bufferDesc->SetBuffer(bufDesc.buffer);
189     bufferDesc->SetBufLength(bufDesc.bufLength);
190     bufferDesc->SetDataLength(bufDesc.dataLength);
191     return 0;
192 }
193 
Enqueue(const std::shared_ptr<BufferDescAdapter> bufferDesc)194 int32_t AudioCapturerAdapterImpl::Enqueue(const std::shared_ptr<BufferDescAdapter> bufferDesc)
195 {
196     if (audio_capturer_ == nullptr) {
197         WVLOG_E("audio capturer is nullptr");
198         return AUDIO_NULL_ERROR;
199     }
200 
201     if (!bufferDesc) {
202         WVLOG_E("bufferDesc is nullptr");
203         return AUDIO_NULL_ERROR;
204     }
205 
206     BufferDesc bufDesc;
207     bufDesc.buffer = bufferDesc->GetBuffer();
208     bufDesc.bufLength = bufferDesc->GetBufLength();
209     bufDesc.dataLength = bufferDesc->GetDataLength();
210     return audio_capturer_->Enqueue(bufDesc);
211 }
212 
GetFrameCount(uint32_t & frameCount)213 int32_t AudioCapturerAdapterImpl::GetFrameCount(uint32_t &frameCount)
214 {
215     if (audio_capturer_ == nullptr) {
216         WVLOG_E("audio capturer is nullptr");
217         return AUDIO_NULL_ERROR;
218     }
219     return audio_capturer_->GetFrameCount(frameCount);
220 }
221 
GetAudioTime()222 int64_t AudioCapturerAdapterImpl::GetAudioTime()
223 {
224     if (audio_capturer_ == nullptr) {
225         WVLOG_E("audio capturer is nullptr");
226         return AUDIO_NULL_ERROR;
227     }
228     Timestamp timeStamp;
229     audio_capturer_->GetAudioTime(timeStamp, Timestamp::Timestampbase::MONOTONIC);
230     return timeStamp.time.tv_sec * NANOSECONDS_PER_SECOND + timeStamp.time.tv_nsec;
231 }
232 
GetAudioSamplingRate(AudioAdapterSamplingRate samplingRate)233 AudioSamplingRate AudioCapturerAdapterImpl::GetAudioSamplingRate(AudioAdapterSamplingRate samplingRate)
234 {
235     auto item = SAMPLING_RATE_MAP.find(samplingRate);
236     if (item == SAMPLING_RATE_MAP.end()) {
237         WVLOG_E("audio sampling rate not found");
238         return AudioSamplingRate::SAMPLE_RATE_44100;
239     }
240     return item->second;
241 }
242 
GetAudioEncodingType(AudioAdapterEncodingType encodingType)243 AudioEncodingType AudioCapturerAdapterImpl::GetAudioEncodingType(AudioAdapterEncodingType encodingType)
244 {
245     auto item = ENCODING_TYPE_MAP.find(encodingType);
246     if (item == ENCODING_TYPE_MAP.end()) {
247         WVLOG_E("audio encoding type not found");
248         return AudioEncodingType::ENCODING_INVALID;
249     }
250     return item->second;
251 }
252 
GetAudioSampleFormat(AudioAdapterSampleFormat sampleFormat)253 AudioSampleFormat AudioCapturerAdapterImpl::GetAudioSampleFormat(AudioAdapterSampleFormat sampleFormat)
254 {
255     auto item = SAMPLE_FORMAT_MAP.find(sampleFormat);
256     if (item == SAMPLE_FORMAT_MAP.end()) {
257         WVLOG_E("audio sample format not found");
258         return AudioSampleFormat::INVALID_WIDTH;
259     }
260     return item->second;
261 }
262 
GetAudioChannel(AudioAdapterChannel channel)263 AudioChannel AudioCapturerAdapterImpl::GetAudioChannel(AudioAdapterChannel channel)
264 {
265     auto item = AUDIO_CHANNEL_MAP.find(channel);
266     if (item == AUDIO_CHANNEL_MAP.end()) {
267         WVLOG_E("audio channel not found");
268         return AudioChannel::STEREO;
269     }
270     return item->second;
271 }
272 
GetAudioSourceType(AudioAdapterSourceType sourceType)273 SourceType AudioCapturerAdapterImpl::GetAudioSourceType(AudioAdapterSourceType sourceType)
274 {
275     auto item = SOURCE_TYPE_MAP.find(sourceType);
276     if (item == SOURCE_TYPE_MAP.end()) {
277         WVLOG_E("audio source type not found");
278         return SourceType::SOURCE_TYPE_VOICE_RECOGNITION;
279     }
280     return item->second;
281 }
282 }  // namespace OHOS::NWeb
283