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
16 #include <memory>
17 #include "native_audiostreambuilder.h"
18 #include "OHAudioStreamBuilder.h"
19 #include "OHAudioRenderer.h"
20 #include "OHAudioCapturer.h"
21
22 using OHOS::AudioStandard::OHAudioStreamBuilder;
23 using OHOS::AudioStandard::AudioSampleFormat;
24 using OHOS::AudioStandard::StreamUsage;
25 using OHOS::AudioStandard::AudioEncodingType;
26 using OHOS::AudioStandard::ContentType;
27 using OHOS::AudioStandard::SourceType;
28
29 static const int32_t RENDERER_TYPE = 1;
30 static const int32_t CAPTURER_TYPE = 2;
31
convertBuilder(OH_AudioStreamBuilder * builder)32 static OHOS::AudioStandard::OHAudioStreamBuilder *convertBuilder(OH_AudioStreamBuilder* builder)
33 {
34 return (OHOS::AudioStandard::OHAudioStreamBuilder*) builder;
35 }
36
OH_AudioStreamBuilder_SetSamplingRate(OH_AudioStreamBuilder * builder,int32_t rate)37 OH_AudioStream_Result OH_AudioStreamBuilder_SetSamplingRate(OH_AudioStreamBuilder* builder, int32_t rate)
38 {
39 OHAudioStreamBuilder *audioStreamBuilder = convertBuilder(builder);
40 CHECK_AND_RETURN_RET_LOG(audioStreamBuilder != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert builder failed");
41 return audioStreamBuilder->SetSamplingRate(rate);
42 }
43
OH_AudioStreamBuilder_SetChannelCount(OH_AudioStreamBuilder * builder,int32_t channelCount)44 OH_AudioStream_Result OH_AudioStreamBuilder_SetChannelCount(OH_AudioStreamBuilder* builder, int32_t channelCount)
45 {
46 OHAudioStreamBuilder *audioStreamBuilder = convertBuilder(builder);
47 CHECK_AND_RETURN_RET_LOG(audioStreamBuilder != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert builder failed");
48 return audioStreamBuilder->SetChannelCount(channelCount);
49 }
50
OH_AudioStreamBuilder_SetSampleFormat(OH_AudioStreamBuilder * builder,OH_AudioStream_SampleFormat format)51 OH_AudioStream_Result OH_AudioStreamBuilder_SetSampleFormat(OH_AudioStreamBuilder* builder,
52 OH_AudioStream_SampleFormat format)
53 {
54 OHAudioStreamBuilder *audioStreamBuilder = convertBuilder(builder);
55 CHECK_AND_RETURN_RET_LOG(audioStreamBuilder != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert builder failed");
56 AudioSampleFormat sampleFormat = (AudioSampleFormat)format;
57 return audioStreamBuilder->SetSampleFormat(sampleFormat);
58 }
59
OH_AudioStreamBuilder_SetEncodingType(OH_AudioStreamBuilder * builder,OH_AudioStream_EncodingType encodingType)60 OH_AudioStream_Result OH_AudioStreamBuilder_SetEncodingType(OH_AudioStreamBuilder* builder,
61 OH_AudioStream_EncodingType encodingType)
62 {
63 OHAudioStreamBuilder *audioStreamBuilder = convertBuilder(builder);
64 CHECK_AND_RETURN_RET_LOG(audioStreamBuilder != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert builder failed");
65 AudioEncodingType type = (AudioEncodingType)encodingType;
66 return audioStreamBuilder->SetEncodingType(type);
67 }
68
OH_AudioStreamBuilder_SetLatencyMode(OH_AudioStreamBuilder * builder,OH_AudioStream_LatencyMode latencyMode)69 OH_AudioStream_Result OH_AudioStreamBuilder_SetLatencyMode(OH_AudioStreamBuilder* builder,
70 OH_AudioStream_LatencyMode latencyMode)
71 {
72 OHAudioStreamBuilder *audioStreamBuilder = convertBuilder(builder);
73 CHECK_AND_RETURN_RET_LOG(audioStreamBuilder != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert builder failed");
74 int32_t innerLatencyMode = (int32_t)latencyMode;
75 return audioStreamBuilder->SetLatencyMode(innerLatencyMode);
76 }
77
OH_AudioStreamBuilder_SetRendererInfo(OH_AudioStreamBuilder * builder,OH_AudioStream_Usage usage)78 OH_AudioStream_Result OH_AudioStreamBuilder_SetRendererInfo(OH_AudioStreamBuilder* builder,
79 OH_AudioStream_Usage usage)
80 {
81 OHAudioStreamBuilder *audioStreamBuilder = convertBuilder(builder);
82 CHECK_AND_RETURN_RET_LOG(audioStreamBuilder != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert builder failed");
83 StreamUsage streamUsage = (StreamUsage)usage;
84 ContentType contentType = ContentType::CONTENT_TYPE_MUSIC;
85 return audioStreamBuilder->SetRendererInfo(streamUsage, contentType);
86 }
87
OH_AudioStreamBuilder_SetRendererCallback(OH_AudioStreamBuilder * builder,OH_AudioRenderer_Callbacks callbacks,void * userData)88 OH_AudioStream_Result OH_AudioStreamBuilder_SetRendererCallback(OH_AudioStreamBuilder* builder,
89 OH_AudioRenderer_Callbacks callbacks, void* userData)
90 {
91 OHAudioStreamBuilder *audioStreamBuilder = convertBuilder(builder);
92 CHECK_AND_RETURN_RET_LOG(audioStreamBuilder != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert builder failed");
93 return audioStreamBuilder->SetRendererCallback(callbacks, userData);
94 }
95
OH_AudioStreamBuilder_SetCapturerInfo(OH_AudioStreamBuilder * builder,OH_AudioStream_SourceType sourceType)96 OH_AudioStream_Result OH_AudioStreamBuilder_SetCapturerInfo(OH_AudioStreamBuilder* builder,
97 OH_AudioStream_SourceType sourceType)
98 {
99 OHAudioStreamBuilder *audioStreamBuilder = convertBuilder(builder);
100 CHECK_AND_RETURN_RET_LOG(audioStreamBuilder != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert builder failed");
101 SourceType type = (SourceType)sourceType;
102 return audioStreamBuilder->SetSourceType(type);
103 }
104
105
OH_AudioStreamBuilder_Create(OH_AudioStreamBuilder ** builder,OH_AudioStream_Type type)106 OH_AudioStream_Result OH_AudioStreamBuilder_Create(OH_AudioStreamBuilder** builder, OH_AudioStream_Type type)
107 {
108 int32_t streamType = type == AUDIOSTREAM_TYPE_RENDERER ? RENDERER_TYPE : CAPTURER_TYPE;
109 OHAudioStreamBuilder *streamBuilder = new OHAudioStreamBuilder(streamType);
110
111 *builder = (OH_AudioStreamBuilder*)streamBuilder;
112
113 return AUDIOSTREAM_SUCCESS;
114 }
115
OH_AudioStreamBuilder_SetCapturerCallback(OH_AudioStreamBuilder * builder,OH_AudioCapturer_Callbacks callbacks,void * userData)116 OH_AudioStream_Result OH_AudioStreamBuilder_SetCapturerCallback(OH_AudioStreamBuilder* builder,
117 OH_AudioCapturer_Callbacks callbacks, void* userData)
118 {
119 OHAudioStreamBuilder *audioStreamBuilder = convertBuilder(builder);
120 CHECK_AND_RETURN_RET_LOG(audioStreamBuilder != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert builder failed");
121
122 return audioStreamBuilder->SetCapturerCallback(callbacks, userData);
123 }
124
OH_AudioStreamBuilder_GenerateRenderer(OH_AudioStreamBuilder * builder,OH_AudioRenderer ** audioRenderer)125 OH_AudioStream_Result OH_AudioStreamBuilder_GenerateRenderer(OH_AudioStreamBuilder* builder,
126 OH_AudioRenderer** audioRenderer)
127 {
128 OHAudioStreamBuilder *audioStreamBuilder = convertBuilder(builder);
129 CHECK_AND_RETURN_RET_LOG(audioStreamBuilder != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert builder failed");
130 return audioStreamBuilder->Generate(audioRenderer);
131 }
132
OH_AudioStreamBuilder_GenerateCapturer(OH_AudioStreamBuilder * builder,OH_AudioCapturer ** audioCapturer)133 OH_AudioStream_Result OH_AudioStreamBuilder_GenerateCapturer(OH_AudioStreamBuilder* builder,
134 OH_AudioCapturer** audioCapturer)
135 {
136 OHAudioStreamBuilder *audioStreamBuilder = convertBuilder(builder);
137 CHECK_AND_RETURN_RET_LOG(audioStreamBuilder != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert builder failed");
138 return audioStreamBuilder->Generate(audioCapturer);
139 }
140
OH_AudioStreamBuilder_Destroy(OH_AudioStreamBuilder * builder)141 OH_AudioStream_Result OH_AudioStreamBuilder_Destroy(OH_AudioStreamBuilder* builder)
142 {
143 OHAudioStreamBuilder *audioStreamBuilder = convertBuilder(builder);
144 CHECK_AND_RETURN_RET_LOG(audioStreamBuilder != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert builder failed");
145 if (audioStreamBuilder != nullptr) {
146 delete audioStreamBuilder;
147 audioStreamBuilder = nullptr;
148 return AUDIOSTREAM_SUCCESS;
149 }
150 return AUDIOSTREAM_ERROR_ILLEGAL_STATE;
151 }
152
153 namespace OHOS {
154 namespace AudioStandard {
155
OHAudioStreamBuilder(const int32_t type)156 OHAudioStreamBuilder::OHAudioStreamBuilder(const int32_t type) : streamType_(RENDERER_TYPE)
157 {
158 AUDIO_INFO_LOG("OHAudioStreamBuilder created, type is %{public}d", type);
159 streamType_ = type;
160 }
161
~OHAudioStreamBuilder()162 OHAudioStreamBuilder::~OHAudioStreamBuilder()
163 {
164 AUDIO_INFO_LOG("OHAudioStreamBuilder destroyed, type is %{public}d", streamType_);
165 }
166
SetSamplingRate(int32_t rate)167 OH_AudioStream_Result OHAudioStreamBuilder::SetSamplingRate(int32_t rate)
168 {
169 switch (rate) {
170 case AudioSamplingRate::SAMPLE_RATE_8000:
171 case AudioSamplingRate::SAMPLE_RATE_11025:
172 case AudioSamplingRate::SAMPLE_RATE_12000:
173 case AudioSamplingRate::SAMPLE_RATE_16000:
174 case AudioSamplingRate::SAMPLE_RATE_22050:
175 case AudioSamplingRate::SAMPLE_RATE_24000:
176 case AudioSamplingRate::SAMPLE_RATE_32000:
177 case AudioSamplingRate::SAMPLE_RATE_44100:
178 case AudioSamplingRate::SAMPLE_RATE_48000:
179 case AudioSamplingRate::SAMPLE_RATE_64000:
180 case AudioSamplingRate::SAMPLE_RATE_96000:
181 AUDIO_DEBUG_LOG("sampleFormat input value is valid");
182 break;
183 default:
184 AUDIO_ERR_LOG("sampleFormat input value is invalid");
185 return AUDIOSTREAM_ERROR_INVALID_PARAM;
186 }
187 samplingRate_ =rate;
188 return AUDIOSTREAM_SUCCESS;
189 }
190
SetChannelCount(int32_t channelCount)191 OH_AudioStream_Result OHAudioStreamBuilder::SetChannelCount(int32_t channelCount)
192 {
193 switch (channelCount) {
194 case AudioChannel::MONO:
195 case AudioChannel::STEREO:
196 case AudioChannel::CHANNEL_3:
197 case AudioChannel::CHANNEL_4:
198 case AudioChannel::CHANNEL_5:
199 case AudioChannel::CHANNEL_6:
200 case AudioChannel::CHANNEL_7:
201 case AudioChannel::CHANNEL_8:
202 AUDIO_DEBUG_LOG("channelCount input value is valid");
203 break;
204 default:
205 AUDIO_ERR_LOG("channelCount input value is invalid");
206 return AUDIOSTREAM_ERROR_INVALID_PARAM;
207 }
208 channelCount_ = channelCount;
209 return AUDIOSTREAM_SUCCESS;
210 }
211
SetSampleFormat(AudioSampleFormat sampleFormat)212 OH_AudioStream_Result OHAudioStreamBuilder::SetSampleFormat(AudioSampleFormat sampleFormat)
213 {
214 sampleFormat_ = sampleFormat;
215 return AUDIOSTREAM_SUCCESS;
216 }
217
SetRendererInfo(StreamUsage usage,ContentType contentType)218 OH_AudioStream_Result OHAudioStreamBuilder::SetRendererInfo(StreamUsage usage, ContentType contentType)
219 {
220 if (streamType_ == CAPTURER_TYPE || usage == StreamUsage::STREAM_USAGE_UNKNOWN
221 || contentType == ContentType::CONTENT_TYPE_UNKNOWN) {
222 AUDIO_ERR_LOG("Error, invalid type input");
223 return AUDIOSTREAM_ERROR_INVALID_PARAM;
224 }
225 usage_ = usage;
226 contentType_ = contentType;
227 return AUDIOSTREAM_SUCCESS;
228 }
229
SetEncodingType(AudioEncodingType encodingType)230 OH_AudioStream_Result OHAudioStreamBuilder::SetEncodingType(AudioEncodingType encodingType)
231 {
232 encodingType_ = encodingType;
233 return AUDIOSTREAM_SUCCESS;
234 }
235
SetSourceType(SourceType type)236 OH_AudioStream_Result OHAudioStreamBuilder::SetSourceType(SourceType type)
237 {
238 if (streamType_ == RENDERER_TYPE || type == SOURCE_TYPE_INVALID) {
239 AUDIO_ERR_LOG("Error, invalid type input");
240 return AUDIOSTREAM_ERROR_INVALID_PARAM;
241 }
242
243 sourceType_ = type;
244 return AUDIOSTREAM_SUCCESS;
245 }
246
247
SetLatencyMode(int32_t latencyMode)248 OH_AudioStream_Result OHAudioStreamBuilder::SetLatencyMode(int32_t latencyMode)
249 {
250 latencyMode_ = latencyMode;
251 return AUDIOSTREAM_SUCCESS;
252 }
253
Generate(OH_AudioRenderer ** renderer)254 OH_AudioStream_Result OHAudioStreamBuilder::Generate(OH_AudioRenderer** renderer)
255 {
256 AUDIO_INFO_LOG("Generate OHAudioRenderer");
257 if (streamType_ != RENDERER_TYPE) {
258 AUDIO_ERR_LOG("Error, invalid type input");
259 return AUDIOSTREAM_ERROR_INVALID_PARAM;
260 }
261
262 AudioStreamInfo streamInfo = {
263 (AudioSamplingRate)samplingRate_,
264 encodingType_,
265 sampleFormat_,
266 (AudioChannel)channelCount_
267 };
268
269 AudioRendererInfo rendererInfo = {
270 contentType_,
271 usage_,
272 latencyMode_
273 };
274
275 AudioRendererOptions options = {
276 streamInfo,
277 rendererInfo
278 };
279
280 OHAudioRenderer *audioRenderer = new OHAudioRenderer();
281 if (audioRenderer->Initialize(options)) {
282 audioRenderer->SetRendererCallback(rendererCallbacks_, userData_);
283 *renderer = (OH_AudioRenderer*)audioRenderer;
284 return AUDIOSTREAM_SUCCESS;
285 }
286 AUDIO_ERR_LOG("Create OHAudioRenderer failed");
287 delete audioRenderer;
288 audioRenderer = nullptr;
289 return AUDIOSTREAM_ERROR_INVALID_PARAM;
290 }
291
Generate(OH_AudioCapturer ** capturer)292 OH_AudioStream_Result OHAudioStreamBuilder::Generate(OH_AudioCapturer** capturer)
293 {
294 AUDIO_INFO_LOG("Generate OHAudioCapturer");
295 if (streamType_ != CAPTURER_TYPE) {
296 AUDIO_ERR_LOG("Error, invalid type input");
297 return AUDIOSTREAM_ERROR_INVALID_PARAM;
298 }
299 AudioStreamInfo streamInfo = {
300 (AudioSamplingRate)samplingRate_,
301 encodingType_,
302 sampleFormat_,
303 (AudioChannel)channelCount_
304 };
305
306 AudioCapturerInfo capturerInfo = {
307 sourceType_,
308 latencyMode_
309 };
310
311 AudioCapturerOptions options = {
312 streamInfo,
313 capturerInfo
314 };
315
316 OHAudioCapturer *audioCapturer = new OHAudioCapturer();
317 if (audioCapturer->Initialize(options)) {
318 audioCapturer->SetCapturerCallback(capturerCallbacks_, userData_);
319 *capturer = (OH_AudioCapturer*)audioCapturer;
320 return AUDIOSTREAM_SUCCESS;
321 }
322 AUDIO_ERR_LOG("Create OHAudioCapturer failed");
323 delete audioCapturer;
324 audioCapturer = nullptr;
325 return AUDIOSTREAM_ERROR_INVALID_PARAM;
326 }
327
SetRendererCallback(OH_AudioRenderer_Callbacks callbacks,void * userData)328 OH_AudioStream_Result OHAudioStreamBuilder::SetRendererCallback(OH_AudioRenderer_Callbacks callbacks, void* userData)
329 {
330 if (streamType_ == CAPTURER_TYPE) {
331 AUDIO_ERR_LOG("SetRendererCallback Error, invalid type input");
332 return AUDIOSTREAM_ERROR_INVALID_PARAM;
333 }
334 rendererCallbacks_ = callbacks;
335 userData_ = userData;
336 return AUDIOSTREAM_SUCCESS;
337 }
338
SetCapturerCallback(OH_AudioCapturer_Callbacks callbacks,void * userData)339 OH_AudioStream_Result OHAudioStreamBuilder::SetCapturerCallback(OH_AudioCapturer_Callbacks callbacks, void* userData)
340 {
341 if (streamType_ == RENDERER_TYPE) {
342 AUDIO_ERR_LOG("SetCapturerCallback Error, invalid type input");
343 return AUDIOSTREAM_ERROR_INVALID_PARAM;
344 }
345 capturerCallbacks_ = callbacks;
346 userData_ = userData;
347 return AUDIOSTREAM_SUCCESS;
348 }
349 } // namespace AudioStandard
350 } // namespace OHOS
351