2 * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
18 #include "cpp_audio_io.h"
19 #include <sound_manager_internal.h>
21 #include "CAudioIODef.h"
23 #include <system_info.h>
25 #define FEATURE_MICROPHONE "http://tizen.org/feature/microphone"
28 using namespace tizen_media_audio;
34 * Name : audio_io_interrupted_cb_s
35 * Declaration : Keeps user callback pointer and user data for delivering an interrupt event
37 typedef struct audio_io_interrupted_cb_s {
39 audio_io_interrupted_cb onInterrupt;
41 audio_io_interrupted_cb_s() : user_data(NULL), onInterrupt(NULL)
43 } audio_io_interrupted_cb_s;
48 * Name : audio_io_stream_cb_s
49 * Declaration : Keeps user callback pointer and user data for delivering an stream event
51 typedef struct audio_io_stream_cb_s {
53 audio_in_stream_cb onStream;
55 audio_io_stream_cb_s() : user_data(NULL), onStream(NULL)
57 } audio_io_stream_cb_s;
62 * Name : audio_io_state_changed_cb_s
63 * Declaration : Keeps user callback pointer and user data for delivering an state changed event
65 typedef struct audio_io_state_changed_cb_s {
67 audio_in_state_changed_cb onStateChanged;
69 audio_io_state_changed_cb_s() : user_data(NULL), onStateChanged(NULL)
71 } audio_io_state_changed_cb_s;
77 * Declaration : An handle of AudioIO
78 * The handle has two struct for user callback
79 * And the handle has a pointer of private audioIO object
80 * The CAudioIO is a abstract class object about Input and Output
82 typedef struct audio_io_s {
83 CAudioIO* audioIoHandle;
84 audio_io_interrupted_cb_s interrupt_callback;
85 audio_io_stream_cb_s stream_callback;
86 audio_io_state_changed_cb_s state_changed_callback;
88 audio_io_s() : audioIoHandle(NULL)
96 static audio_io_error_e __convert_CAudioError(CAudioError& error) {
97 audio_io_error_e ret = AUDIO_IO_ERROR_NONE;
98 CAudioError::EError err = error.getError();
101 case CAudioError::EError::ERROR_NONE:
102 ret = AUDIO_IO_ERROR_NONE;
104 case CAudioError::EError::ERROR_INVALID_ARGUMENT:
105 case CAudioError::EError::ERROR_INVALID_HANDLE:
106 case CAudioError::EError::ERROR_INVALID_SAMPLERATE:
107 case CAudioError::EError::ERROR_INVALID_CHANNEL:
108 case CAudioError::EError::ERROR_INVALID_FORMAT:
109 ret = AUDIO_IO_ERROR_INVALID_PARAMETER;
111 case CAudioError::EError::ERROR_DEVICE_NOT_OPENED:
112 ret = AUDIO_IO_ERROR_DEVICE_NOT_OPENED;
114 case CAudioError::EError::ERROR_DEVICE_NOT_CLOSED:
115 ret = AUDIO_IO_ERROR_DEVICE_NOT_CLOSED;
117 case CAudioError::EError::ERROR_PERMISSION_DENIED:
118 ret = AUDIO_IO_ERROR_PERMISSION_DENIED;
120 case CAudioError::EError::ERROR_DEVICE_POLICY_RESTRICTION:
121 ret = AUDIO_IO_ERROR_DEVICE_POLICY_RESTRICTION;
123 case CAudioError::EError::ERROR_NOT_SUPPORTED:
124 ret = AUDIO_IO_ERROR_NOT_SUPPORTED;
126 case CAudioError::EError::ERROR_NOT_SUPPORTED_TYPE:
127 ret = AUDIO_IO_ERROR_NOT_SUPPORTED_TYPE;
129 case CAudioError::EError::ERROR_MAX:
130 case CAudioError::EError::ERROR_INTERNAL_OPERATION:
131 case CAudioError::EError::ERROR_NOT_INITIALIZED:
132 case CAudioError::EError::ERROR_FAILED_OPERATION:
133 case CAudioError::EError::ERROR_INVALID_OPERATION:
134 ret = AUDIO_IO_ERROR_INVALID_OPERATION;
136 case CAudioError::EError::ERROR_INVALID_STATE:
137 ret = AUDIO_IO_ERROR_INVALID_STATE;
139 case CAudioError::EError::ERROR_OUT_OF_MEMORY:
140 case CAudioError::EError::ERROR_INVALID_POINTER:
141 ret = AUDIO_IO_ERROR_INVALID_BUFFER;
143 case CAudioError::EError::ERROR_POLICY_BLOCKED:
144 case CAudioError::EError::ERROR_POLICY_INTERRUPTED:
145 case CAudioError::EError::ERROR_POLICY_DUPLICATED:
146 ret = AUDIO_IO_ERROR_SOUND_POLICY;
153 static void __convert_channel_2_audio_info_channel(const audio_channel_e& src_channel,
154 CAudioInfo::EChannel& dst_channel) {
155 switch (src_channel) {
156 case AUDIO_CHANNEL_MONO:
157 dst_channel = CAudioInfo::EChannel::CHANNEL_MONO;
159 case AUDIO_CHANNEL_STEREO:
160 dst_channel = CAudioInfo::EChannel::CHANNEL_STEREO;
163 dst_channel = CAudioInfo::EChannel::CHANNEL_MONO;
168 static void __convert_audio_info_channel_2_channel(const CAudioInfo::EChannel& src_channel,
169 audio_channel_e& dst_channel) {
170 switch (src_channel) {
171 case CAudioInfo::EChannel::CHANNEL_MONO:
172 dst_channel = AUDIO_CHANNEL_MONO;
174 case CAudioInfo::EChannel::CHANNEL_STEREO:
175 dst_channel = AUDIO_CHANNEL_STEREO;
178 dst_channel = AUDIO_CHANNEL_MONO;
183 static void __convert_sample_type_2_audio_info_sample_type(const audio_sample_type_e& src_type,
184 CAudioInfo::ESampleType& dst_type) {
186 case AUDIO_SAMPLE_TYPE_U8:
187 dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_U8;
189 case AUDIO_SAMPLE_TYPE_S16_LE:
190 dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_S16_LE;
193 dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_U8;
198 static void __convert_audio_info_sample_type_2_sample_type(const CAudioInfo::ESampleType& src_type,
199 audio_sample_type_e& dst_type) {
201 case CAudioInfo::ESampleType::SAMPLE_TYPE_U8:
202 dst_type = AUDIO_SAMPLE_TYPE_U8;
204 case CAudioInfo::ESampleType::SAMPLE_TYPE_S16_LE:
205 dst_type = AUDIO_SAMPLE_TYPE_S16_LE;
208 dst_type = AUDIO_SAMPLE_TYPE_U8;
213 static void __convert_sound_type_2_audio_info_audio_type(const sound_type_e& src_type,
214 CAudioInfo::EAudioType& dst_type) {
216 case SOUND_TYPE_SYSTEM:
217 dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_SYSTEM;
219 case SOUND_TYPE_NOTIFICATION:
220 dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_NOTIFICATION;
222 case SOUND_TYPE_ALARM:
223 dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_ALARM;
225 case SOUND_TYPE_RINGTONE:
226 dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_RINGTONE_VOIP;
228 case SOUND_TYPE_MEDIA:
229 dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA;
231 case SOUND_TYPE_CALL:
232 dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_SYSTEM;
234 case SOUND_TYPE_VOIP:
235 dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOIP;
237 case SOUND_TYPE_VOICE:
238 dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOICE_INFORMATION;
241 dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA;
246 static void __convert_audio_info_audio_type_2_sound_type(const CAudioInfo::EAudioType& src_type,
247 sound_type_e& dst_type) {
249 case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA:
250 dst_type = SOUND_TYPE_MEDIA;
252 case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_SYSTEM:
253 dst_type = SOUND_TYPE_SYSTEM;
255 case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_ALARM:
256 dst_type = SOUND_TYPE_ALARM;
258 case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_NOTIFICATION:
259 case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_EMERGENCY:
260 dst_type = SOUND_TYPE_NOTIFICATION;
262 case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOICE_INFORMATION:
263 dst_type = SOUND_TYPE_VOICE;
265 case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_RINGTONE_VOIP:
266 dst_type = SOUND_TYPE_RINGTONE;
268 case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOIP:
269 dst_type = SOUND_TYPE_VOIP;
272 dst_type = SOUND_TYPE_MEDIA;
277 static audio_io_state_e __convert_state_type(const CAudioInfo::EAudioIOState src_state) {
278 audio_io_state_e dst_state;
281 case CAudioInfo::EAudioIOState::AUDIO_IO_STATE_NONE:
282 dst_state = AUDIO_IO_STATE_IDLE;
284 case CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE:
285 dst_state = AUDIO_IO_STATE_IDLE;
287 case CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING:
288 dst_state = AUDIO_IO_STATE_RUNNING;
290 case CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED:
291 dst_state = AUDIO_IO_STATE_PAUSED;
294 dst_state = AUDIO_IO_STATE_IDLE;
300 static void __check_audio_param(int sample_rate, audio_channel_e channel, audio_sample_type_e type) throw(CAudioError) {
301 if (sample_rate < 0) {
302 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Invalid sample rate :%d", sample_rate);
305 if (channel != AUDIO_CHANNEL_MONO && channel != AUDIO_CHANNEL_STEREO) {
306 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Invalid channel :%d", channel);
309 if (type != AUDIO_SAMPLE_TYPE_U8 && type != AUDIO_SAMPLE_TYPE_S16_LE) {
310 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Invalid sample type :%d", type);
314 static void __check_audio_param(int sample_rate, audio_channel_e channel, audio_sample_type_e type, sound_type_e sound_type) throw(CAudioError) {
315 __check_audio_param(sample_rate, channel, type);
317 if (sound_type < SOUND_TYPE_SYSTEM || sound_type > SOUND_TYPE_VOICE) {
318 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Invalid sound type : %d", sound_type);
322 static CAudioInfo __generate_audio_input_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type) throw(CAudioError) {
323 CAudioInfo::EChannel dstChannel;
324 CAudioInfo::ESampleType dstSampleType;
325 CAudioInfo::EAudioType dstAudioType = CAudioInfo::EAudioType::AUDIO_IN_TYPE_MEDIA;
327 __convert_channel_2_audio_info_channel(channel, dstChannel);
328 __convert_sample_type_2_audio_info_sample_type(sample_type, dstSampleType);
330 return CAudioInfo(sampleRate, dstChannel, dstSampleType, dstAudioType, -1);
333 static CAudioInfo __generate_audio_input_loopback_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type) throw(CAudioError) {
334 CAudioInfo::EChannel dstChannel;
335 CAudioInfo::ESampleType dstSampleType;
336 CAudioInfo::EAudioType dstAudioType = CAudioInfo::EAudioType::AUDIO_IN_TYPE_LOOPBACK;
338 __convert_channel_2_audio_info_channel(channel, dstChannel);
339 __convert_sample_type_2_audio_info_sample_type(sample_type, dstSampleType);
341 return CAudioInfo(sampleRate, dstChannel, dstSampleType, dstAudioType, -1);
344 static CAudioInfo __generate_audio_output_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type, sound_type_e sound_type) throw(CAudioError) {
345 CAudioInfo::EChannel dstChannel;
346 CAudioInfo::ESampleType dstSampleType;
347 CAudioInfo::EAudioType dstAudioType;
349 __convert_channel_2_audio_info_channel(channel, dstChannel);
350 __convert_sample_type_2_audio_info_sample_type(sample_type, dstSampleType);
351 __convert_sound_type_2_audio_info_audio_type(sound_type, dstAudioType);
353 return CAudioInfo(sampleRate, dstChannel, dstSampleType, dstAudioType, -1);
356 static audio_io_interrupted_code_e __convert_interrupted_code(IAudioSessionEventListener::EInterruptCode code) {
358 case IAudioSessionEventListener::EInterruptCode::INTERRUPT_COMPLETED:
359 return AUDIO_IO_INTERRUPTED_COMPLETED;
360 case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_CALL:
361 return AUDIO_IO_INTERRUPTED_BY_CALL;
362 case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_EARJACK_UNPLUG:
363 return AUDIO_IO_INTERRUPTED_BY_EARJACK_UNPLUG;
364 case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_RESOURCE_CONFLICT:
365 return AUDIO_IO_INTERRUPTED_BY_RESOURCE_CONFLICT;
366 case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_ALARM:
367 return AUDIO_IO_INTERRUPTED_BY_ALARM;
368 case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_EMERGENCY:
369 return AUDIO_IO_INTERRUPTED_BY_EMERGENCY;
370 case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_NOTIFICATION:
371 return AUDIO_IO_INTERRUPTED_BY_NOTIFICATION;
372 case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_MEDIA:
373 case IAudioSessionEventListener::EInterruptCode::INTERRUPT_MAX:
375 return AUDIO_IO_INTERRUPTED_BY_MEDIA;
380 * Implements CAPI functions
382 int cpp_audio_in_create(int sample_rate, audio_channel_e channel, audio_sample_type_e type, audio_in_h *input) {
383 audio_io_s* handle = NULL;
384 bool mic_enable = false;
388 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
389 "Parameters are NULL input:%p", input);
392 __check_audio_param(sample_rate, channel, type);
394 /* If MIC is not supported, return NOT_SUPPORTED error */
395 ret = system_info_get_platform_bool(FEATURE_MICROPHONE, &mic_enable);
396 AUDIO_IO_LOGD("system_info_platform [%s]=[%d], ret[%d]", FEATURE_MICROPHONE, mic_enable, ret);
397 if (ret != SYSTEM_INFO_ERROR_NONE || !mic_enable) {
398 THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "System doesn't support microphone!");
401 handle = new audio_io_s;
402 if (handle == NULL) {
403 THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
406 CAudioInfo audioInfo = __generate_audio_input_info(sample_rate, channel, type);
408 handle->audioIoHandle = new CAudioInput(audioInfo);
409 if (handle->audioIoHandle == NULL) {
410 THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
413 handle->audioIoHandle->initialize();
416 } catch (CAudioError e) {
417 AUDIO_IO_LOGE("%s", e.getErrorMsg());
419 VALID_POINTER_START(handle)
420 SAFE_FINALIZE(handle->audioIoHandle);
421 SAFE_DELETE(handle->audioIoHandle);
425 VALID_POINTER_START(input)
429 return __convert_CAudioError(e);
432 return AUDIO_IO_ERROR_NONE;
435 int cpp_audio_in_create_loopback(int sample_rate, audio_channel_e channel, audio_sample_type_e type , audio_in_h* input) {
436 audio_io_s* handle = NULL;
439 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
440 "Parameters are NULL input:%p", input);
443 __check_audio_param(sample_rate, channel, type);
445 handle = new audio_io_s;
446 if (handle == NULL) {
447 THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
450 CAudioInfo audioInfo = __generate_audio_input_loopback_info(sample_rate, channel, type);
452 handle->audioIoHandle = new CAudioInput(audioInfo);
453 if (handle->audioIoHandle == NULL) {
454 THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
457 handle->audioIoHandle->initialize();
460 } catch (CAudioError e) {
461 AUDIO_IO_LOGE("%s", e.getErrorMsg());
463 VALID_POINTER_START(handle)
464 SAFE_FINALIZE(handle->audioIoHandle);
465 SAFE_DELETE(handle->audioIoHandle);
469 VALID_POINTER_START(input)
473 return __convert_CAudioError(e);
476 return AUDIO_IO_ERROR_NONE;
479 int cpp_audio_in_destroy(audio_in_h input) {
480 audio_io_s* handle = static_cast<audio_io_s*>(input);
483 if (handle == NULL) {
484 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
485 "Parameters are NULL input:%p", input);
487 assert(handle->audioIoHandle);
489 /* Internal unprepare for backward compatibility */
490 handle->audioIoHandle->unprepare();
492 SAFE_FINALIZE(handle->audioIoHandle);
493 SAFE_DELETE(handle->audioIoHandle);
495 } catch (CAudioError e) {
496 AUDIO_IO_LOGE("%s", e.getErrorMsg());
497 return __convert_CAudioError(e);
500 return AUDIO_IO_ERROR_NONE;
503 int cpp_audio_in_set_sound_stream_info(audio_in_h input, sound_stream_info_h stream_info) {
504 audio_io_s* handle = static_cast<audio_io_s*>(input);
507 if (handle == NULL || stream_info == NULL) {
508 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
509 "Parameters are NULL input:%p, stream_info:%p", input, stream_info);
511 assert(handle->audioIoHandle);
513 handle->audioIoHandle->setStreamInfo(stream_info);
514 } catch (CAudioError e) {
515 AUDIO_IO_LOGE("%s", e.getErrorMsg());
516 return __convert_CAudioError(e);
519 return AUDIO_IO_ERROR_NONE;
522 int cpp_audio_in_prepare(audio_in_h input) {
523 audio_io_s* handle = static_cast<audio_io_s*>(input);
526 if (handle == NULL) {
527 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
528 "Parameters are NULL input:%p", input);
530 assert(handle->audioIoHandle);
532 handle->audioIoHandle->prepare();
533 } catch (CAudioError e) {
534 AUDIO_IO_LOGE("%s", e.getErrorMsg());
535 return __convert_CAudioError(e);
538 return AUDIO_IO_ERROR_NONE;
541 int cpp_audio_in_unprepare(audio_in_h input) {
542 audio_io_s* handle = static_cast<audio_io_s*>(input);
545 if (handle == NULL) {
546 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
547 "Parameters are NULL input:%p", input);
549 assert(handle->audioIoHandle);
551 handle->audioIoHandle->unprepare();
552 } catch (CAudioError e) {
553 AUDIO_IO_LOGE("%s", e.getErrorMsg());
554 return __convert_CAudioError(e);
557 return AUDIO_IO_ERROR_NONE;
560 int cpp_audio_in_pause(audio_in_h input) {
561 audio_io_s* handle = static_cast<audio_io_s*>(input);
564 if (handle == NULL) {
565 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
566 "Parameters are NULL input:%p", input);
568 assert(handle->audioIoHandle);
570 handle->audioIoHandle->pause();
571 } catch (CAudioError e) {
572 AUDIO_IO_LOGE("%s", e.getErrorMsg());
573 return __convert_CAudioError(e);
576 return AUDIO_IO_ERROR_NONE;
579 int cpp_audio_in_resume(audio_in_h input) {
580 audio_io_s* handle = static_cast<audio_io_s*>(input);
583 if (handle == NULL) {
584 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
585 "Parameters are NULL input:%p", input);
587 assert(handle->audioIoHandle);
589 handle->audioIoHandle->resume();
590 } catch (CAudioError e) {
591 AUDIO_IO_LOGE("%s", e.getErrorMsg());
592 return __convert_CAudioError(e);
595 return AUDIO_IO_ERROR_NONE;
598 int cpp_audio_in_drain(audio_in_h input) {
599 audio_io_s* handle = static_cast<audio_io_s*>(input);
602 if (handle == NULL) {
603 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
604 "Parameters are NULL input:%p", input);
606 assert(handle->audioIoHandle);
608 handle->audioIoHandle->drain();
609 } catch (CAudioError e) {
610 AUDIO_IO_LOGE("%s", e.getErrorMsg());
611 return __convert_CAudioError(e);
614 return AUDIO_IO_ERROR_NONE;
617 int cpp_audio_in_flush(audio_in_h input) {
618 audio_io_s* handle = static_cast<audio_io_s*>(input);
621 if (handle == NULL) {
622 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
623 "Parameters are NULL input:%p", input);
625 assert(handle->audioIoHandle);
627 handle->audioIoHandle->flush();
628 } catch (CAudioError e) {
629 AUDIO_IO_LOGE("%s", e.getErrorMsg());
630 return __convert_CAudioError(e);
633 return AUDIO_IO_ERROR_NONE;
636 int cpp_audio_in_read(audio_in_h input, void *buffer, unsigned int length) {
637 audio_io_s* handle = static_cast<audio_io_s*>(input);
641 if (handle == NULL || buffer == NULL) {
642 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
643 "Parameters are NULL input:%p, buffer:%p", input, buffer);
645 assert(handle->audioIoHandle);
647 CAudioInput* inputHandle = dynamic_cast<CAudioInput*>(handle->audioIoHandle);
648 if (inputHandle == NULL) {
649 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
652 size_t readn = inputHandle->read(buffer, static_cast<size_t>(length));
653 ret = static_cast<int>(readn);
654 #ifdef _AUDIO_IO_DEBUG_TIMING_
655 AUDIO_IO_LOGD("readn:%d", readn);
657 } catch (CAudioError e) {
658 AUDIO_IO_LOGE("%s", e.getErrorMsg());
659 return __convert_CAudioError(e);
665 int cpp_audio_in_get_buffer_size(audio_in_h input, int *size) {
666 audio_io_s* handle = static_cast<audio_io_s*>(input);
669 if (handle == NULL || size == NULL) {
670 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
671 "Parameters are NULL input:%p, size:%p", input, size);
673 assert(handle->audioIoHandle);
675 CAudioIO* inputHandle = dynamic_cast<CAudioInput*>(handle->audioIoHandle);
676 if (inputHandle == NULL) {
677 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
679 *size = inputHandle->getBufferSize();
680 } catch (CAudioError e) {
681 AUDIO_IO_LOGE("%s", e.getErrorMsg());
682 return __convert_CAudioError(e);
685 return AUDIO_IO_ERROR_NONE;
688 int cpp_audio_in_get_sample_rate(audio_in_h input, int *sample_rate) {
689 audio_io_s* handle = static_cast<audio_io_s*>(input);
692 if (handle == NULL || sample_rate == NULL) {
693 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
694 "Parameters are NULL input:%p, sample_rate:%p", input, sample_rate);
696 assert(handle->audioIoHandle);
698 *sample_rate = handle->audioIoHandle->getAudioInfo().getSampleRate();
699 } catch (CAudioError e) {
700 AUDIO_IO_LOGE("%s", e.getErrorMsg());
701 return __convert_CAudioError(e);
704 return AUDIO_IO_ERROR_NONE;
707 int cpp_audio_in_get_channel(audio_in_h input, audio_channel_e *channel) {
708 audio_io_s* handle = static_cast<audio_io_s*>(input);
711 if (handle == NULL || channel == NULL) {
712 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
713 "Parameters are NULL input:%p, channel:%p", input, channel);
715 assert(handle->audioIoHandle);
717 const CAudioInfo::EChannel srcChannel = handle->audioIoHandle->getAudioInfo().getChannel();
718 audio_channel_e dstChannel = AUDIO_CHANNEL_MONO;
719 __convert_audio_info_channel_2_channel(srcChannel, dstChannel);
721 *channel = dstChannel;
722 } catch (CAudioError e) {
723 AUDIO_IO_LOGE("%s", e.getErrorMsg());
724 return __convert_CAudioError(e);
727 return AUDIO_IO_ERROR_NONE;
730 int cpp_audio_in_get_sample_type(audio_in_h input, audio_sample_type_e *type) {
731 audio_io_s* handle = static_cast<audio_io_s*>(input);
734 if (handle == NULL || type == NULL) {
735 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
736 "Parameters are NULL input:%p, type:%p", input, type);
738 assert(handle->audioIoHandle);
740 const CAudioInfo::ESampleType srcSampleType = handle->audioIoHandle->getAudioInfo().getSampleType();
741 audio_sample_type_e dstSampleType = AUDIO_SAMPLE_TYPE_U8;
742 __convert_audio_info_sample_type_2_sample_type(srcSampleType, dstSampleType);
744 *type = dstSampleType;
745 } catch (CAudioError e) {
746 AUDIO_IO_LOGE("%s", e.getErrorMsg());
747 return __convert_CAudioError(e);
750 return AUDIO_IO_ERROR_NONE;
753 static void __interrupt_cb_internal(IAudioSessionEventListener::EInterruptCode _code, void* user_data) {
754 audio_io_s* handle = static_cast<audio_io_s*>(user_data);
755 audio_io_interrupted_code_e code = __convert_interrupted_code(_code);
759 if (handle->interrupt_callback.onInterrupt) {
760 handle->interrupt_callback.onInterrupt(code, handle->interrupt_callback.user_data);
764 int cpp_audio_in_set_interrupted_cb(audio_in_h input, audio_io_interrupted_cb callback, void *user_data) {
765 audio_io_s* handle = static_cast<audio_io_s*>(input);
768 if (handle == NULL || callback == NULL) {
769 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
770 "Parameters are NULL input:%p, callback:%p", input, callback);
772 assert(handle->audioIoHandle);
774 handle->interrupt_callback.onInterrupt = callback;
775 handle->interrupt_callback.user_data = user_data;
777 CAudioIO::SInterruptCallback cb = handle->audioIoHandle->getInterruptCallback();
778 cb.mUserData = static_cast<void*>(handle);
779 cb.onInterrupt = __interrupt_cb_internal;
781 handle->audioIoHandle->setInterruptCallback(cb);
782 } catch (CAudioError e) {
783 AUDIO_IO_LOGE("%s", e.getErrorMsg());
784 return __convert_CAudioError(e);
787 return AUDIO_IO_ERROR_NONE;
790 int cpp_audio_in_unset_interrupted_cb(audio_in_h input) {
791 audio_io_s* handle = static_cast<audio_io_s*>(input);
794 if (handle == NULL) {
795 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
796 "Parameters are NULL input:%p", input);
798 assert(handle->audioIoHandle);
800 handle->interrupt_callback.onInterrupt = NULL;
801 handle->interrupt_callback.user_data = NULL;
803 CAudioIO::SInterruptCallback cb = handle->audioIoHandle->getInterruptCallback();
805 cb.onInterrupt = NULL;
807 handle->audioIoHandle->setInterruptCallback(cb);
808 } catch (CAudioError e) {
809 AUDIO_IO_LOGE("%s", e.getErrorMsg());
810 return __convert_CAudioError(e);
813 return AUDIO_IO_ERROR_NONE;
816 int cpp_audio_in_ignore_session(audio_in_h input) {
817 audio_io_s* handle = static_cast<audio_io_s*>(input);
820 if (handle == NULL) {
821 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
822 "Parameters are NULL input:%p", input);
825 if (handle->stream_callback.onStream) {
826 THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION,
827 "Not support ignore session in async mode");
829 assert(handle->audioIoHandle);
831 handle->audioIoHandle->ignoreSession();
832 } catch (CAudioError e) {
833 AUDIO_IO_LOGE("%s", e.getErrorMsg());
834 return __convert_CAudioError(e);
837 return AUDIO_IO_ERROR_NONE;
840 static void __stream_cb_internal(size_t nbytes, void *user_data) {
841 audio_io_s* audioIo = static_cast<audio_io_s*>(user_data);
844 if (audioIo->stream_callback.onStream) {
845 audioIo->stream_callback.onStream(audioIo, nbytes, audioIo->stream_callback.user_data);
849 static void __state_changed_cb_internal(CAudioInfo::EAudioIOState state,
850 CAudioInfo::EAudioIOState state_prev,
853 audio_io_s* audioIo = static_cast<audio_io_s*>(user_data);
856 if (audioIo->state_changed_callback.onStateChanged) {
857 audioIo->state_changed_callback.onStateChanged(audioIo, __convert_state_type(state_prev),
858 __convert_state_type(state), by_policy,
859 audioIo->state_changed_callback.user_data);
863 int cpp_audio_in_set_stream_cb(audio_in_h input, audio_in_stream_cb callback, void* user_data) {
864 audio_io_s* handle = static_cast<audio_io_s*>(input);
867 if (handle == NULL || callback == NULL) {
868 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
869 "Parameters are NULL input:%p, callback:%p", input, callback);
871 assert(handle->audioIoHandle);
873 handle->stream_callback.onStream = callback;
874 handle->stream_callback.user_data = user_data;
876 CAudioIO::SStreamCallback cb = handle->audioIoHandle->getStreamCallback();
877 cb.mUserData = static_cast<void*>(handle);
878 cb.onStream = __stream_cb_internal;
880 handle->audioIoHandle->setStreamCallback(cb);
881 } catch (CAudioError e) {
882 AUDIO_IO_LOGE("%s", e.getErrorMsg());
883 return __convert_CAudioError(e);
886 return AUDIO_IO_ERROR_NONE;
889 int cpp_audio_in_unset_stream_cb(audio_in_h input) {
890 audio_io_s* handle = static_cast<audio_io_s*>(input);
893 if (handle == NULL) {
894 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
895 "Parameters are NULL input:%p", input);
897 assert(handle->audioIoHandle);
899 handle->stream_callback.onStream = NULL;
900 handle->stream_callback.user_data = NULL;
902 CAudioIO::SStreamCallback cb = handle->audioIoHandle->getStreamCallback();
906 handle->audioIoHandle->setStreamCallback(cb);
907 } catch (CAudioError e) {
908 AUDIO_IO_LOGE("%s", e.getErrorMsg());
909 return __convert_CAudioError(e);
912 return AUDIO_IO_ERROR_NONE;
915 int cpp_audio_in_peek(audio_in_h input, const void **buffer, unsigned int *length) {
916 audio_io_s* handle = static_cast<audio_io_s*>(input);
920 if (handle == NULL || buffer == NULL) {
921 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
922 "Parameters are NULL input:%p, buffer:%p", input, buffer);
925 CAudioInput* inputHandle = dynamic_cast<CAudioInput*>(handle->audioIoHandle);
928 inputHandle->peek(buffer, &_length);
929 } catch (CAudioError e) {
930 AUDIO_IO_LOGE("%s", e.getErrorMsg());
931 return __convert_CAudioError(e);
934 *length = (unsigned int)_length;
936 return AUDIO_IO_ERROR_NONE;
939 int cpp_audio_in_drop(audio_in_h input) {
940 audio_io_s* handle = static_cast<audio_io_s*>(input);
943 if (handle == NULL) {
944 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
945 "Parameters are NULL input:%p", input);
948 CAudioInput* inputHandle = dynamic_cast<CAudioInput*>(handle->audioIoHandle);
952 } catch (CAudioError e) {
953 AUDIO_IO_LOGE("%s", e.getErrorMsg());
954 return __convert_CAudioError(e);
957 return AUDIO_IO_ERROR_NONE;
960 int cpp_audio_in_set_state_changed_cb(audio_in_h input, audio_in_state_changed_cb callback, void* user_data) {
961 audio_io_s* handle = static_cast<audio_io_s*>(input);
964 if (handle == NULL || callback == NULL) {
965 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
966 "Parameters are NULL input:%p, callback:%p", input, callback);
968 assert(handle->audioIoHandle);
970 handle->state_changed_callback.onStateChanged = callback;
971 handle->state_changed_callback.user_data = user_data;
973 CAudioIO::SStateChangedCallback cb = handle->audioIoHandle->getStateChangedCallback();
974 cb.mUserData = static_cast<void*>(handle);
975 cb.onStateChanged = __state_changed_cb_internal;
977 handle->audioIoHandle->setStateChangedCallback(cb);
978 } catch (CAudioError e) {
979 AUDIO_IO_LOGE("%s", e.getErrorMsg());
980 return __convert_CAudioError(e);
983 return AUDIO_IO_ERROR_NONE;
986 int cpp_audio_in_unset_state_changed_cb(audio_in_h input) {
987 audio_io_s* handle = static_cast<audio_io_s*>(input);
990 if (handle == NULL) {
991 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
992 "Parameters are NULL output:%p", input);
994 assert(handle->audioIoHandle);
996 handle->state_changed_callback.onStateChanged = NULL;
997 handle->state_changed_callback.user_data = NULL;
999 CAudioIO::SStateChangedCallback cb = handle->audioIoHandle->getStateChangedCallback();
1000 cb.mUserData = NULL;
1001 cb.onStateChanged = NULL;
1003 handle->audioIoHandle->setStateChangedCallback(cb);
1004 } catch (CAudioError e) {
1005 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1006 return __convert_CAudioError(e);
1009 return AUDIO_IO_ERROR_NONE;
1016 int cpp_audio_out_create(int sample_rate, audio_channel_e channel, audio_sample_type_e type, sound_type_e sound_type, audio_out_h *output) {
1017 audio_io_s* handle = NULL;
1019 if (output == NULL) {
1020 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1021 "Parameters are NULL output:%p", output);
1024 __check_audio_param(sample_rate, channel, type, sound_type);
1026 handle = new audio_io_s;
1027 if (handle == NULL) {
1028 THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
1031 CAudioInfo audioInfo = __generate_audio_output_info(sample_rate, channel, type, sound_type);
1033 handle->audioIoHandle = new CAudioOutput(audioInfo);
1034 if (handle->audioIoHandle == NULL) {
1035 THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
1038 handle->audioIoHandle->initialize();
1041 } catch (CAudioError e) {
1042 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1044 VALID_POINTER_START(handle)
1045 SAFE_FINALIZE(handle->audioIoHandle);
1046 SAFE_DELETE(handle->audioIoHandle);
1047 SAFE_DELETE(handle);
1050 VALID_POINTER_START(output)
1054 return __convert_CAudioError(e);
1057 return AUDIO_IO_ERROR_NONE;
1060 int cpp_audio_out_create_new(int sample_rate, audio_channel_e channel, audio_sample_type_e type, audio_out_h *output) {
1061 audio_io_s* handle = NULL;
1063 if (output == NULL) {
1064 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1065 "Parameters are NULL output:%p", output);
1068 __check_audio_param(sample_rate, channel, type, SOUND_TYPE_SYSTEM /*default check */);
1070 handle = new audio_io_s;
1071 if (handle == NULL) {
1072 THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
1075 CAudioInfo audioInfo = __generate_audio_output_info(sample_rate, channel, type, SOUND_TYPE_MEDIA);
1077 handle->audioIoHandle = new CAudioOutput(audioInfo);
1078 if (handle->audioIoHandle == NULL) {
1079 THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
1082 handle->audioIoHandle->initialize();
1085 } catch (CAudioError e) {
1086 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1088 VALID_POINTER_START(handle)
1089 SAFE_FINALIZE(handle->audioIoHandle);
1090 SAFE_DELETE(handle->audioIoHandle);
1091 SAFE_DELETE(handle);
1094 VALID_POINTER_START(output)
1098 return __convert_CAudioError(e);
1101 return AUDIO_IO_ERROR_NONE;
1104 int cpp_audio_out_destroy(audio_out_h output) {
1105 audio_io_s* handle = static_cast<audio_io_s*>(output);
1108 if (handle == NULL) {
1109 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1110 "Parameter is NULL output:%p", output);
1112 assert(handle->audioIoHandle);
1114 /* Internal unprepare for backward compatibility */
1115 handle->audioIoHandle->unprepare();
1117 SAFE_FINALIZE(handle->audioIoHandle);
1118 SAFE_DELETE(handle->audioIoHandle);
1119 SAFE_DELETE(handle);
1120 } catch (CAudioError e) {
1121 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1122 return __convert_CAudioError(e);
1125 return AUDIO_IO_ERROR_NONE;
1128 int cpp_audio_out_set_sound_stream_info(audio_out_h output, sound_stream_info_h stream_info) {
1129 audio_io_s* handle = static_cast<audio_io_s*>(output);
1132 if (handle == NULL || stream_info == NULL) {
1133 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1134 "Parameters are NULL output:%p, stream_info:%p", output, stream_info);
1136 assert(handle->audioIoHandle);
1138 handle->audioIoHandle->setStreamInfo(stream_info);
1139 } catch (CAudioError e) {
1140 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1141 return __convert_CAudioError(e);
1144 return AUDIO_IO_ERROR_NONE;
1147 int cpp_audio_out_prepare(audio_out_h output) {
1148 audio_io_s* handle = static_cast<audio_io_s*>(output);
1151 if (handle == NULL) {
1152 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1153 "Parameter is NULL output:%p", output);
1155 assert(handle->audioIoHandle);
1157 handle->audioIoHandle->prepare();
1158 } catch (CAudioError e) {
1159 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1160 return __convert_CAudioError(e);
1163 return AUDIO_IO_ERROR_NONE;
1166 int cpp_audio_out_unprepare(audio_out_h output) {
1167 audio_io_s* handle = static_cast<audio_io_s*>(output);
1170 if (handle == NULL) {
1171 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1172 "Parameter is NULL output:%p", output);
1174 assert(handle->audioIoHandle);
1176 handle->audioIoHandle->unprepare();
1177 } catch (CAudioError e) {
1178 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1179 return __convert_CAudioError(e);
1182 return AUDIO_IO_ERROR_NONE;
1185 int cpp_audio_out_pause(audio_out_h output) {
1186 audio_io_s* handle = static_cast<audio_io_s*>(output);
1189 if (handle == NULL) {
1190 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1191 "Parameter is NULL output:%p", output);
1193 assert(handle->audioIoHandle);
1195 handle->audioIoHandle->pause();
1196 } catch (CAudioError e) {
1197 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1198 return __convert_CAudioError(e);
1201 return AUDIO_IO_ERROR_NONE;
1204 int cpp_audio_out_resume(audio_out_h output) {
1205 audio_io_s* handle = static_cast<audio_io_s*>(output);
1208 if (handle == NULL) {
1209 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1210 "Parameter is NULL output:%p", output);
1212 assert(handle->audioIoHandle);
1214 handle->audioIoHandle->resume();
1215 } catch (CAudioError e) {
1216 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1217 return __convert_CAudioError(e);
1220 return AUDIO_IO_ERROR_NONE;
1223 int cpp_audio_out_drain(audio_out_h output) {
1224 audio_io_s* handle = static_cast<audio_io_s*>(output);
1227 if (handle == NULL) {
1228 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1229 "Parameter is NULL output:%p", output);
1231 assert(handle->audioIoHandle);
1233 handle->audioIoHandle->drain();
1234 } catch (CAudioError e) {
1235 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1236 return __convert_CAudioError(e);
1239 return AUDIO_IO_ERROR_NONE;
1242 int cpp_audio_out_flush(audio_out_h output) {
1243 audio_io_s* handle = static_cast<audio_io_s*>(output);
1246 if (handle == NULL) {
1247 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1248 "Parameter is NULL output:%p", output);
1250 assert(handle->audioIoHandle);
1252 handle->audioIoHandle->flush();
1253 } catch (CAudioError e) {
1254 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1255 return __convert_CAudioError(e);
1258 return AUDIO_IO_ERROR_NONE;
1261 int cpp_audio_out_write(audio_out_h output, void *buffer, unsigned int length) {
1262 audio_io_s* handle = static_cast<audio_io_s*>(output);
1266 if (handle == NULL || buffer == NULL) {
1267 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1268 "Parameter is NULL output:%p, buffer:%p", output, buffer);
1270 assert(handle->audioIoHandle);
1272 CAudioOutput* outputHandle = dynamic_cast<CAudioOutput*>(handle->audioIoHandle);
1273 if (outputHandle == NULL) {
1274 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
1277 size_t written = outputHandle->write(buffer, static_cast<size_t>(length));
1278 ret = static_cast<int>(written);
1279 #ifdef _AUDIO_IO_DEBUG_TIMING_
1280 AUDIO_IO_LOGD("written:%d", written);
1282 } catch (CAudioError e) {
1283 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1284 return __convert_CAudioError(e);
1290 int cpp_audio_out_get_buffer_size(audio_out_h output, int *size) {
1291 audio_io_s* handle = static_cast<audio_io_s*>(output);
1294 if (handle == NULL || size == NULL) {
1295 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1296 "Parameters are NULL output:%p, size:%p", output, size);
1298 assert(handle->audioIoHandle);
1300 CAudioOutput* outputHandle = dynamic_cast<CAudioOutput*>(handle->audioIoHandle);
1301 if (outputHandle == NULL) {
1302 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
1304 *size = outputHandle->getBufferSize();
1305 } catch (CAudioError e) {
1306 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1307 return __convert_CAudioError(e);
1310 return AUDIO_IO_ERROR_NONE;
1313 int cpp_audio_out_get_sample_rate(audio_out_h output, int *sample_rate) {
1314 audio_io_s* handle = static_cast<audio_io_s*>(output);
1317 if (handle == NULL || sample_rate == NULL) {
1318 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1319 "Parameters are NULL output:%p, sample_rate:%p", output, sample_rate);
1321 assert(handle->audioIoHandle);
1323 *sample_rate = handle->audioIoHandle->getAudioInfo().getSampleRate();
1324 } catch (CAudioError e) {
1325 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1326 return __convert_CAudioError(e);
1329 return AUDIO_IO_ERROR_NONE;
1332 int cpp_audio_out_get_channel(audio_out_h output, audio_channel_e *channel) {
1333 audio_io_s* handle = static_cast<audio_io_s*>(output);
1336 if (handle == NULL || channel == NULL) {
1337 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1338 "Parameters are NULL output:%p, channel:%p", output, channel);
1340 assert(handle->audioIoHandle);
1342 const CAudioInfo::EChannel srcChannel = handle->audioIoHandle->getAudioInfo().getChannel();
1343 audio_channel_e dstChannel = AUDIO_CHANNEL_MONO;
1344 __convert_audio_info_channel_2_channel(srcChannel, dstChannel);
1346 *channel = dstChannel;
1347 } catch (CAudioError e) {
1348 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1349 return __convert_CAudioError(e);
1352 return AUDIO_IO_ERROR_NONE;
1355 int cpp_audio_out_get_sample_type(audio_out_h output, audio_sample_type_e *type) {
1356 audio_io_s* handle = static_cast<audio_io_s*>(output);
1359 if (handle == NULL || type == NULL) {
1360 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1361 "Parameters are NULL output:%p, type:%p", output, type);
1363 assert(handle->audioIoHandle);
1365 const CAudioInfo::ESampleType srcSampleType = handle->audioIoHandle->getAudioInfo().getSampleType();
1366 audio_sample_type_e dstSampleType = AUDIO_SAMPLE_TYPE_U8;
1367 __convert_audio_info_sample_type_2_sample_type(srcSampleType, dstSampleType);
1369 *type = dstSampleType;
1370 } catch (CAudioError e) {
1371 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1372 return __convert_CAudioError(e);
1375 return AUDIO_IO_ERROR_NONE;
1378 int cpp_audio_out_get_sound_type(audio_out_h output, sound_type_e *type) {
1379 audio_io_s* handle = static_cast<audio_io_s*>(output);
1382 if (handle == NULL || type == NULL) {
1383 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1384 "Parameters are NULL output:%p, type:%p", output, type);
1386 assert(handle->audioIoHandle);
1388 const CAudioInfo::EAudioType srcAudioType = handle->audioIoHandle->getAudioInfo().getAudioType();
1389 sound_type_e dstSoundType = SOUND_TYPE_MEDIA;
1390 __convert_audio_info_audio_type_2_sound_type(srcAudioType, dstSoundType);
1392 *type = dstSoundType;
1393 } catch (CAudioError e) {
1394 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1395 return __convert_CAudioError(e);
1398 return AUDIO_IO_ERROR_NONE;
1401 int cpp_audio_out_set_interrupted_cb(audio_out_h output, audio_io_interrupted_cb callback, void *user_data) {
1402 audio_io_s* handle = static_cast<audio_io_s*>(output);
1405 if (handle == NULL || callback == NULL) {
1406 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1407 "Parameters are NULL output:%p, callback:%p", output, callback);
1409 assert(handle->audioIoHandle);
1411 handle->interrupt_callback.onInterrupt = callback;
1412 handle->interrupt_callback.user_data = user_data;
1414 CAudioIO::SInterruptCallback cb = handle->audioIoHandle->getInterruptCallback();
1415 cb.mUserData = static_cast<void*>(handle);
1416 cb.onInterrupt = __interrupt_cb_internal;
1418 handle->audioIoHandle->setInterruptCallback(cb);
1419 } catch (CAudioError e) {
1420 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1421 return __convert_CAudioError(e);
1424 return AUDIO_IO_ERROR_NONE;
1427 int cpp_audio_out_unset_interrupted_cb(audio_out_h output) {
1428 audio_io_s* handle = static_cast<audio_io_s*>(output);
1431 if (handle == NULL) {
1432 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1433 "Parameters are NULL output:%p", output);
1435 assert(handle->audioIoHandle);
1437 handle->interrupt_callback.onInterrupt = NULL;
1438 handle->interrupt_callback.user_data = NULL;
1440 CAudioIO::SInterruptCallback cb = handle->audioIoHandle->getInterruptCallback();
1441 cb.mUserData = NULL;
1442 cb.onInterrupt = NULL;
1444 handle->audioIoHandle->setInterruptCallback(cb);
1445 } catch (CAudioError e) {
1446 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1447 return __convert_CAudioError(e);
1450 return AUDIO_IO_ERROR_NONE;
1453 int cpp_audio_out_ignore_session(audio_out_h output) {
1454 audio_io_s* handle = static_cast<audio_io_s*>(output);
1457 if (handle == NULL) {
1458 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1459 "Parameters are NULL output:%p", output);
1462 if (handle->stream_callback.onStream) {
1463 THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION,
1464 "Not support ignore session in async mode");
1466 assert(handle->audioIoHandle);
1468 handle->audioIoHandle->ignoreSession();
1469 } catch (CAudioError e) {
1470 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1471 return __convert_CAudioError(e);
1474 return AUDIO_IO_ERROR_NONE;
1477 int cpp_audio_out_set_stream_cb(audio_out_h output, audio_out_stream_cb callback, void* user_data) {
1478 audio_io_s* handle = static_cast<audio_io_s*>(output);
1481 if (handle == NULL || callback == NULL) {
1482 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1483 "Parameters are NULL output:%p, callback:%p", output, callback);
1485 assert(handle->audioIoHandle);
1487 handle->stream_callback.onStream = callback;
1488 handle->stream_callback.user_data = user_data;
1490 CAudioIO::SStreamCallback cb = handle->audioIoHandle->getStreamCallback();
1491 cb.mUserData = static_cast<void*>(handle);
1492 cb.onStream = __stream_cb_internal;
1494 handle->audioIoHandle->setStreamCallback(cb);
1495 } catch (CAudioError e) {
1496 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1497 return __convert_CAudioError(e);
1500 return AUDIO_IO_ERROR_NONE;
1503 int cpp_audio_out_unset_stream_cb(audio_out_h output) {
1504 audio_io_s* handle = static_cast<audio_io_s*>(output);
1507 if (handle == NULL) {
1508 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1509 "Parameters are NULL output:%p", output);
1511 assert(handle->audioIoHandle);
1513 handle->stream_callback.onStream = NULL;
1514 handle->stream_callback.user_data = NULL;
1516 CAudioIO::SStreamCallback cb = handle->audioIoHandle->getStreamCallback();
1517 cb.mUserData = NULL;
1520 handle->audioIoHandle->setStreamCallback(cb);
1521 } catch (CAudioError e) {
1522 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1523 return __convert_CAudioError(e);
1526 return AUDIO_IO_ERROR_NONE;
1529 int cpp_audio_out_set_state_changed_cb(audio_out_h output, audio_in_state_changed_cb callback, void* user_data) {
1530 audio_io_s* handle = static_cast<audio_io_s*>(output);
1533 if (handle == NULL || callback == NULL) {
1534 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1535 "Parameters are NULL output:%p, callback:%p", output, callback);
1537 assert(handle->audioIoHandle);
1539 handle->state_changed_callback.onStateChanged = callback;
1540 handle->state_changed_callback.user_data = user_data;
1542 CAudioIO::SStateChangedCallback cb = handle->audioIoHandle->getStateChangedCallback();
1543 cb.mUserData = static_cast<void*>(handle);
1544 cb.onStateChanged = __state_changed_cb_internal;
1546 handle->audioIoHandle->setStateChangedCallback(cb);
1547 } catch (CAudioError e) {
1548 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1549 return __convert_CAudioError(e);
1552 return AUDIO_IO_ERROR_NONE;
1555 int cpp_audio_out_unset_state_changed_cb(audio_out_h output) {
1556 audio_io_s* handle = static_cast<audio_io_s*>(output);
1559 if (handle == NULL) {
1560 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1561 "Parameters are NULL output:%p", output);
1563 assert(handle->audioIoHandle);
1565 handle->state_changed_callback.onStateChanged = NULL;
1566 handle->state_changed_callback.user_data = NULL;
1568 CAudioIO::SStateChangedCallback cb = handle->audioIoHandle->getStateChangedCallback();
1569 cb.mUserData = NULL;
1570 cb.onStateChanged = NULL;
1572 handle->audioIoHandle->setStateChangedCallback(cb);
1573 } catch (CAudioError e) {
1574 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1575 return __convert_CAudioError(e);
1578 return AUDIO_IO_ERROR_NONE;