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);
488 assert(handle->audioIoHandle);
490 /* Internal unprepare for backward compatibility */
491 handle->audioIoHandle->unprepare();
493 SAFE_FINALIZE(handle->audioIoHandle);
494 SAFE_DELETE(handle->audioIoHandle);
496 } catch (CAudioError e) {
497 AUDIO_IO_LOGE("%s", e.getErrorMsg());
498 return __convert_CAudioError(e);
501 return AUDIO_IO_ERROR_NONE;
504 int cpp_audio_in_set_sound_stream_info(audio_in_h input, sound_stream_info_h stream_info) {
505 audio_io_s* handle = static_cast<audio_io_s*>(input);
508 if (handle == NULL || stream_info == NULL) {
509 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
510 "Parameters are NULL input:%p, stream_info:%p", input, stream_info);
513 assert(handle->audioIoHandle);
515 int errorCode = SOUND_MANAGER_ERROR_NONE;
516 CAudioInfo::EAudioType audioType = CAudioInfo::EAudioType::AUDIO_IN_TYPE_MEDIA;
521 if ((errorCode = sound_manager_is_available_stream_information(stream_info, NATIVE_API_AUDIO_IO, &avail)) != SOUND_MANAGER_ERROR_NONE) {
522 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info is invalid [ret:%d]", errorCode);
526 if ((errorCode = sound_manager_get_type_from_stream_information(stream_info, &type)) != SOUND_MANAGER_ERROR_NONE) {
527 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->stream_type is invalid [ret:%d]", errorCode);
529 handle->audioIoHandle->getAudioInfo().convertInputStreamType2AudioType(type, &audioType);
530 handle->audioIoHandle->getAudioInfo().setAudioType(audioType);
532 if ((errorCode = sound_manager_get_index_from_stream_information(stream_info, &index)) != SOUND_MANAGER_ERROR_NONE) {
533 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->index is invalid [ret:%d]", errorCode);
535 handle->audioIoHandle->getAudioInfo().setAudioIndex(index);
537 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_SUPPORTED_TYPE, "Input stream is not supported");
539 } catch (CAudioError e) {
540 AUDIO_IO_LOGE("%s", e.getErrorMsg());
541 return __convert_CAudioError(e);
544 return AUDIO_IO_ERROR_NONE;
547 int cpp_audio_in_prepare(audio_in_h input) {
548 audio_io_s* handle = static_cast<audio_io_s*>(input);
551 if (handle == NULL) {
552 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
553 "Parameters are NULL input:%p", input);
556 assert(handle->audioIoHandle);
558 handle->audioIoHandle->prepare();
559 } catch (CAudioError e) {
560 AUDIO_IO_LOGE("%s", e.getErrorMsg());
561 return __convert_CAudioError(e);
564 return AUDIO_IO_ERROR_NONE;
567 int cpp_audio_in_unprepare(audio_in_h input) {
568 audio_io_s* handle = static_cast<audio_io_s*>(input);
571 if (handle == NULL) {
572 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
573 "Parameters are NULL input:%p", input);
575 assert(handle->audioIoHandle);
577 handle->audioIoHandle->unprepare();
578 } catch (CAudioError e) {
579 AUDIO_IO_LOGE("%s", e.getErrorMsg());
580 return __convert_CAudioError(e);
583 return AUDIO_IO_ERROR_NONE;
586 int cpp_audio_in_pause(audio_in_h input) {
587 audio_io_s* handle = static_cast<audio_io_s*>(input);
590 if (handle == NULL) {
591 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
592 "Parameters are NULL input:%p", input);
594 assert(handle->audioIoHandle);
596 handle->audioIoHandle->pause();
597 } catch (CAudioError e) {
598 AUDIO_IO_LOGE("%s", e.getErrorMsg());
599 return __convert_CAudioError(e);
602 return AUDIO_IO_ERROR_NONE;
605 int cpp_audio_in_resume(audio_in_h input) {
606 audio_io_s* handle = static_cast<audio_io_s*>(input);
609 if (handle == NULL) {
610 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
611 "Parameters are NULL input:%p", input);
613 assert(handle->audioIoHandle);
615 handle->audioIoHandle->resume();
616 } catch (CAudioError e) {
617 AUDIO_IO_LOGE("%s", e.getErrorMsg());
618 return __convert_CAudioError(e);
621 return AUDIO_IO_ERROR_NONE;
624 int cpp_audio_in_drain(audio_in_h input) {
625 audio_io_s* handle = static_cast<audio_io_s*>(input);
628 if (handle == NULL) {
629 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
630 "Parameters are NULL input:%p", input);
632 assert(handle->audioIoHandle);
634 handle->audioIoHandle->drain();
635 } catch (CAudioError e) {
636 AUDIO_IO_LOGE("%s", e.getErrorMsg());
637 return __convert_CAudioError(e);
640 return AUDIO_IO_ERROR_NONE;
643 int cpp_audio_in_flush(audio_in_h input) {
644 audio_io_s* handle = static_cast<audio_io_s*>(input);
647 if (handle == NULL) {
648 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
649 "Parameters are NULL input:%p", input);
652 assert(handle->audioIoHandle);
654 handle->audioIoHandle->flush();
655 } catch (CAudioError e) {
656 AUDIO_IO_LOGE("%s", e.getErrorMsg());
657 return __convert_CAudioError(e);
660 return AUDIO_IO_ERROR_NONE;
663 int cpp_audio_in_read(audio_in_h input, void *buffer, unsigned int length) {
664 audio_io_s* handle = static_cast<audio_io_s*>(input);
668 if (handle == NULL || buffer == NULL) {
669 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
670 "Parameters are NULL input:%p, buffer:%p", input, buffer);
672 assert(handle->audioIoHandle);
674 CAudioInput* inputHandle = dynamic_cast<CAudioInput*>(handle->audioIoHandle);
675 if (inputHandle == NULL) {
676 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
679 size_t readn = inputHandle->read(buffer, static_cast<size_t>(length));
680 ret = static_cast<int>(readn);
681 #ifdef _AUDIO_IO_DEBUG_TIMING_
682 AUDIO_IO_LOGD("readn:%d", readn);
684 } catch (CAudioError e) {
685 AUDIO_IO_LOGE("%s", e.getErrorMsg());
686 return __convert_CAudioError(e);
692 int cpp_audio_in_get_buffer_size(audio_in_h input, int *size) {
693 audio_io_s* handle = static_cast<audio_io_s*>(input);
696 if (handle == NULL || size == NULL) {
697 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
698 "Parameters are NULL input:%p, size:%p", input, size);
701 assert(handle->audioIoHandle);
703 CAudioIO* inputHandle = dynamic_cast<CAudioInput*>(handle->audioIoHandle);
704 if (inputHandle == NULL) {
705 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
707 *size = inputHandle->getBufferSize();
708 } catch (CAudioError e) {
709 AUDIO_IO_LOGE("%s", e.getErrorMsg());
710 return __convert_CAudioError(e);
713 return AUDIO_IO_ERROR_NONE;
716 int cpp_audio_in_get_sample_rate(audio_in_h input, int *sample_rate) {
717 audio_io_s* handle = static_cast<audio_io_s*>(input);
720 if (handle == NULL || sample_rate == NULL) {
721 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
722 "Parameters are NULL input:%p, sample_rate:%p", input, sample_rate);
725 assert(handle->audioIoHandle);
726 *sample_rate = handle->audioIoHandle->getAudioInfo().getSampleRate();
727 } catch (CAudioError e) {
728 AUDIO_IO_LOGE("%s", e.getErrorMsg());
729 return __convert_CAudioError(e);
732 return AUDIO_IO_ERROR_NONE;
735 int cpp_audio_in_get_channel(audio_in_h input, audio_channel_e *channel) {
736 audio_io_s* handle = static_cast<audio_io_s*>(input);
739 if (handle == NULL || channel == NULL) {
740 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
741 "Parameters are NULL input:%p, channel:%p", input, channel);
744 assert(handle->audioIoHandle);
746 const CAudioInfo::EChannel srcChannel = handle->audioIoHandle->getAudioInfo().getChannel();
747 audio_channel_e dstChannel = AUDIO_CHANNEL_MONO;
748 __convert_audio_info_channel_2_channel(srcChannel, dstChannel);
750 *channel = dstChannel;
751 } catch (CAudioError e) {
752 AUDIO_IO_LOGE("%s", e.getErrorMsg());
753 return __convert_CAudioError(e);
756 return AUDIO_IO_ERROR_NONE;
759 int cpp_audio_in_get_sample_type(audio_in_h input, audio_sample_type_e *type) {
760 audio_io_s* handle = static_cast<audio_io_s*>(input);
763 if (handle == NULL || type == NULL) {
764 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
765 "Parameters are NULL input:%p, type:%p", input, type);
767 assert(handle->audioIoHandle);
769 const CAudioInfo::ESampleType srcSampleType = handle->audioIoHandle->getAudioInfo().getSampleType();
770 audio_sample_type_e dstSampleType = AUDIO_SAMPLE_TYPE_U8;
771 __convert_audio_info_sample_type_2_sample_type(srcSampleType, dstSampleType);
773 *type = dstSampleType;
774 } catch (CAudioError e) {
775 AUDIO_IO_LOGE("%s", e.getErrorMsg());
776 return __convert_CAudioError(e);
779 return AUDIO_IO_ERROR_NONE;
782 static void __interrupt_cb_internal(IAudioSessionEventListener::EInterruptCode _code, void* user_data) {
783 audio_io_s* handle = static_cast<audio_io_s*>(user_data);
784 audio_io_interrupted_code_e code = __convert_interrupted_code(_code);
788 if (handle->interrupt_callback.onInterrupt) {
789 handle->interrupt_callback.onInterrupt(code, handle->interrupt_callback.user_data);
793 int cpp_audio_in_set_interrupted_cb(audio_in_h input, audio_io_interrupted_cb callback, void *user_data) {
794 audio_io_s* handle = static_cast<audio_io_s*>(input);
797 if (handle == NULL || callback == NULL) {
798 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
799 "Parameters are NULL input:%p, callback:%p", input, callback);
802 assert(handle->audioIoHandle);
804 handle->interrupt_callback.onInterrupt = callback;
805 handle->interrupt_callback.user_data = user_data;
807 CAudioIO::SInterruptCallback cb = handle->audioIoHandle->getInterruptCallback();
808 cb.mUserData = static_cast<void*>(handle);
809 cb.onInterrupt = __interrupt_cb_internal;
811 handle->audioIoHandle->setInterruptCallback(cb);
812 } catch (CAudioError e) {
813 AUDIO_IO_LOGE("%s", e.getErrorMsg());
814 return __convert_CAudioError(e);
817 return AUDIO_IO_ERROR_NONE;
820 int cpp_audio_in_unset_interrupted_cb(audio_in_h input) {
821 audio_io_s* handle = static_cast<audio_io_s*>(input);
824 if (handle == NULL) {
825 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
826 "Parameters are NULL input:%p", input);
829 assert(handle->audioIoHandle);
831 handle->interrupt_callback.onInterrupt = NULL;
832 handle->interrupt_callback.user_data = NULL;
834 CAudioIO::SInterruptCallback cb = handle->audioIoHandle->getInterruptCallback();
836 cb.onInterrupt = NULL;
838 handle->audioIoHandle->setInterruptCallback(cb);
839 } catch (CAudioError e) {
840 AUDIO_IO_LOGE("%s", e.getErrorMsg());
841 return __convert_CAudioError(e);
844 return AUDIO_IO_ERROR_NONE;
847 int cpp_audio_in_ignore_session(audio_in_h input) {
848 audio_io_s* handle = static_cast<audio_io_s*>(input);
851 if (handle == NULL) {
852 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
853 "Parameters are NULL input:%p", input);
856 if (handle->stream_callback.onStream) {
857 THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION,
858 "Not support ignore session in async mode");
861 assert(handle->audioIoHandle);
863 handle->audioIoHandle->ignoreSession();
864 } catch (CAudioError e) {
865 AUDIO_IO_LOGE("%s", e.getErrorMsg());
866 return __convert_CAudioError(e);
869 return AUDIO_IO_ERROR_NONE;
872 static void __stream_cb_internal(size_t nbytes, void *user_data) {
873 audio_io_s* audioIo = static_cast<audio_io_s*>(user_data);
876 if (audioIo->stream_callback.onStream) {
877 audioIo->stream_callback.onStream(audioIo, nbytes, audioIo->stream_callback.user_data);
881 static void __state_changed_cb_internal(CAudioInfo::EAudioIOState state,
882 CAudioInfo::EAudioIOState state_prev,
885 audio_io_s* audioIo = static_cast<audio_io_s*>(user_data);
888 if (audioIo->state_changed_callback.onStateChanged) {
889 audioIo->state_changed_callback.onStateChanged(audioIo, __convert_state_type(state_prev),
890 __convert_state_type(state), by_policy,
891 audioIo->state_changed_callback.user_data);
895 int cpp_audio_in_set_stream_cb(audio_in_h input, audio_in_stream_cb callback, void* user_data) {
896 audio_io_s* handle = static_cast<audio_io_s*>(input);
899 if (handle == NULL || callback == NULL) {
900 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
901 "Parameters are NULL input:%p, callback:%p", input, callback);
904 assert(handle->audioIoHandle);
906 handle->stream_callback.onStream = callback;
907 handle->stream_callback.user_data = user_data;
909 CAudioIO::SStreamCallback cb = handle->audioIoHandle->getStreamCallback();
910 cb.mUserData = static_cast<void*>(handle);
911 cb.onStream = __stream_cb_internal;
913 handle->audioIoHandle->setStreamCallback(cb);
914 } catch (CAudioError e) {
915 AUDIO_IO_LOGE("%s", e.getErrorMsg());
916 return __convert_CAudioError(e);
919 return AUDIO_IO_ERROR_NONE;
922 int cpp_audio_in_unset_stream_cb(audio_in_h input) {
923 audio_io_s* handle = static_cast<audio_io_s*>(input);
926 if (handle == NULL) {
927 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
928 "Parameters are NULL input:%p", input);
931 assert(handle->audioIoHandle);
933 handle->stream_callback.onStream = NULL;
934 handle->stream_callback.user_data = NULL;
936 CAudioIO::SStreamCallback cb = handle->audioIoHandle->getStreamCallback();
940 handle->audioIoHandle->setStreamCallback(cb);
941 } catch (CAudioError e) {
942 AUDIO_IO_LOGE("%s", e.getErrorMsg());
943 return __convert_CAudioError(e);
946 return AUDIO_IO_ERROR_NONE;
949 int cpp_audio_in_peek(audio_in_h input, const void **buffer, unsigned int *length) {
950 audio_io_s* handle = static_cast<audio_io_s*>(input);
954 if (handle == NULL || buffer == NULL) {
955 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
956 "Parameters are NULL input:%p, buffer:%p", input, buffer);
959 CAudioInput* inputHandle = dynamic_cast<CAudioInput*>(handle->audioIoHandle);
962 inputHandle->peek(buffer, &_length);
963 } catch (CAudioError e) {
964 AUDIO_IO_LOGE("%s", e.getErrorMsg());
965 return __convert_CAudioError(e);
968 *length = (unsigned int)_length;
970 return AUDIO_IO_ERROR_NONE;
973 int cpp_audio_in_drop(audio_in_h input) {
974 audio_io_s* handle = static_cast<audio_io_s*>(input);
977 if (handle == NULL) {
978 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
979 "Parameters are NULL input:%p", input);
982 CAudioInput* inputHandle = dynamic_cast<CAudioInput*>(handle->audioIoHandle);
986 } catch (CAudioError e) {
987 AUDIO_IO_LOGE("%s", e.getErrorMsg());
988 return __convert_CAudioError(e);
991 return AUDIO_IO_ERROR_NONE;
994 int cpp_audio_in_set_state_changed_cb(audio_in_h input, audio_in_state_changed_cb callback, void* user_data) {
995 audio_io_s* handle = static_cast<audio_io_s*>(input);
998 if (handle == NULL || callback == NULL) {
999 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1000 "Parameters are NULL input:%p, callback:%p", input, callback);
1003 assert(handle->audioIoHandle);
1005 handle->state_changed_callback.onStateChanged = callback;
1006 handle->state_changed_callback.user_data = user_data;
1008 CAudioIO::SStateChangedCallback cb = handle->audioIoHandle->getStateChangedCallback();
1009 cb.mUserData = static_cast<void*>(handle);
1010 cb.onStateChanged = __state_changed_cb_internal;
1012 handle->audioIoHandle->setStateChangedCallback(cb);
1013 } catch (CAudioError e) {
1014 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1015 return __convert_CAudioError(e);
1018 return AUDIO_IO_ERROR_NONE;
1021 int cpp_audio_in_unset_state_changed_cb(audio_in_h input) {
1022 audio_io_s* handle = static_cast<audio_io_s*>(input);
1025 if (handle == NULL) {
1026 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1027 "Parameters are NULL output:%p", input);
1030 assert(handle->audioIoHandle);
1032 handle->state_changed_callback.onStateChanged = NULL;
1033 handle->state_changed_callback.user_data = NULL;
1035 CAudioIO::SStateChangedCallback cb = handle->audioIoHandle->getStateChangedCallback();
1036 cb.mUserData = NULL;
1037 cb.onStateChanged = NULL;
1039 handle->audioIoHandle->setStateChangedCallback(cb);
1040 } catch (CAudioError e) {
1041 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1042 return __convert_CAudioError(e);
1045 return AUDIO_IO_ERROR_NONE;
1052 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) {
1053 audio_io_s* handle = NULL;
1055 if (output == NULL) {
1056 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1057 "Parameters are NULL output:%p", output);
1060 __check_audio_param(sample_rate, channel, type, sound_type);
1062 handle = new audio_io_s;
1063 if (handle == NULL) {
1064 THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
1067 CAudioInfo audioInfo = __generate_audio_output_info(sample_rate, channel, type, sound_type);
1069 handle->audioIoHandle = new CAudioOutput(audioInfo);
1070 if (handle->audioIoHandle == NULL) {
1071 THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
1074 handle->audioIoHandle->initialize();
1077 } catch (CAudioError e) {
1078 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1080 VALID_POINTER_START(handle)
1081 SAFE_FINALIZE(handle->audioIoHandle);
1082 SAFE_DELETE(handle->audioIoHandle);
1083 SAFE_DELETE(handle);
1086 VALID_POINTER_START(output)
1090 return __convert_CAudioError(e);
1093 return AUDIO_IO_ERROR_NONE;
1096 int cpp_audio_out_create_new(int sample_rate, audio_channel_e channel, audio_sample_type_e type, audio_out_h *output) {
1097 audio_io_s* handle = NULL;
1099 if (output == NULL) {
1100 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1101 "Parameters are NULL output:%p", output);
1104 __check_audio_param(sample_rate, channel, type, SOUND_TYPE_SYSTEM /*default check */);
1106 handle = new audio_io_s;
1107 if (handle == NULL) {
1108 THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
1111 CAudioInfo audioInfo = __generate_audio_output_info(sample_rate, channel, type, SOUND_TYPE_MEDIA);
1113 handle->audioIoHandle = new CAudioOutput(audioInfo);
1114 if (handle->audioIoHandle == NULL) {
1115 THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
1118 handle->audioIoHandle->initialize();
1121 } catch (CAudioError e) {
1122 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1124 VALID_POINTER_START(handle)
1125 SAFE_FINALIZE(handle->audioIoHandle);
1126 SAFE_DELETE(handle->audioIoHandle);
1127 SAFE_DELETE(handle);
1130 VALID_POINTER_START(output)
1134 return __convert_CAudioError(e);
1137 return AUDIO_IO_ERROR_NONE;
1140 int cpp_audio_out_destroy(audio_out_h output) {
1141 audio_io_s* handle = static_cast<audio_io_s*>(output);
1144 if (handle == NULL) {
1145 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1146 "Parameter is NULL output:%p", output);
1149 assert(handle->audioIoHandle);
1151 /* Internal unprepare for backward compatibility */
1152 handle->audioIoHandle->unprepare();
1154 SAFE_FINALIZE(handle->audioIoHandle);
1155 SAFE_DELETE(handle->audioIoHandle);
1156 SAFE_DELETE(handle);
1157 } catch (CAudioError e) {
1158 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1159 return __convert_CAudioError(e);
1162 return AUDIO_IO_ERROR_NONE;
1165 int cpp_audio_out_set_sound_stream_info(audio_out_h output, sound_stream_info_h stream_info) {
1166 audio_io_s* handle = static_cast<audio_io_s*>(output);
1169 if (handle == NULL || stream_info == NULL) {
1170 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1171 "Parameters are NULL output:%p, stream_info:%p", output, stream_info);
1174 assert(handle->audioIoHandle);
1176 int errorCode = SOUND_MANAGER_ERROR_NONE;
1177 CAudioInfo::EAudioType audioType = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA;
1182 if ((errorCode = sound_manager_is_available_stream_information(stream_info, NATIVE_API_AUDIO_IO, &avail)) != SOUND_MANAGER_ERROR_NONE) {
1183 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info is invalid [ret:%d]", errorCode);
1187 if ((errorCode = sound_manager_get_type_from_stream_information(stream_info, &type)) != SOUND_MANAGER_ERROR_NONE) {
1188 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->stream_type is invalid [ret:%d]", errorCode);
1190 handle->audioIoHandle->getAudioInfo().convertOutputStreamType2AudioType(type, &audioType);
1191 handle->audioIoHandle->getAudioInfo().setAudioType(audioType);
1193 if ((errorCode = sound_manager_get_index_from_stream_information(stream_info, &index)) != SOUND_MANAGER_ERROR_NONE) {
1194 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->index is invalid [ret:%d]", errorCode);
1196 handle->audioIoHandle->getAudioInfo().setAudioIndex(index);
1198 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_SUPPORTED_TYPE,
1199 "Output stream is not supported");
1201 } catch (CAudioError e) {
1202 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1203 return __convert_CAudioError(e);
1206 return AUDIO_IO_ERROR_NONE;
1209 int cpp_audio_out_prepare(audio_out_h output) {
1210 audio_io_s* handle = static_cast<audio_io_s*>(output);
1213 if (handle == NULL) {
1214 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1215 "Parameter is NULL output:%p", output);
1218 assert(handle->audioIoHandle);
1220 handle->audioIoHandle->prepare();
1221 } catch (CAudioError e) {
1222 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1223 return __convert_CAudioError(e);
1226 return AUDIO_IO_ERROR_NONE;
1229 int cpp_audio_out_unprepare(audio_out_h output) {
1230 audio_io_s* handle = static_cast<audio_io_s*>(output);
1233 if (handle == NULL) {
1234 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1235 "Parameter is NULL output:%p", output);
1238 assert(handle->audioIoHandle);
1240 handle->audioIoHandle->unprepare();
1241 } catch (CAudioError e) {
1242 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1243 return __convert_CAudioError(e);
1246 return AUDIO_IO_ERROR_NONE;
1249 int cpp_audio_out_pause(audio_out_h output) {
1250 audio_io_s* handle = static_cast<audio_io_s*>(output);
1253 if (handle == NULL) {
1254 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1255 "Parameter is NULL output:%p", output);
1258 assert(handle->audioIoHandle);
1260 handle->audioIoHandle->pause();
1261 } catch (CAudioError e) {
1262 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1263 return __convert_CAudioError(e);
1266 return AUDIO_IO_ERROR_NONE;
1269 int cpp_audio_out_resume(audio_out_h output) {
1270 audio_io_s* handle = static_cast<audio_io_s*>(output);
1273 if (handle == NULL) {
1274 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1275 "Parameter is NULL output:%p", output);
1278 assert(handle->audioIoHandle);
1280 handle->audioIoHandle->resume();
1281 } catch (CAudioError e) {
1282 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1283 return __convert_CAudioError(e);
1286 return AUDIO_IO_ERROR_NONE;
1289 int cpp_audio_out_drain(audio_out_h output) {
1290 audio_io_s* handle = static_cast<audio_io_s*>(output);
1293 if (handle == NULL) {
1294 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1295 "Parameter is NULL output:%p", output);
1298 assert(handle->audioIoHandle);
1300 handle->audioIoHandle->drain();
1301 } catch (CAudioError e) {
1302 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1303 return __convert_CAudioError(e);
1306 return AUDIO_IO_ERROR_NONE;
1309 int cpp_audio_out_flush(audio_out_h output) {
1310 audio_io_s* handle = static_cast<audio_io_s*>(output);
1313 if (handle == NULL) {
1314 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1315 "Parameter is NULL output:%p", output);
1318 assert(handle->audioIoHandle);
1320 handle->audioIoHandle->flush();
1321 } catch (CAudioError e) {
1322 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1323 return __convert_CAudioError(e);
1326 return AUDIO_IO_ERROR_NONE;
1329 int cpp_audio_out_write(audio_out_h output, void *buffer, unsigned int length) {
1330 audio_io_s* handle = static_cast<audio_io_s*>(output);
1334 if (handle == NULL || buffer == NULL) {
1335 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1336 "Parameter is NULL output:%p, buffer:%p", output, buffer);
1339 assert(handle->audioIoHandle);
1341 CAudioOutput* outputHandle = dynamic_cast<CAudioOutput*>(handle->audioIoHandle);
1342 if (outputHandle == NULL) {
1343 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
1346 size_t written = outputHandle->write(buffer, static_cast<size_t>(length));
1347 ret = static_cast<int>(written);
1348 #ifdef _AUDIO_IO_DEBUG_TIMING_
1349 AUDIO_IO_LOGD("written:%d", written);
1351 } catch (CAudioError e) {
1352 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1353 return __convert_CAudioError(e);
1359 int cpp_audio_out_get_buffer_size(audio_out_h output, int *size) {
1360 audio_io_s* handle = static_cast<audio_io_s*>(output);
1363 if (handle == NULL || size == NULL) {
1364 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1365 "Parameters are NULL output:%p, size:%p", output, size);
1368 assert(handle->audioIoHandle);
1370 CAudioOutput* outputHandle = dynamic_cast<CAudioOutput*>(handle->audioIoHandle);
1371 if (outputHandle == NULL) {
1372 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
1374 *size = outputHandle->getBufferSize();
1375 } catch (CAudioError e) {
1376 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1377 return __convert_CAudioError(e);
1380 return AUDIO_IO_ERROR_NONE;
1383 int cpp_audio_out_get_sample_rate(audio_out_h output, int *sample_rate) {
1384 audio_io_s* handle = static_cast<audio_io_s*>(output);
1387 if (handle == NULL || sample_rate == NULL) {
1388 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1389 "Parameters are NULL output:%p, sample_rate:%p", output, sample_rate);
1392 assert(handle->audioIoHandle);
1393 *sample_rate = handle->audioIoHandle->getAudioInfo().getSampleRate();
1394 } catch (CAudioError e) {
1395 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1396 return __convert_CAudioError(e);
1399 return AUDIO_IO_ERROR_NONE;
1402 int cpp_audio_out_get_channel(audio_out_h output, audio_channel_e *channel) {
1403 audio_io_s* handle = static_cast<audio_io_s*>(output);
1406 if (handle == NULL || channel == NULL) {
1407 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1408 "Parameters are NULL output:%p, channel:%p", output, channel);
1411 assert(handle->audioIoHandle);
1413 const CAudioInfo::EChannel srcChannel = handle->audioIoHandle->getAudioInfo().getChannel();
1414 audio_channel_e dstChannel = AUDIO_CHANNEL_MONO;
1415 __convert_audio_info_channel_2_channel(srcChannel, dstChannel);
1417 *channel = dstChannel;
1418 } catch (CAudioError e) {
1419 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1420 return __convert_CAudioError(e);
1423 return AUDIO_IO_ERROR_NONE;
1426 int cpp_audio_out_get_sample_type(audio_out_h output, audio_sample_type_e *type) {
1427 audio_io_s* handle = static_cast<audio_io_s*>(output);
1430 if (handle == NULL || type == NULL) {
1431 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1432 "Parameters are NULL output:%p, type:%p", output, type);
1435 assert(handle->audioIoHandle);
1437 const CAudioInfo::ESampleType srcSampleType = handle->audioIoHandle->getAudioInfo().getSampleType();
1438 audio_sample_type_e dstSampleType = AUDIO_SAMPLE_TYPE_U8;
1439 __convert_audio_info_sample_type_2_sample_type(srcSampleType, dstSampleType);
1441 *type = dstSampleType;
1442 } catch (CAudioError e) {
1443 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1444 return __convert_CAudioError(e);
1447 return AUDIO_IO_ERROR_NONE;
1450 int cpp_audio_out_get_sound_type(audio_out_h output, sound_type_e *type) {
1451 audio_io_s* handle = static_cast<audio_io_s*>(output);
1454 if (handle == NULL || type == NULL) {
1455 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1456 "Parameters are NULL output:%p, type:%p", output, type);
1459 assert(handle->audioIoHandle);
1461 const CAudioInfo::EAudioType srcAudioType = handle->audioIoHandle->getAudioInfo().getAudioType();
1462 sound_type_e dstSoundType = SOUND_TYPE_MEDIA;
1463 __convert_audio_info_audio_type_2_sound_type(srcAudioType, dstSoundType);
1465 *type = dstSoundType;
1466 } catch (CAudioError e) {
1467 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1468 return __convert_CAudioError(e);
1471 return AUDIO_IO_ERROR_NONE;
1474 int cpp_audio_out_set_interrupted_cb(audio_out_h output, audio_io_interrupted_cb callback, void *user_data) {
1475 audio_io_s* handle = static_cast<audio_io_s*>(output);
1478 if (handle == NULL || callback == NULL) {
1479 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1480 "Parameters are NULL output:%p, callback:%p", output, callback);
1483 assert(handle->audioIoHandle);
1485 handle->interrupt_callback.onInterrupt = callback;
1486 handle->interrupt_callback.user_data = user_data;
1488 CAudioIO::SInterruptCallback cb = handle->audioIoHandle->getInterruptCallback();
1489 cb.mUserData = static_cast<void*>(handle);
1490 cb.onInterrupt = __interrupt_cb_internal;
1492 handle->audioIoHandle->setInterruptCallback(cb);
1493 } catch (CAudioError e) {
1494 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1495 return __convert_CAudioError(e);
1498 return AUDIO_IO_ERROR_NONE;
1501 int cpp_audio_out_unset_interrupted_cb(audio_out_h output) {
1502 audio_io_s* handle = static_cast<audio_io_s*>(output);
1505 if (handle == NULL) {
1506 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1507 "Parameters are NULL output:%p", output);
1510 assert(handle->audioIoHandle);
1512 handle->interrupt_callback.onInterrupt = NULL;
1513 handle->interrupt_callback.user_data = NULL;
1515 CAudioIO::SInterruptCallback cb = handle->audioIoHandle->getInterruptCallback();
1516 cb.mUserData = NULL;
1517 cb.onInterrupt = NULL;
1519 handle->audioIoHandle->setInterruptCallback(cb);
1520 } catch (CAudioError e) {
1521 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1522 return __convert_CAudioError(e);
1525 return AUDIO_IO_ERROR_NONE;
1528 int cpp_audio_out_ignore_session(audio_out_h output) {
1529 audio_io_s* handle = static_cast<audio_io_s*>(output);
1532 if (handle == NULL) {
1533 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1534 "Parameters are NULL output:%p", output);
1537 if (handle->stream_callback.onStream) {
1538 THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION,
1539 "Not support ignore session in async mode");
1542 assert(handle->audioIoHandle);
1544 handle->audioIoHandle->ignoreSession();
1545 } catch (CAudioError e) {
1546 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1547 return __convert_CAudioError(e);
1550 return AUDIO_IO_ERROR_NONE;
1553 int cpp_audio_out_set_stream_cb(audio_out_h output, audio_out_stream_cb callback, void* user_data) {
1554 audio_io_s* handle = static_cast<audio_io_s*>(output);
1557 if (handle == NULL || callback == NULL) {
1558 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1559 "Parameters are NULL output:%p, callback:%p", output, callback);
1562 assert(handle->audioIoHandle);
1564 handle->stream_callback.onStream = callback;
1565 handle->stream_callback.user_data = user_data;
1567 CAudioIO::SStreamCallback cb = handle->audioIoHandle->getStreamCallback();
1568 cb.mUserData = static_cast<void*>(handle);
1569 cb.onStream = __stream_cb_internal;
1571 handle->audioIoHandle->setStreamCallback(cb);
1572 } catch (CAudioError e) {
1573 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1574 return __convert_CAudioError(e);
1577 return AUDIO_IO_ERROR_NONE;
1580 int cpp_audio_out_unset_stream_cb(audio_out_h output) {
1581 audio_io_s* handle = static_cast<audio_io_s*>(output);
1584 if (handle == NULL) {
1585 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1586 "Parameters are NULL output:%p", output);
1589 assert(handle->audioIoHandle);
1591 handle->stream_callback.onStream = NULL;
1592 handle->stream_callback.user_data = NULL;
1594 CAudioIO::SStreamCallback cb = handle->audioIoHandle->getStreamCallback();
1595 cb.mUserData = NULL;
1598 handle->audioIoHandle->setStreamCallback(cb);
1599 } catch (CAudioError e) {
1600 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1601 return __convert_CAudioError(e);
1604 return AUDIO_IO_ERROR_NONE;
1607 int cpp_audio_out_set_state_changed_cb(audio_out_h output, audio_in_state_changed_cb callback, void* user_data) {
1608 audio_io_s* handle = static_cast<audio_io_s*>(output);
1611 if (handle == NULL || callback == NULL) {
1612 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1613 "Parameters are NULL output:%p, callback:%p", output, callback);
1616 assert(handle->audioIoHandle);
1618 handle->state_changed_callback.onStateChanged = callback;
1619 handle->state_changed_callback.user_data = user_data;
1621 CAudioIO::SStateChangedCallback cb = handle->audioIoHandle->getStateChangedCallback();
1622 cb.mUserData = static_cast<void*>(handle);
1623 cb.onStateChanged = __state_changed_cb_internal;
1625 handle->audioIoHandle->setStateChangedCallback(cb);
1626 } catch (CAudioError e) {
1627 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1628 return __convert_CAudioError(e);
1631 return AUDIO_IO_ERROR_NONE;
1634 int cpp_audio_out_unset_state_changed_cb(audio_out_h output) {
1635 audio_io_s* handle = static_cast<audio_io_s*>(output);
1638 if (handle == NULL) {
1639 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
1640 "Parameters are NULL output:%p", output);
1643 assert(handle->audioIoHandle);
1645 handle->state_changed_callback.onStateChanged = NULL;
1646 handle->state_changed_callback.user_data = NULL;
1648 CAudioIO::SStateChangedCallback cb = handle->audioIoHandle->getStateChangedCallback();
1649 cb.mUserData = NULL;
1650 cb.onStateChanged = NULL;
1652 handle->audioIoHandle->setStateChangedCallback(cb);
1653 } catch (CAudioError e) {
1654 AUDIO_IO_LOGE("%s", e.getErrorMsg());
1655 return __convert_CAudioError(e);
1658 return AUDIO_IO_ERROR_NONE;