X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Faudio_io.c;h=17e5d3190ef8f130b35ac9982eca1ca386bf5f29;hb=988beac45f9052b97aad88d14079537c36f68d6a;hp=54a7f1e2dc6a980d2bb86ab59565e9f6a1e5f24b;hpb=2f358b1f5748aa5f6f79b4fe1bbf4ce94b23254b;p=platform%2Fcore%2Fapi%2Faudio-io.git

diff --git a/src/audio_io.c b/src/audio_io.c
index 54a7f1e..17e5d31 100644
--- a/src/audio_io.c
+++ b/src/audio_io.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+* Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -14,11 +14,8 @@
 * limitations under the License.
 */
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <mm.h>
-#include "audio_io_private.h"
+
+#include <cpp_audio_io.h>
 #include <dlog.h>
 
 #ifdef LOG_TAG
@@ -26,553 +23,194 @@
 #endif
 #define LOG_TAG "TIZEN_N_AUDIO_IO"
 
-#include <mm_sound_pcm_async.h>
-/*
-* Internal Implementation
-*/
-
-
-/*
-* Public Implementation
-*/
-
-/* Audio In */
 int audio_in_create(int sample_rate, audio_channel_e channel, audio_sample_type_e type , audio_in_h* input)
 {
-	return audio_in_create_private (sample_rate, channel, type, SUPPORT_SOURCE_TYPE_DEFAULT, input);
+	return cpp_audio_in_create(sample_rate, channel, type, input);
 }
 
-int audio_in_create_loopback(int sample_rate, audio_channel_e channel, audio_sample_type_e type, audio_in_h* input)
+int audio_in_destroy(audio_in_h input)
 {
-	return audio_in_create_private (sample_rate, channel, type, SUPPORT_SOURCE_TYPE_LOOPBACK, input);
+	return cpp_audio_in_destroy(input);
 }
 
-int audio_in_destroy(audio_in_h input)
+int audio_in_set_sound_stream_info(audio_in_h input, sound_stream_info_h stream_info)
 {
-	AUDIO_IO_NULL_ARG_CHECK(input);
-	audio_in_s *handle = (audio_in_s *) input;
-	int ret = MM_ERROR_NONE;
-
-	if (handle->is_async) {
-		ret = mm_sound_pcm_capture_close_async(handle->mm_handle);
-	} else {
-		ret = mm_sound_pcm_capture_close(handle->mm_handle);
-	}
-	if (ret != MM_ERROR_NONE) {
-		free(handle);
-		return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
-	}
-	free(handle);
-
-	LOGI("[%s] mm_sound_pcm_capture_close() success",__FUNCTION__);
-	return AUDIO_IO_ERROR_NONE;
+	return cpp_audio_in_set_sound_stream_info(input, stream_info);
 }
 
 int audio_in_prepare(audio_in_h input)
 {
-	AUDIO_IO_NULL_ARG_CHECK(input);
-	audio_in_s *handle = (audio_in_s *) input;
-	int ret = MM_ERROR_NONE;
-
-	if (handle->is_async) {
-		ret = mm_sound_pcm_capture_start_async(handle->mm_handle);
-	} else {
-		ret = mm_sound_pcm_capture_start(handle->mm_handle);
-	}
-
-	if (ret != MM_ERROR_NONE) {
-		return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
-	}
-
-	LOGI("[%s] mm_sound_pcm_capture_start() success",__FUNCTION__);
-	return AUDIO_IO_ERROR_NONE;
+	return cpp_audio_in_prepare(input);
 }
 
 int audio_in_unprepare(audio_in_h input)
 {
-	AUDIO_IO_NULL_ARG_CHECK(input);
-	audio_in_s *handle = (audio_in_s *) input;
-	int ret = MM_ERROR_NONE;
-
-	if (handle->is_async) {
-		ret = mm_sound_pcm_capture_stop_async(handle->mm_handle);
-	} else {
-		ret = mm_sound_pcm_capture_stop(handle->mm_handle);
-	}
-	if (ret != MM_ERROR_NONE) {
-		return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
-	}
-
-	LOGI("[%s] mm_sound_pcm_capture_stop() success",__FUNCTION__);
-	return AUDIO_IO_ERROR_NONE;
+	return cpp_audio_in_unprepare(input);
 }
 
-int audio_in_flush(audio_in_h input)
+int audio_in_pause(audio_in_h input)
 {
-	AUDIO_IO_NULL_ARG_CHECK(input);
-	audio_in_s *handle = (audio_in_s *) input;
-	int ret = MM_ERROR_NONE;
-
-	if (handle->is_async) {
-		ret = mm_sound_pcm_capture_flush_async(handle->mm_handle);
-	} else {
-		ret = mm_sound_pcm_capture_flush(handle->mm_handle);
-	}
-	if (ret != MM_ERROR_NONE) {
-		return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
-	}
-
-	LOGI("[%s] mm_sound_pcm_capture_flush() success",__FUNCTION__);
-	return AUDIO_IO_ERROR_NONE;
-}
-
-int audio_in_read(audio_in_h input, void *buffer, unsigned int length )
-{
-	AUDIO_IO_NULL_ARG_CHECK(input);
-	AUDIO_IO_NULL_ARG_CHECK(buffer);
-	audio_in_s *handle = (audio_in_s *) input;
-	int ret = 0;
-	int result = 0;
-
-	if (handle->is_async) {
-		LOGE ("audio_in_read doesn't operate in async mode!!!, use audio_in_peek/audio_in_drop instead");
-		return AUDIO_IO_ERROR_INVALID_OPERATION;
-	}
-
-	ret = mm_sound_pcm_capture_read(handle->mm_handle, (void*) buffer, length);
-	if (ret > 0)
-		return ret;
-
-	switch(ret)
-	{
-		case MM_ERROR_SOUND_INVALID_STATE:
-			result = AUDIO_IO_ERROR_INVALID_OPERATION;
-			LOGE("[%s] (0x%08x) : Not recording started yet.",(char*)__FUNCTION__, AUDIO_IO_ERROR_INVALID_OPERATION);
-			break;
-		default:
-			result = __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
-			break;
-	}
-	return result;
+	return cpp_audio_in_pause(input);
 }
 
-int audio_in_get_buffer_size(audio_in_h input, int *size)
+int audio_in_resume(audio_in_h input)
 {
-	AUDIO_IO_NULL_ARG_CHECK(input);
-	AUDIO_IO_NULL_ARG_CHECK(size);
-	audio_in_s *handle = (audio_in_s *) input;
-
-	*size = handle->_buffer_size;
-
-	LOGI("[%s] buffer size = %d",__FUNCTION__, *size);
-	return AUDIO_IO_ERROR_NONE;
+	return cpp_audio_in_resume(input);
 }
 
-int audio_in_get_sample_rate(audio_in_h input, int *sample_rate)
+int audio_in_flush(audio_in_h input)
 {
-	AUDIO_IO_NULL_ARG_CHECK(input);
-	AUDIO_IO_NULL_ARG_CHECK(sample_rate);
-	audio_in_s *handle = (audio_in_s *) input;
-
-	*sample_rate = handle->_sample_rate;
-
-	LOGI("[%s] sample rate = %d",__FUNCTION__, *sample_rate);
-	return AUDIO_IO_ERROR_NONE;
+	return cpp_audio_in_flush(input);
 }
 
-
-int audio_in_get_channel(audio_in_h input, audio_channel_e *channel)
+int audio_in_read(audio_in_h input, void *buffer, unsigned int length)
 {
-	AUDIO_IO_NULL_ARG_CHECK(input);
-	AUDIO_IO_NULL_ARG_CHECK(channel);
-	audio_in_s *handle = (audio_in_s *) input;
-
-	*channel = handle->_channel;
-
-	LOGI("[%s] channel = %d",__FUNCTION__, *channel);
-	return AUDIO_IO_ERROR_NONE;
+	return cpp_audio_in_read(input, buffer, length);
 }
 
-int audio_in_get_sample_type(audio_in_h input, audio_sample_type_e *type)
+int audio_in_get_buffer_size(audio_in_h input, int *size)
 {
-	AUDIO_IO_NULL_ARG_CHECK(input);
-	AUDIO_IO_NULL_ARG_CHECK(type);
-	audio_in_s *handle = (audio_in_s *) input;
-
-	*type = handle->_type;
-
-	LOGI("[%s] sample type = %d",__FUNCTION__, *type);
-	return AUDIO_IO_ERROR_NONE;
+	return cpp_audio_in_get_buffer_size(input, size);
 }
 
-int audio_in_set_interrupted_cb(audio_in_h input, audio_io_interrupted_cb callback, void *user_data)
+int audio_in_get_sample_rate(audio_in_h input, int *sample_rate)
 {
-	AUDIO_IO_NULL_ARG_CHECK(input);
-	AUDIO_IO_NULL_ARG_CHECK(callback);
-	audio_in_s *handle = (audio_in_s *) input;
-
-	handle->user_cb = callback;
-	handle->user_data = user_data;
-
-	LOGI("[%s] current interrupted cb (%p) / data (%p)",__FUNCTION__, handle->user_cb, handle->user_data);
-	return AUDIO_IO_ERROR_NONE;
+	return cpp_audio_in_get_sample_rate(input, sample_rate);
 }
 
-int audio_in_unset_interrupted_cb(audio_in_h input)
+int audio_in_get_channel(audio_in_h input, audio_channel_e *channel)
 {
-	AUDIO_IO_NULL_ARG_CHECK(input);
-	audio_in_s  * handle = (audio_in_s  *) input;
-
-	handle->user_cb = NULL;
-	handle->user_data = NULL;
-
-	LOGI("[%s] current interrupted cb (%p) / data (%p)",__FUNCTION__, handle->user_cb, handle->user_data);
-	return AUDIO_IO_ERROR_NONE;
+	return cpp_audio_in_get_channel(input, channel);
 }
 
-int audio_in_ignore_session(audio_in_h input)
+int audio_in_get_sample_type(audio_in_h input, audio_sample_type_e *type)
 {
-	AUDIO_IO_NULL_ARG_CHECK(input);
-	audio_in_s  * handle = (audio_in_s  *) input;
-	int ret = 0;
-
-	if (handle->is_async) {
-		LOGE ("Not supported in async mode");
-		return AUDIO_IO_ERROR_INVALID_OPERATION;
-	}
-
-	ret = mm_sound_pcm_capture_ignore_session(handle->mm_handle);
-	if (ret != MM_ERROR_NONE) {
-		return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
-	}
-
-	LOGI("[%s] mm_sound_pcm_capture_ignore_session() success",__FUNCTION__);
-	return AUDIO_IO_ERROR_NONE;
+	return cpp_audio_in_get_sample_type(input, type);
 }
 
-int audio_in_set_stream_cb(audio_in_h input, audio_in_stream_cb callback, void* userdata)
+int audio_in_set_stream_cb(audio_in_h input, audio_in_stream_cb callback, void* user_data)
 {
-	AUDIO_IO_NULL_ARG_CHECK(input);
-	AUDIO_IO_NULL_ARG_CHECK(callback);
-	return audio_in_set_callback_private(input, callback, userdata);
+	return cpp_audio_in_set_stream_cb(input, callback, user_data);
 }
 
 int audio_in_unset_stream_cb(audio_in_h input)
 {
-	AUDIO_IO_NULL_ARG_CHECK(input);
-	return audio_in_set_callback_private(input, NULL, NULL);
+	return cpp_audio_in_unset_stream_cb(input);
 }
 
 int audio_in_peek(audio_in_h input, const void **buffer, unsigned int *length)
 {
-	AUDIO_IO_NULL_ARG_CHECK(input);
-	AUDIO_IO_NULL_ARG_CHECK(buffer);
-	audio_in_s *handle = (audio_in_s *) input;
-	int ret = 0;
-	int result = 0;
-	LOGE("handle->is_async : %d", handle->is_async);
-	if (!handle->is_async) {
-		LOGE ("audio_in_peek doesn't operate in poll mode!!!, use audio_in_read instead");
-		return AUDIO_IO_ERROR_INVALID_OPERATION;
-	}
-
-	LOGE("before mm_sound_pcm_capture_peek(handle[%p], buffer[%p], length[%d])", handle->mm_handle, buffer, length);
-	ret = mm_sound_pcm_capture_peek(handle->mm_handle, buffer, length);
-	LOGE("after mm_sound_pcm_capture_peek() ret[%d]", ret);
-	switch(ret)
-	{
-	case MM_ERROR_SOUND_INVALID_STATE:
-		result = AUDIO_IO_ERROR_INVALID_OPERATION;
-		LOGE("[%s] (0x%08x) : Not recording started yet.",(char*)__FUNCTION__, AUDIO_IO_ERROR_INVALID_OPERATION);
-		break;
-	default:
-		result = __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
-		break;
-	}
-	return result;
+	return cpp_audio_in_peek(input, buffer, length);
 }
 
 int audio_in_drop(audio_in_h input)
 {
-	AUDIO_IO_NULL_ARG_CHECK(input);
-	audio_in_s *handle = (audio_in_s *) input;
-	int ret = 0;
-	int result = 0;
-
-	if (!handle->is_async) {
-		LOGE ("audio_in_drop doesn't operate in poll mode!!!, use audio_in_read instead");
-		return AUDIO_IO_ERROR_INVALID_OPERATION;
-	}
+	return cpp_audio_in_drop(input);
+}
 
-	ret = mm_sound_pcm_capture_drop(handle->mm_handle);
-	if (ret == MM_ERROR_NONE) {
-		return ret;
-	}
+int audio_in_set_state_changed_cb(audio_in_h input, audio_in_state_changed_cb callback, void* user_data)
+{
+	return cpp_audio_in_set_state_changed_cb(input, callback, user_data);
+}
 
-	switch(ret)
-	{
-	case MM_ERROR_SOUND_INVALID_STATE:
-		result = AUDIO_IO_ERROR_INVALID_OPERATION;
-		LOGE("[%s] (0x%08x) : Not recording started yet.",(char*)__FUNCTION__, AUDIO_IO_ERROR_INVALID_OPERATION);
-		break;
-	default:
-		result = __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
-		break;
-	}
-	return result;
+int audio_in_unset_state_changed_cb(audio_in_h input)
+{
+	return cpp_audio_in_unset_state_changed_cb(input);
 }
 
 
 /* Audio Out */
-int audio_out_create(int sample_rate, audio_channel_e channel, audio_sample_type_e type, sound_type_e sound_type,  audio_out_h* output)
+int audio_out_create_new(int sample_rate, audio_channel_e channel, audio_sample_type_e type, audio_out_h *output)
 {
-	return audio_out_create_private(sample_rate, channel, type, sound_type, output);
+	return cpp_audio_out_create_new(sample_rate, channel, type, output);
 }
 
 int audio_out_destroy(audio_out_h output)
 {
-	AUDIO_IO_NULL_ARG_CHECK(output);
-	audio_out_s *handle = (audio_out_s *) output;
-	int ret = MM_ERROR_NONE;
-
-	if (handle->is_async) {
-		ret = mm_sound_pcm_play_close_async(handle->mm_handle);
-	} else {
-		ret = mm_sound_pcm_play_close(handle->mm_handle);
-	}
-	if (ret != MM_ERROR_NONE) {
-		free(handle);
-		return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
-	}
-	free(handle);
+	return cpp_audio_out_destroy(output);
+}
 
-	LOGI("[%s] mm_sound_pcm_play_close() success",__FUNCTION__);
-	return AUDIO_IO_ERROR_NONE;
+int audio_out_set_sound_stream_info(audio_out_h output, sound_stream_info_h stream_info)
+{
+	return cpp_audio_out_set_sound_stream_info(output, stream_info);
 }
 
 int audio_out_prepare(audio_out_h output)
 {
-	AUDIO_IO_NULL_ARG_CHECK(output);
-	audio_out_s *handle = (audio_out_s *) output;
-	int ret = MM_ERROR_NONE;
-
-	if (handle->is_async) {
-		ret = mm_sound_pcm_play_start_async(handle->mm_handle);
-	} else {
-		ret = mm_sound_pcm_play_start(handle->mm_handle);
-	}
-
-	if (ret != MM_ERROR_NONE) {
-		return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
-	}
-
-	LOGI("[%s] mm_sound_pcm_play_start() success",__FUNCTION__);
-	return AUDIO_IO_ERROR_NONE;
+	return cpp_audio_out_prepare(output);
 }
 
 int audio_out_unprepare(audio_out_h output)
 {
-	AUDIO_IO_NULL_ARG_CHECK(output);
-	audio_out_s *handle = (audio_out_s *) output;
-	int ret = MM_ERROR_NONE;
-
-	if (handle->is_async) {
-		ret = mm_sound_pcm_play_stop_async(handle->mm_handle);
-	} else {
-		ret = mm_sound_pcm_play_stop(handle->mm_handle);
-	}
+	return cpp_audio_out_unprepare(output);
+}
 
-	if (ret != MM_ERROR_NONE) {
-		return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
-	}
+int audio_out_pause(audio_out_h output)
+{
+	return cpp_audio_out_pause(output);
+}
 
-	LOGI("[%s] mm_sound_pcm_play_stop() success",__FUNCTION__);
-	return AUDIO_IO_ERROR_NONE;
+int audio_out_resume(audio_out_h output)
+{
+	return cpp_audio_out_resume(output);
 }
 
 int audio_out_drain(audio_out_h output)
 {
-	AUDIO_IO_NULL_ARG_CHECK(output);
-	audio_out_s *handle = (audio_out_s *) output;
-	int ret = MM_ERROR_NONE;
-
-	if (handle->is_async) {
-		ret = mm_sound_pcm_play_drain_async(handle->mm_handle);
-	} else {
-		ret = mm_sound_pcm_play_drain(handle->mm_handle);
-	}
-
-	if (ret != MM_ERROR_NONE) {
-		return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
-	}
-
-	LOGI("[%s] mm_sound_pcm_play_drain() success",__FUNCTION__);
-	return AUDIO_IO_ERROR_NONE;
+	return cpp_audio_out_drain(output);
 }
 
 int audio_out_flush(audio_out_h output)
 {
-	AUDIO_IO_NULL_ARG_CHECK(output);
-	audio_out_s *handle = (audio_out_s *) output;
-	int ret = MM_ERROR_NONE;
-
-	if (handle->is_async) {
-		ret = mm_sound_pcm_play_flush_async(handle->mm_handle);
-	} else {
-		ret = mm_sound_pcm_play_flush(handle->mm_handle);
-	}
-
-	if (ret != MM_ERROR_NONE) {
-		return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
-	}
-
-	LOGI("[%s] mm_sound_pcm_play_flush() success",__FUNCTION__);
-	return AUDIO_IO_ERROR_NONE;
+	return cpp_audio_out_flush(output);
 }
 
 int audio_out_write(audio_out_h output, void* buffer, unsigned int length)
 {
-	AUDIO_IO_NULL_ARG_CHECK(output);
-	AUDIO_IO_NULL_ARG_CHECK(buffer);
-	audio_out_s *handle = (audio_out_s *) output;
-	int ret = MM_ERROR_NONE;
-
-	if (handle->is_async) {
-		ret = mm_sound_pcm_play_write_async(handle->mm_handle, (void*) buffer, length);
-	} else {
-		ret = mm_sound_pcm_play_write(handle->mm_handle, (void*) buffer, length);
-	}
-
-	if (ret > 0)
-		return ret;
-
-	switch(ret)
-	{
-		case MM_ERROR_SOUND_INVALID_STATE:
-			ret = AUDIO_IO_ERROR_INVALID_OPERATION;
-			LOGE("[%s] (0x%08x) : Not playing started yet.",(char*)__FUNCTION__, AUDIO_IO_ERROR_INVALID_OPERATION);
-			break;
-		default:
-			ret = __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
-			break;
-	}
-	return ret;
+	return cpp_audio_out_write(output, buffer, length);
 }
 
 int audio_out_get_buffer_size(audio_out_h output, int *size)
 {
-	AUDIO_IO_NULL_ARG_CHECK(output);
-	AUDIO_IO_NULL_ARG_CHECK(size);
-	audio_out_s *handle = (audio_out_s *) output;
-
-	*size = handle->_buffer_size;
-
-	LOGI("[%s] buffer size = %d",__FUNCTION__, *size);
-	return AUDIO_IO_ERROR_NONE;
+	return cpp_audio_out_get_buffer_size(output, size);
 }
 
 int audio_out_get_sample_rate(audio_out_h output, int *sample_rate)
 {
-	AUDIO_IO_NULL_ARG_CHECK(output);
-	AUDIO_IO_NULL_ARG_CHECK(sample_rate);
-	audio_out_s *handle = (audio_out_s *) output;
-
-	*sample_rate = handle->_sample_rate;
-
-	LOGI("[%s] sample rate = %d",__FUNCTION__, *sample_rate);
-	return AUDIO_IO_ERROR_NONE;
+	return cpp_audio_out_get_sample_rate(output, sample_rate);
 }
 
 int audio_out_get_channel(audio_out_h output, audio_channel_e *channel)
 {
-	AUDIO_IO_NULL_ARG_CHECK(output);
-	AUDIO_IO_NULL_ARG_CHECK(channel);
-	audio_out_s *handle = (audio_out_s *) output;
-
-	*channel = handle->_channel;
-
-	LOGI("[%s] channel = %d",__FUNCTION__, *channel);
-	return AUDIO_IO_ERROR_NONE;
+	return cpp_audio_out_get_channel(output, channel);
 }
 
 int audio_out_get_sample_type(audio_out_h output, audio_sample_type_e *type)
 {
-	AUDIO_IO_NULL_ARG_CHECK(output);
-	AUDIO_IO_NULL_ARG_CHECK(type);
-	audio_out_s *handle = (audio_out_s *) output;
-
-	*type = handle->_type;
-
-	LOGI("[%s] sample type = %d",__FUNCTION__, *type);
-	return AUDIO_IO_ERROR_NONE;
+	return cpp_audio_out_get_sample_type(output, type);
 }
 
 int audio_out_get_sound_type(audio_out_h output, sound_type_e *type)
 {
-	AUDIO_IO_NULL_ARG_CHECK(output);
-	AUDIO_IO_NULL_ARG_CHECK(type);
-	audio_out_s *handle = (audio_out_s *) output;
-
-	*type = handle->_sound_type;
-
-	LOGI("[%s] sound type = %d",__FUNCTION__, *type);
-	return AUDIO_IO_ERROR_NONE;
+	return cpp_audio_out_get_sound_type(output, type);
 }
 
-int audio_out_set_interrupted_cb(audio_out_h output, audio_io_interrupted_cb callback, void *user_data)
+int audio_out_set_stream_cb(audio_out_h output, audio_out_stream_cb callback, void* user_data)
 {
-	AUDIO_IO_NULL_ARG_CHECK(output);
-	AUDIO_IO_NULL_ARG_CHECK(callback);
-	audio_out_s *handle = (audio_out_s *) output;
-
-	handle->user_cb = callback;
-	handle->user_data = user_data;
-
-	LOGI("[%s] current interrupted cb (%p) / data (%p)",__FUNCTION__, handle->user_cb, handle->user_data);
-	return AUDIO_IO_ERROR_NONE;
+	return cpp_audio_out_set_stream_cb(output, callback, user_data);
 }
 
-int audio_out_unset_interrupted_cb(audio_out_h output)
-{
-	AUDIO_IO_NULL_ARG_CHECK(output);
-	audio_out_s *handle = (audio_out_s *) output;
-
-	handle->user_cb = NULL;
-	handle->user_data = NULL;
-
-	LOGI("[%s] current interrupted cb (%p) / data (%p)",__FUNCTION__, handle->user_cb, handle->user_data);
-	return AUDIO_IO_ERROR_NONE;
-}
-
-int audio_out_ignore_session(audio_out_h output)
+int audio_out_unset_stream_cb(audio_out_h output)
 {
-	AUDIO_IO_NULL_ARG_CHECK(output);
-	audio_out_s *handle = (audio_out_s *) output;
-	int ret = 0;
-
-	if (handle->is_async) {
-		LOGE ("Not supported in async mode");
-		return AUDIO_IO_ERROR_INVALID_OPERATION;
-	}
-
-	ret = mm_sound_pcm_play_ignore_session(handle->mm_handle);
-	if (ret != MM_ERROR_NONE) {
-		return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
-	}
-	LOGI("[%s] mm_sound_pcm_play_ignore_session() success",__FUNCTION__);
-
-	return AUDIO_IO_ERROR_NONE;
+	return cpp_audio_out_unset_stream_cb(output);
 }
 
-int audio_out_set_stream_cb(audio_out_h output, audio_out_stream_cb callback, void* userdata)
+int audio_out_set_state_changed_cb(audio_out_h output, audio_out_state_changed_cb callback, void* user_data)
 {
-	AUDIO_IO_NULL_ARG_CHECK(output);
-	AUDIO_IO_NULL_ARG_CHECK(callback);
-	return audio_out_set_callback_private(output, callback, userdata);
+	return cpp_audio_out_set_state_changed_cb(output, callback, user_data);
 }
 
-int audio_out_unset_stream_cb(audio_out_h output)
+int audio_out_unset_state_changed_cb(audio_out_h output)
 {
-	AUDIO_IO_NULL_ARG_CHECK(output);
-	return audio_out_set_callback_private(output, NULL, NULL);
+	return cpp_audio_out_unset_state_changed_cb(output);
 }