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 AudioAdapterCapturerOptions & capturerOptions,std::string cachePath)86 int32_t AudioCapturerAdapterImpl::Create(const AudioAdapterCapturerOptions &capturerOptions,
87 std::string cachePath)
88 {
89 std::string audioCachePath = cachePath;
90 if (audioCachePath.empty()) {
91 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
92 AbilityRuntime::ApplicationContext::GetApplicationContext();
93 if (!context) {
94 WVLOG_E("application context get failed");
95 return AUDIO_ERROR;
96 }
97 audioCachePath = context->GetCacheDir();
98 if (audioCachePath.empty()) {
99 WVLOG_E("application cache path get failed");
100 return AUDIO_ERROR;
101 }
102 }
103
104 AudioCapturerOptions options;
105 options.streamInfo.samplingRate = GetAudioSamplingRate(capturerOptions.samplingRate);
106 options.streamInfo.encoding = GetAudioEncodingType(capturerOptions.encoding);
107 options.streamInfo.format = GetAudioSampleFormat(capturerOptions.format);
108 options.streamInfo.channels = GetAudioChannel(capturerOptions.channels);
109 options.capturerInfo.sourceType = GetAudioSourceType(capturerOptions.sourceType);
110 options.capturerInfo.capturerFlags = capturerOptions.capturerFlags;
111
112 audio_capturer_ = AudioCapturer::Create(options, audioCachePath);
113 if (audio_capturer_ == nullptr) {
114 WVLOG_E("audio capturer create failed");
115 return AUDIO_NULL_ERROR;
116 }
117 audio_capturer_->SetCaptureMode(AudioCaptureMode::CAPTURE_MODE_CALLBACK);
118 return AUDIO_OK;
119 }
120
Start()121 bool AudioCapturerAdapterImpl::Start()
122 {
123 if (audio_capturer_ == nullptr) {
124 WVLOG_E("audio capturer is nullptr");
125 return false;
126 }
127 return audio_capturer_->Start();
128 }
129
Stop()130 bool AudioCapturerAdapterImpl::Stop()
131 {
132 if (audio_capturer_ == nullptr) {
133 WVLOG_E("audio capturer is nullptr");
134 return false;
135 }
136 return audio_capturer_->Stop();
137 }
138
Release()139 bool AudioCapturerAdapterImpl::Release()
140 {
141 if (audio_capturer_ == nullptr) {
142 WVLOG_E("audio capturer is nullptr");
143 return false;
144 }
145 return audio_capturer_->Release();
146 }
147
SetCapturerReadCallback(const std::shared_ptr<AudioCapturerReadCallbackAdapter> & callback)148 int32_t AudioCapturerAdapterImpl::SetCapturerReadCallback(
149 const std::shared_ptr<AudioCapturerReadCallbackAdapter> &callback)
150 {
151 if (audio_capturer_ == nullptr) {
152 WVLOG_E("audio capturer is nullptr");
153 return AUDIO_NULL_ERROR;
154 }
155 auto capturerReadCallback = std::make_shared<AudioCapturerReadCallbackImpl>(callback);
156 if (capturerReadCallback == nullptr) {
157 WVLOG_E("audio capturerReadCallback is nullptr");
158 return AUDIO_NULL_ERROR;
159 }
160 return audio_capturer_->SetCapturerReadCallback(capturerReadCallback);
161 }
162
GetBufferDesc(BufferDescAdapter & bufferDesc)163 int32_t AudioCapturerAdapterImpl::GetBufferDesc(BufferDescAdapter &bufferDesc)
164 {
165 if (audio_capturer_ == nullptr) {
166 WVLOG_E("audio capturer is nullptr");
167 return AUDIO_NULL_ERROR;
168 }
169 BufferDesc bufDesc;
170 audio_capturer_->GetBufferDesc(bufDesc);
171 bufferDesc.buffer = bufDesc.buffer;
172 bufferDesc.bufLength = bufDesc.bufLength;
173 bufferDesc.dataLength = bufDesc.dataLength;
174 return 0;
175 }
176
Enqueue(const BufferDescAdapter & bufferDesc) const177 int32_t AudioCapturerAdapterImpl::Enqueue(const BufferDescAdapter &bufferDesc) const
178 {
179 if (audio_capturer_ == nullptr) {
180 WVLOG_E("audio capturer is nullptr");
181 return AUDIO_NULL_ERROR;
182 }
183 BufferDesc bufDesc;
184 bufDesc.buffer = bufferDesc.buffer;
185 bufDesc.bufLength = bufferDesc.bufLength;
186 bufDesc.dataLength = bufferDesc.dataLength;
187 return audio_capturer_->Enqueue(bufDesc);
188 }
189
GetFrameCount(uint32_t & frameCount) const190 int32_t AudioCapturerAdapterImpl::GetFrameCount(uint32_t &frameCount) const
191 {
192 if (audio_capturer_ == nullptr) {
193 WVLOG_E("audio capturer is nullptr");
194 return AUDIO_NULL_ERROR;
195 }
196 return audio_capturer_->GetFrameCount(frameCount);
197 }
198
GetAudioTime()199 int64_t AudioCapturerAdapterImpl::GetAudioTime()
200 {
201 if (audio_capturer_ == nullptr) {
202 WVLOG_E("audio capturer is nullptr");
203 return AUDIO_NULL_ERROR;
204 }
205 Timestamp timeStamp;
206 audio_capturer_->GetAudioTime(timeStamp, Timestamp::Timestampbase::MONOTONIC);
207 return timeStamp.time.tv_sec * NANOSECONDS_PER_SECOND + timeStamp.time.tv_nsec;
208 }
209
GetAudioSamplingRate(AudioAdapterSamplingRate samplingRate)210 AudioSamplingRate AudioCapturerAdapterImpl::GetAudioSamplingRate(AudioAdapterSamplingRate samplingRate)
211 {
212 auto item = SAMPLING_RATE_MAP.find(samplingRate);
213 if (item == SAMPLING_RATE_MAP.end()) {
214 WVLOG_E("audio sampling rate not found");
215 return AudioSamplingRate::SAMPLE_RATE_44100;
216 }
217 return item->second;
218 }
219
GetAudioEncodingType(AudioAdapterEncodingType encodingType)220 AudioEncodingType AudioCapturerAdapterImpl::GetAudioEncodingType(AudioAdapterEncodingType encodingType)
221 {
222 auto item = ENCODING_TYPE_MAP.find(encodingType);
223 if (item == ENCODING_TYPE_MAP.end()) {
224 WVLOG_E("audio encoding type not found");
225 return AudioEncodingType::ENCODING_INVALID;
226 }
227 return item->second;
228 }
229
GetAudioSampleFormat(AudioAdapterSampleFormat sampleFormat)230 AudioSampleFormat AudioCapturerAdapterImpl::GetAudioSampleFormat(AudioAdapterSampleFormat sampleFormat)
231 {
232 auto item = SAMPLE_FORMAT_MAP.find(sampleFormat);
233 if (item == SAMPLE_FORMAT_MAP.end()) {
234 WVLOG_E("audio sample format not found");
235 return AudioSampleFormat::INVALID_WIDTH;
236 }
237 return item->second;
238 }
239
GetAudioChannel(AudioAdapterChannel channel)240 AudioChannel AudioCapturerAdapterImpl::GetAudioChannel(AudioAdapterChannel channel)
241 {
242 auto item = AUDIO_CHANNEL_MAP.find(channel);
243 if (item == AUDIO_CHANNEL_MAP.end()) {
244 WVLOG_E("audio channel not found");
245 return AudioChannel::STEREO;
246 }
247 return item->second;
248 }
249
GetAudioSourceType(AudioAdapterSourceType sourceType)250 SourceType AudioCapturerAdapterImpl::GetAudioSourceType(AudioAdapterSourceType sourceType)
251 {
252 auto item = SOURCE_TYPE_MAP.find(sourceType);
253 if (item == SOURCE_TYPE_MAP.end()) {
254 WVLOG_E("audio source type not found");
255 return SourceType::SOURCE_TYPE_VOICE_RECOGNITION;
256 }
257 return item->second;
258 }
259 } // namespace OHOS::NWeb