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 <common.h>
17
18 using namespace std;
19 using namespace OHOS;
20 using namespace OHOS::AudioStandard;
21
22 namespace OHOS {
23 namespace AudioStandard {
AudioCapturerAdapter()24 AudioCapturerAdapter::AudioCapturerAdapter() { }
25
~AudioCapturerAdapter()26 AudioCapturerAdapter::~AudioCapturerAdapter() { }
27
GetInstance()28 AudioCapturerAdapter* AudioCapturerAdapter::GetInstance()
29 {
30 static AudioCapturerAdapter audioCapturerAdapter_;
31 return &audioCapturerAdapter_;
32 }
33
GetAudioCapturerById(SLuint32 id)34 AudioCapturer *AudioCapturerAdapter::GetAudioCapturerById(SLuint32 id)
35 {
36 AUDIO_INFO_LOG("AudioCapturerAdapter::GetAudioCapturerById: %{public}lu", id);
37 return captureMap_.find(id)->second;
38 }
39
EraseAudioCapturerById(SLuint32 id)40 void AudioCapturerAdapter::EraseAudioCapturerById(SLuint32 id)
41 {
42 AUDIO_INFO_LOG("AudioCapturerAdapter::EraseAudioCapturerById: %{public}lu", id);
43 captureMap_.erase(id);
44 callbackMap_.erase(id);
45 }
46
CreateAudioCapturerAdapter(SLuint32 id,SLDataSource * dataSource,SLDataSink * dataSink,AudioStreamType streamType)47 SLresult AudioCapturerAdapter::CreateAudioCapturerAdapter(SLuint32 id, SLDataSource *dataSource,
48 SLDataSink *dataSink, AudioStreamType streamType)
49 {
50 AUDIO_INFO_LOG("AudioCapturerAdapter::CreateAudioCapturerAdapter .");
51 SLDataFormat_PCM *pcmFormat = (SLDataFormat_PCM *)dataSink->pFormat;
52 AudioCapturerParams capturerParams;
53 ConvertPcmFormat(pcmFormat, &capturerParams);
54 streamType = AudioStreamType::STREAM_MUSIC;
55 AudioCapturerOptions capturerOptions;
56 capturerOptions.streamInfo.samplingRate = capturerParams.samplingRate;
57 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
58 capturerOptions.streamInfo.format = capturerParams.audioSampleFormat;
59 capturerOptions.streamInfo.channels = capturerParams.audioChannel;
60 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
61 capturerOptions.capturerInfo.capturerFlags = 0;
62 string cachePath = "/data/storage/el2/base/temp";
63 unique_ptr<AudioCapturer> capturerHolder = AudioCapturer::Create(capturerOptions, cachePath.c_str());
64 if (!capturerHolder) {
65 AUDIO_ERR_LOG("AudioCapturerAdapter::CreateAudioCapturerAdapter fail, ID: %{public}lu", id);
66 return SL_RESULT_RESOURCE_ERROR;
67 }
68 capturerHolder->SetParams(capturerParams);
69 AudioCapturer *capturer = capturerHolder.release();
70 AUDIO_INFO_LOG("AudioCapturerAdapter::CreateAudioCapturerAdapter ID: %{public}lu", id);
71 capturer->SetCaptureMode(CAPTURE_MODE_CALLBACK);
72 captureMap_.insert(make_pair(id, capturer));
73 return SL_RESULT_SUCCESS;
74 }
75
SetCaptureStateAdapter(SLuint32 id,SLuint32 state)76 SLresult AudioCapturerAdapter::SetCaptureStateAdapter(SLuint32 id, SLuint32 state)
77 {
78 AUDIO_INFO_LOG("AudioCapturerAdapter::SetCaptureStateAdapter state: %{public}lu.", state);
79 AudioCapturer *audioCapturer = GetAudioCapturerById(id);
80 if (audioCapturer == nullptr) {
81 AUDIO_ERR_LOG("AudioCapturerAdapter::SetCaptureStateAdapter invalid id.");
82 return SL_RESULT_RESOURCE_ERROR;
83 }
84
85 SLresult slResult = SL_RESULT_SUCCESS;
86 bool result = false;
87 bool rtStop = false;
88 bool rtRelease = false;
89 int32_t rtClear = -1;
90 switch (state) {
91 case SL_RECORDSTATE_RECORDING:
92 result = audioCapturer->Start();
93 break;
94 case SL_RECORDSTATE_PAUSED:
95 result = audioCapturer->Pause();
96 break;
97 case SL_RECORDSTATE_STOPPED: {
98 rtStop = audioCapturer->Stop();
99 rtClear = audioCapturer->Clear();
100 rtRelease = audioCapturer->Release();
101 result = rtStop && !rtClear && rtRelease;
102 break;
103 }
104 default:
105 AUDIO_ERR_LOG("AudioPlayerAdapter::play state not supported.");
106 break;
107 }
108 slResult = result ? SL_RESULT_SUCCESS : SL_RESULT_RESOURCE_ERROR;
109 return slResult;
110 }
111
GetCaptureStateAdapter(SLuint32 id,SLuint32 * state)112 SLresult AudioCapturerAdapter::GetCaptureStateAdapter(SLuint32 id, SLuint32 *state)
113 {
114 AudioCapturer *audioCapturer = GetAudioCapturerById(id);
115 if (audioCapturer == nullptr) {
116 AUDIO_ERR_LOG("AudioCapturerAdapter::GetCaptureStateAdapter invalid id.");
117 return SL_RESULT_RESOURCE_ERROR;
118 }
119
120 CapturerState capturerState = audioCapturer->GetStatus();
121 switch (capturerState) {
122 case CAPTURER_RUNNING:
123 *state = SL_RECORDSTATE_RECORDING;
124 break;
125 case CAPTURER_PAUSED:
126 *state = SL_RECORDSTATE_PAUSED;
127 break;
128 case CAPTURER_STOPPED:
129 *state = SL_RECORDSTATE_STOPPED;
130 break;
131 default:
132 *state = -1;
133 break;
134 }
135 AUDIO_INFO_LOG("AudioCapturerAdapter::GetCaptureStateAdapter state: %{public}lu.", *state);
136 return SL_RESULT_SUCCESS;
137 }
138
EnqueueAdapter(SLuint32 id,const void * buffer,SLuint32 size)139 SLresult AudioCapturerAdapter::EnqueueAdapter(SLuint32 id, const void *buffer, SLuint32 size)
140 {
141 AudioCapturer *audioCapturer = GetAudioCapturerById(id);
142 if (audioCapturer == nullptr) {
143 AUDIO_ERR_LOG("AudioCapturerAdapter::EnqueueAdapter invalid id.");
144 return SL_RESULT_RESOURCE_ERROR;
145 }
146
147 BufferDesc bufDesc = {};
148 bufDesc.buffer = (uint8_t*) buffer;
149 bufDesc.bufLength = size;
150 AUDIO_INFO_LOG("AudioCapturerAdapter::EnqueueAdapter bufferlength: %{public}zu", bufDesc.bufLength);
151 audioCapturer->Enqueue(bufDesc);
152 return SL_RESULT_SUCCESS;
153 }
154
ClearAdapter(SLuint32 id)155 SLresult AudioCapturerAdapter::ClearAdapter(SLuint32 id)
156 {
157 AudioCapturer *audioCapturer = GetAudioCapturerById(id);
158 if (audioCapturer == nullptr) {
159 AUDIO_ERR_LOG("AudioCapturerAdapter::ClearAdapter invalid id.");
160 return SL_RESULT_RESOURCE_ERROR;
161 }
162
163 audioCapturer->Clear();
164 return SL_RESULT_SUCCESS;
165 }
166
GetStateAdapter(SLuint32 id,SLOHBufferQueueState * state)167 SLresult AudioCapturerAdapter::GetStateAdapter(SLuint32 id, SLOHBufferQueueState *state)
168 {
169 AudioCapturer *audioCapturer = GetAudioCapturerById(id);
170 if (audioCapturer == nullptr) {
171 AUDIO_ERR_LOG("AudioCapturerAdapter::GetStateAdapter invalid id.");
172 return SL_RESULT_RESOURCE_ERROR;
173 }
174
175 BufferQueueState queueState = {0, 0};
176 audioCapturer->GetBufQueueState(queueState);
177 state->count = queueState.numBuffers;
178 state->index = queueState.currentIndex;
179 return SL_RESULT_SUCCESS;
180 }
181
GetBufferAdapter(SLuint32 id,SLuint8 ** buffer,SLuint32 * size)182 SLresult AudioCapturerAdapter::GetBufferAdapter(SLuint32 id, SLuint8 **buffer, SLuint32 *size)
183 {
184 AudioCapturer *audioCapturer = GetAudioCapturerById(id);
185 if (audioCapturer == nullptr) {
186 AUDIO_ERR_LOG("AudioCapturerAdapter::GetBufferAdapter invalid id.");
187 return SL_RESULT_RESOURCE_ERROR;
188 }
189
190 BufferDesc bufferDesc = {};
191 audioCapturer->GetBufferDesc(bufferDesc);
192 *buffer = bufferDesc.buffer;
193 *size = bufferDesc.bufLength;
194 return SL_RESULT_SUCCESS;
195 }
196
RegisterCallbackAdapter(SLOHBufferQueueItf itf,SlOHBufferQueueCallback callback,void * pContext)197 SLresult AudioCapturerAdapter::RegisterCallbackAdapter(SLOHBufferQueueItf itf,
198 SlOHBufferQueueCallback callback, void *pContext)
199 {
200 IOHBufferQueue *thiz = (IOHBufferQueue *)itf;
201 AudioCapturer *audioCapturer = GetAudioCapturerById(thiz->mId);
202 if (audioCapturer == nullptr) {
203 AUDIO_ERR_LOG("AudioCapturerAdapter::RegisterCallbackAdapter invalid id.");
204 return SL_RESULT_RESOURCE_ERROR;
205 }
206
207 callbackPtr_ = make_shared<ReadOrWriteCallbackAdapter>(callback, itf, pContext);
208 audioCapturer->SetCapturerReadCallback(static_pointer_cast<AudioCapturerReadCallback>(callbackPtr_));
209 callbackMap_.insert(make_pair(thiz->mId, callbackPtr_));
210 return SL_RESULT_SUCCESS;
211 }
212
ConvertPcmFormat(SLDataFormat_PCM * slFormat,AudioCapturerParams * capturerParams)213 void AudioCapturerAdapter::ConvertPcmFormat(SLDataFormat_PCM *slFormat, AudioCapturerParams *capturerParams)
214 {
215 AudioSampleFormat sampleFormat = SlToOhosSampelFormat(slFormat);
216 AudioSamplingRate sampleRate = SlToOhosSamplingRate(slFormat);
217 AudioChannel channelCount = SlToOhosChannel(slFormat);
218 capturerParams->audioSampleFormat = sampleFormat;
219 capturerParams->samplingRate = sampleRate;
220 capturerParams->audioChannel = channelCount;
221 capturerParams->audioEncoding = ENCODING_PCM;
222 }
223
SlToOhosSampelFormat(SLDataFormat_PCM * pcmFormat)224 AudioSampleFormat AudioCapturerAdapter::SlToOhosSampelFormat(SLDataFormat_PCM *pcmFormat)
225 {
226 AudioSampleFormat sampleFormat;
227 switch (pcmFormat->bitsPerSample) {
228 case SL_PCMSAMPLEFORMAT_FIXED_8:
229 sampleFormat = SAMPLE_U8;
230 break;
231 case SL_PCMSAMPLEFORMAT_FIXED_16:
232 sampleFormat = SAMPLE_S16LE;
233 break;
234 case SL_PCMSAMPLEFORMAT_FIXED_20:
235 sampleFormat = INVALID_WIDTH;
236 break;
237 case SL_PCMSAMPLEFORMAT_FIXED_24:
238 sampleFormat = SAMPLE_S24LE;
239 break;
240 case SL_PCMSAMPLEFORMAT_FIXED_28:
241 sampleFormat = INVALID_WIDTH;
242 break;
243 case SL_PCMSAMPLEFORMAT_FIXED_32:
244 sampleFormat = SAMPLE_S32LE;
245 break;
246 default:
247 sampleFormat = INVALID_WIDTH;
248 }
249 return sampleFormat;
250 }
251
SlToOhosSamplingRate(SLDataFormat_PCM * pcmFormat)252 AudioSamplingRate AudioCapturerAdapter::SlToOhosSamplingRate(SLDataFormat_PCM *pcmFormat)
253 {
254 AudioSamplingRate sampleRate;
255 switch (pcmFormat->samplesPerSec) {
256 case SL_SAMPLINGRATE_8:
257 sampleRate = SAMPLE_RATE_8000;
258 break;
259 case SL_SAMPLINGRATE_11_025:
260 sampleRate = SAMPLE_RATE_11025;
261 break;
262 case SL_SAMPLINGRATE_12:
263 sampleRate = SAMPLE_RATE_12000;
264 break;
265 case SL_SAMPLINGRATE_16:
266 sampleRate = SAMPLE_RATE_16000;
267 break;
268 case SL_SAMPLINGRATE_22_05:
269 sampleRate = SAMPLE_RATE_22050;
270 break;
271 case SL_SAMPLINGRATE_24:
272 sampleRate = SAMPLE_RATE_24000;
273 break;
274 case SL_SAMPLINGRATE_32:
275 sampleRate = SAMPLE_RATE_32000;
276 break;
277 case SL_SAMPLINGRATE_44_1:
278 sampleRate = SAMPLE_RATE_44100;
279 break;
280 case SL_SAMPLINGRATE_48:
281 sampleRate = SAMPLE_RATE_48000;
282 break;
283 case SL_SAMPLINGRATE_64:
284 sampleRate = SAMPLE_RATE_64000;
285 break;
286 case SL_SAMPLINGRATE_88_2:
287 sampleRate = SAMPLE_RATE_44100;
288 break;
289 case SL_SAMPLINGRATE_96:
290 sampleRate = SAMPLE_RATE_96000;
291 break;
292 case SL_SAMPLINGRATE_192:
293 sampleRate = SAMPLE_RATE_44100;
294 break;
295 default: {
296 AUDIO_ERR_LOG("AudioCapturerAdapter::SlToOhosSamplingRate mismatch, use default.");
297 sampleRate = SAMPLE_RATE_44100;
298 }
299 }
300 return sampleRate;
301 }
302
SlToOhosChannel(SLDataFormat_PCM * pcmFormat)303 AudioChannel AudioCapturerAdapter::SlToOhosChannel(SLDataFormat_PCM *pcmFormat)
304 {
305 AudioChannel channelCount;
306 switch (pcmFormat->numChannels) {
307 case MONO:
308 channelCount = MONO;
309 break;
310 case STEREO:
311 channelCount = STEREO;
312 break;
313 default:
314 channelCount = MONO;
315 AUDIO_ERR_LOG("AudioPlayerAdapter::channel count not supported ");
316 }
317 return channelCount;
318 }
319 }
320 }
321