tizen 2.3 releasetizen_2.3_releasesubmit/tizen_2.3/20150202.060724tizen_2.3

53 files changed, 1974 insertions, 3735 deletions

diff --git a/wearable/AUTHORS b/AUTHORS
index b01c60f..b01c60f 100644
--- a/wearable/AUTHORS
+++ b/AUTHORS
diff --git a/wearable/CMakeLists.txt b/CMakeLists.txt
index e07a48b..991dc46 100755
--- a/wearable/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -10,7 +10,7 @@ SET(PREFIX ${CMAKE_INSTALL_PREFIX})
 SET(INC_DIR include)
 INCLUDE_DIRECTORIES(${INC_DIR})
 
-SET(dependents "dlog mm-pcmsound capi-base-common capi-media-sound-manager")
+SET(dependents "dlog glib-2.0 mm-sound capi-base-common capi-media-sound-manager")
 SET(pc_dependents "capi-base-common capi-media-sound-manager")
 
 INCLUDE(FindPkgConfig)
diff --git a/wearable/LICENSE b/LICENSE
index bbe9d02..bbe9d02 100644
--- a/wearable/LICENSE
+++ b/LICENSE
diff --git a/mobile/capi-media-audio-io.manifest b/capi-media-audio-io.manifest
index a76fdba..a76fdba 100644
--- a/mobile/capi-media-audio-io.manifest
+++ b/capi-media-audio-io.manifest
diff --git a/wearable/capi-media-audio-io.pc.in b/capi-media-audio-io.pc.in
index 5d02f8d..5d02f8d 100644
--- a/wearable/capi-media-audio-io.pc.in
+++ b/capi-media-audio-io.pc.in
diff --git a/wearable/doc/audio_io_doc.h b/doc/audio_io_doc.h
index 88bf7d5..4ca1422 100644
--- a/wearable/doc/audio_io_doc.h
+++ b/doc/audio_io_doc.h
@@ -21,7 +21,7 @@
 
 /**
  * @file audio_io_doc.h
- * @brief File contains the high level documentation for the Audio I/O API.
+ * @brief This file contains high level documentation for the Audio I/O API.
  *
  */
 
@@ -31,21 +31,21 @@
  */
 
 /**
- * @addtogroup CAPI_MEDIA_AUDIO_IO_MODULE
- * @brief The @ref CAPI_MEDIA_AUDIO_IO_MODULE API  provides functions for controlling the audio devices.
  * @ingroup CAPI_MEDIA_FRAMEWORK
-  * @section CAPI_MEDIA_AUDIO_IO_MODULE_HEADER Required Header
+ * @addtogroup CAPI_MEDIA_AUDIO_IO_MODULE
+ * @brief The @ref CAPI_MEDIA_AUDIO_IO_MODULE API provides functions for controlling audio devices.
+ * @section CAPI_MEDIA_AUDIO_IO_MODULE_HEADER Required Header
  *    \#include <audio_io.h>
  *
  * @section CAPI_MEDIA_AUDIO_IO_MODULE_OVERVIEW Overview
- * The Audio I/O API provides set of functions to directly manage the system audio devices. 
+ * The Audio I/O API provides a set of functions to directly manage the system audio devices.
  * It gives easy access to the hardware layer of the sound card with a professional multichannel audio interface.
  * It should be used for activities requiring raw audio data buffers(PCM format).
  *
- * Programming the interface requires first obtaining a handle to the device, via the audio_in_create() or audio_out_create() functions
+ * Programming the interface requires first obtaining a handle to the device, via the audio_in_create() or audio_out_create() function.
  *
  * The input and output devices both have an available set of queries, to find the suggested buffer size, sampling rate, channel type,
- * and sample type.  For output there is an additional query, to get the sound type (these types are defined in the @ref CAPI_MEDIA_SOUND_MANAGER_MODULE API)
+ * and sample type. For output, there is an additional query, to get the sound type (these types are defined in the @ref CAPI_MEDIA_SOUND_MANAGER_MODULE API).
  *
  * Reading and writing is done by allocating a buffer and passing the buffer to the input device
  * via audio_in_start_recording(), audio_in_read(), or writing to the buffer and passing it to the output device via audio_out_write().
@@ -53,22 +53,39 @@
  */
 
  /**
+ * @ingroup CAPI_MEDIA_AUDIO_IO_MODULE
  * @defgroup CAPI_MEDIA_AUDIO_IN_MODULE Audio Input
- * @brief It provides set of functions to directly manage the system audio input devices.
+ * @brief The @ref CAPI_MEDIA_AUDIO_IN_MODULE API provides a set of functions to directly manage the system audio input devices.
  * @section CAPI_MEDIA_AUDIO_IN_MODULE_HEADER Required Header
  *   \#include <audio_io.h>
  *
- * @ingroup CAPI_MEDIA_AUDIO_IO_MODULE
+ * @section CAPI_MEDIA_AUDIO_IN_MODULE_OVERVIEW Overview
+ * The Audio Input API provides a set of functions to record audio data (PCM format) from audio devices.
+ *
+ * @section CAPI_MEDIA_AUDIO_IN_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ *  - http://tizen.org/feature/microphone\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
  *
  */
 
  /**
+ * @ingroup CAPI_MEDIA_AUDIO_IO_MODULE
  * @defgroup CAPI_MEDIA_AUDIO_OUT_MODULE Audio Output
- * @brief It provides set of functions to directly manage the system audio output devices
+ * @brief The @ref CAPI_MEDIA_AUDIO_OUT_MODULE API provides a set of functions to directly manage the system audio output devices.
  * @section CAPI_MEDIA_AUDIO_OUT_MODULE_HEADER Required Header
  *   \#include <audio_io.h>
  *
- * @ingroup CAPI_MEDIA_AUDIO_IO_MODULE
+ * @section CAPI_MEDIA_AUDIO_OUT_MODULE_OVERVIEW Overview
+ * The Audio Output API provides a set of functions to play recorded audio data from Audio Input.
+ *
  *
  */
 #endif /* __TIZEN_MEDIA_AUDIO_IO_DOC_H__ */
diff --git a/include/audio_io.h b/include/audio_io.h
new file mode 100644
index 0000000..0b237cf
--- /dev/null
+++ b/include/audio_io.h
@@ -0,0 +1,781 @@
+/*
+* Copyright (c) 2011 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.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License. 
+*/
+
+#ifndef __TIZEN_MEDIA_AUDIO_IO_H__
+#define __TIZEN_MEDIA_AUDIO_IO_H__
+
+#include <tizen.h>
+#include <sound_manager.h>
+#include <sys/types.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**
+ * @file audio_io.h
+ * @brief This file contains the Audio Input and Audio Output API.
+ */
+
+/**
+ * @addtogroup CAPI_MEDIA_AUDIO_IN_MODULE
+ * @{
+*/
+
+/**
+ * @brief The audio input handle.
+ * @since_tizen 2.3
+ */
+typedef struct audio_in_s *audio_in_h;
+
+/**
+ * @}
+*/
+
+/**
+ * @addtogroup CAPI_MEDIA_AUDIO_OUT_MODULE
+ * @{
+ */
+ 
+/**
+ * @brief The audio output handle.
+ * @since_tizen 2.3
+ */
+typedef struct audio_out_s *audio_out_h;
+
+ /**
+ * @}
+ */
+
+/**
+ * @addtogroup CAPI_MEDIA_AUDIO_IO_MODULE
+ * @{
+ */
+
+/**
+ * @brief Enumeration for audio sample type with bit depth.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+    AUDIO_SAMPLE_TYPE_U8 = 0x70,    /**< Unsigned 8-bit audio samples */
+    AUDIO_SAMPLE_TYPE_S16_LE,       /**< Signed 16-bit audio samples */
+} audio_sample_type_e;
+
+/**
+ * @brief Enumeration for audio channel.
+ * @since_tizen 2.3
+ */
+typedef enum {
+    AUDIO_CHANNEL_MONO = 0x80,                  /**< 1 channel, mono */
+    AUDIO_CHANNEL_STEREO,                       /**< 2 channel, stereo */
+} audio_channel_e;
+
+/**
+ * @brief Enumeration for audio input and output error.
+ * @since_tizen 2.3
+ */
+typedef enum{
+    AUDIO_IO_ERROR_NONE                = TIZEN_ERROR_NONE,              /**< Successful */
+    AUDIO_IO_ERROR_OUT_OF_MEMORY       = TIZEN_ERROR_OUT_OF_MEMORY,     /**< Out of memory */
+    AUDIO_IO_ERROR_INVALID_PARAMETER   = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
+    AUDIO_IO_ERROR_INVALID_OPERATION   = TIZEN_ERROR_INVALID_OPERATION, /**< Invalid operation */
+    AUDIO_IO_ERROR_PERMISSION_DENIED   = TIZEN_ERROR_PERMISSION_DENIED, /**< Device open error by security */
+    AUDIO_IO_ERROR_NOT_SUPPORTED       = TIZEN_ERROR_NOT_SUPPORTED,     /**< Not supported */
+    AUDIO_IO_ERROR_DEVICE_NOT_OPENED   = TIZEN_ERROR_AUDIO_IO | 0x01,   /**< Device open error */
+    AUDIO_IO_ERROR_DEVICE_NOT_CLOSED   = TIZEN_ERROR_AUDIO_IO | 0x02,   /**< Device close error */
+    AUDIO_IO_ERROR_INVALID_BUFFER      = TIZEN_ERROR_AUDIO_IO | 0x03,   /**< Invalid buffer pointer */
+    AUDIO_IO_ERROR_SOUND_POLICY        = TIZEN_ERROR_AUDIO_IO | 0x04,   /**< Sound policy error */
+} audio_io_error_e;
+
+/**
+ * @brief Enumeration for audio IO interrupted messages.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+    AUDIO_IO_INTERRUPTED_COMPLETED = 0,         /**< Interrupt completed */
+    AUDIO_IO_INTERRUPTED_BY_MEDIA,              /**< Interrupted by a media application */
+    AUDIO_IO_INTERRUPTED_BY_CALL,               /**< Interrupted by an incoming call */
+    AUDIO_IO_INTERRUPTED_BY_EARJACK_UNPLUG,     /**< Interrupted by unplugging headphones */
+    AUDIO_IO_INTERRUPTED_BY_RESOURCE_CONFLICT,  /**< Interrupted by a resource conflict */
+    AUDIO_IO_INTERRUPTED_BY_ALARM,              /**< Interrupted by an alarm */
+    AUDIO_IO_INTERRUPTED_BY_EMERGENCY,          /**< Interrupted by an emergency */
+    AUDIO_IO_INTERRUPTED_BY_NOTIFICATION,       /**< Interrupted by a notification */
+} audio_io_interrupted_code_e;
+
+/**
+ * @brief Called when audio input or output is interrupted.
+ *
+ * @since_tizen 2.3
+ * @param[in] error_code The interrupted error code
+ * @param[in] user_data The user data passed from the callback registration function
+ *
+ * @see audio_in_set_interrupted_cb()
+ * @see audio_out_set_interrupted_cb()
+ * @see audio_in_unset_interrupted_cb()
+ * @see audio_out_unset_interrupted_cb()
+ */
+typedef void (*audio_io_interrupted_cb)(audio_io_interrupted_code_e code, void *user_data);
+
+/**
+ * @}
+*/
+
+/**
+ * @addtogroup CAPI_MEDIA_AUDIO_IN_MODULE
+ * @{
+*/
+
+//
+//AUDIO INPUT
+//
+
+/**
+ * @brief Called when audio input data is available in asynchronous(event) mode.
+ *
+ * @since_tizen 2.3
+ *
+ * @remarks @a use audio_in_peek() to get audio in data inside callback, use audio_in_drop() after use of peeked data.
+ *
+ * @param[in] handle The handle to the audio input
+ * @param[in] nbytes The amount of available audio in data which can be peeked.
+ * @param[in] userdata The user data passed from the callback registration function
+ *
+ * @see audio_in_set_stream_cb()
+ */
+typedef void (*audio_in_stream_cb)(audio_in_h handle, size_t nbytes, void *userdata);
+
+/**
+ * @brief Creates an audio device instance and returns an input handle to record PCM (pulse-code modulation) data.
+ *
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/recorder
+ *
+ * @details This function is used for audio input initialization.
+ *
+ * @remarks @a input must be released using audio_in_destroy().
+ *
+ * @param[in] sample_rate	The audio sample rate in 8000[Hz] ~ 48000[Hz]
+ * @param[in] channel	The audio channel type (mono or stereo)
+ * @param[in] type	The type of audio sample (8- or 16-bit)
+ * @param[out] input	An audio input handle is created on success
+ * @return @c 0 on success,
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #AUDIO_IO_ERROR_PERMISSION_DENIED Permission denied
+ * @retval #AUDIO_IO_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #AUDIO_IO_ERROR_DEVICE_NOT_OPENED Device not opened
+ * @retval #AUDIO_IO_ERROR_SOUND_POLICY Sound policy error
+ * @retval #AUDIO_IO_ERROR_NOT_SUPPORTED Not supported
+ * @see audio_in_destroy()
+ */
+int audio_in_create(int sample_rate, audio_channel_e channel, audio_sample_type_e type, audio_in_h *input);
+
+/**
+ * @brief Creates an audio loopback device instance and returns an input handle to record PCM (pulse-code modulation) data.
+ *
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/recorder
+ *
+ * @details This function is used for audio loopback input initialization.
+ *
+ * @remarks @a input must be released using audio_in_destroy().
+ *
+ * @param[in] sample_rate	The audio sample rate in 8000[Hz] ~ 48000[Hz]
+ * @param[in] channel	The audio channel type, mono, or stereo
+ * @param[in] type	The type of audio sample (8- or 16-bit)
+ * @param[out] input	An audio input handle will be created, if successful
+ * @return @c 0 on success,
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #AUDIO_IO_ERROR_PERMISSION_DENIED Permission denied
+ * @retval #AUDIO_IO_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #AUDIO_IO_ERROR_DEVICE_NOT_OPENED Device not opened
+ * @retval #AUDIO_IO_ERROR_SOUND_POLICY Sound policy error
+ * @retval #AUDIO_IO_ERROR_NOT_SUPPORTED Not supported
+ * @see audio_in_destroy()
+ */
+int audio_in_create_loopback(int sample_rate, audio_channel_e channel, audio_sample_type_e type , audio_in_h* input);
+
+/**
+ * @brief Releases the audio input handle and all its resources associated with an audio stream.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] input The handle to the audio input to destroy
+ * @return @c 0 on success,
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #AUDIO_IO_ERROR_DEVICE_NOT_CLOSED Device not closed
+ * @retval #AUDIO_IO_ERROR_NOT_SUPPORTED Not supported
+ * @see audio_in_create()
+ */
+int audio_in_destroy(audio_in_h input);
+
+/**
+ * @brief Prepares reading audio input by starting buffering of audio data from the device.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] input The handle to the audio input
+ * @return @c 0 on success,
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #AUDIO_IO_ERROR_NOT_SUPPORTED Not supported
+ *
+ * @see audio_in_unprepare()
+ */
+int audio_in_prepare(audio_in_h input);
+
+/**
+ * @brief Unprepares reading audio input by stopping buffering the audio data from the device.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] input The handle to the audio input
+ * @return @c 0 on success,
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #AUDIO_IO_ERROR_NOT_SUPPORTED Not supported
+ * @see audio_in_prepare()
+ */
+int audio_in_unprepare(audio_in_h input);
+
+/**
+ * @brief Reads audio data from the audio input buffer.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] input The handle to the audio input
+ * @param[out] buffer The PCM buffer address
+ * @param[in] length The length of the PCM data buffer (in bytes)
+ * @return The number of read bytes on success, 
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #AUDIO_IO_ERROR_INVALID_BUFFER Invalid buffer pointer
+ * @retval #AUDIO_IO_ERROR_SOUND_POLICY Sound policy error
+ * @retval #AUDIO_IO_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #AUDIO_IO_ERROR_NOT_SUPPORTED Not supported
+ * @pre audio_in_start_recording().
+*/
+int audio_in_read(audio_in_h input, void *buffer, unsigned int length);
+
+/**
+ * @brief Gets the size to be allocated for the audio input buffer.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] input The handle to the audio input
+ * @param[out] size The buffer size (in bytes, the maximum size is 1 MB)
+ * @return @c 0 on success,
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #AUDIO_IO_ERROR_NOT_SUPPORTED Not supported
+ * @see audio_in_read()
+*/
+int audio_in_get_buffer_size(audio_in_h input, int *size);
+
+/**
+ * @brief Gets the sample rate of the audio input data stream.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] input The handle to the audio input
+ * @param[out] sample_rate The audio sample rate in Hertz (8000 ~ 48000)
+ * @return @c 0 on success,
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #AUDIO_IO_ERROR_NOT_SUPPORTED Not supported
+*/
+int audio_in_get_sample_rate(audio_in_h input, int *sample_rate);
+
+/**
+ * @brief Gets the channel type of the audio input data stream.
+ *
+ * @since_tizen 2.3
+ *
+ * @details The audio channel type defines whether the audio is mono or stereo.
+ *
+ * @param[in] input The handle to the audio input
+ * @param[out] channel The audio channel type
+ * @return @c 0 on success,
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #AUDIO_IO_ERROR_NOT_SUPPORTED Not supported
+*/
+int audio_in_get_channel(audio_in_h input, audio_channel_e *channel);
+
+/**
+ * @brief Gets the sample audio format (8-bit or 16-bit) of the audio input data stream.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] input The handle to the audio input
+ * @param[out] type The audio sample type
+ * @return @c 0 on success,
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #AUDIO_IO_ERROR_NOT_SUPPORTED Not supported
+*/
+int audio_in_get_sample_type(audio_in_h input, audio_sample_type_e *type);
+
+/**
+ * @brief Registers a callback function to be invoked when the audio input handle is interrupted or the interrupt is completed.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] input The handle to the audio input
+ * @param[in] callback The callback function to register
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return @c 0 on success,
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #AUDIO_IO_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #AUDIO_IO_ERROR_NOT_SUPPORTED Not supported
+ * @post audio_io_interrupted_cb() will be invoked.
+ *
+ * @see audio_in_unset_interrupted_cb()
+ * @see audio_io_interrupted_cb()
+ */
+int audio_in_set_interrupted_cb(audio_in_h input, audio_io_interrupted_cb callback, void *user_data);
+
+/**
+ * @brief Unregisters the callback function.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] input The handle to the audio input
+ * @return @c 0 on success,
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #AUDIO_IO_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #AUDIO_IO_ERROR_NOT_SUPPORTED Not supported
+ *
+ * @see audio_in_set_interrupted_cb()
+ */
+int audio_in_unset_interrupted_cb(audio_in_h input);
+
+/**
+ * @brief Ignores session for input.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] input The handle to the audio input
+ * @return @c 0 on success,
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #AUDIO_IO_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #AUDIO_IO_ERROR_NOT_SUPPORTED Not supported
+ */
+int audio_in_ignore_session(audio_in_h input);
+
+/**
+ * @brief Sets an asynchronous(event) callback function to handle recording PCM (pulse-code modulation) data.
+ *
+ * @since_tizen 2.3
+ *
+ * @details @a callback will be called when you can read a PCM data.
+ * It might cause dead lock if change the state of audio handle in callback.
+ * (ex: audio_in_destroy, audio_in_prepare, audio_in_unprepare)
+ * Recommend to use as a VOIP only.
+ * Recommend not to hold callback too long.(it affects latency)
+ *
+ * @remarks @a input must be created using audio_in_create().
+ *
+ * @param[in] input    An audio input handle
+ * @param[in] callback notify stream callback when user can read data (#audio_in_stream_cb)
+ * @param[in] userdata user data to be retrieved when callback is called
+ * @return @c 0 on success,
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #AUDIO_IO_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #AUDIO_IO_ERROR_DEVICE_NOT_OPENED Device not opened
+ * @retval #AUDIO_IO_ERROR_SOUND_POLICY Sound policy error
+ * @retval #AUDIO_IO_ERROR_NOT_SUPPORTED Not supported
+ *
+ * @see audio_out_set_stream_cb()
+ */
+int audio_in_set_stream_cb(audio_in_h input, audio_in_stream_cb callback, void* userdata);
+
+/**
+ * @brief Unregisters the callback function.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] input The handle to the audio input
+ * @return @c 0 on success,
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #AUDIO_IO_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #AUDIO_IO_ERROR_NOT_SUPPORTED Not supported
+ *
+ * @see audio_in_set_interrupted_cb()
+ */
+int audio_in_unset_stream_cb(audio_in_h input);
+
+/**
+ * @brief peek from audio in buffer
+ *
+ * @since_tizen 2.3
+ *
+ * @details This function works correctly only with read, write callback. Otherwise it won't operate as intended.
+ *
+ * @remarks @a Works only in asynchronous(event) mode. This will just retrieve buffer pointer from audio in buffer. Drop after use.
+ *
+ * @param[in] input The handle to the audio input
+ * @param[out] buffer start buffer pointer of peeked audio in data
+ * @param[in,out] length amount of audio in data to be peeked
+ * @return @c 0 on success,
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #AUDIO_IO_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #AUDIO_IO_ERROR_NOT_SUPPORTED Not supported
+ *
+ * @see audio_in_drop()
+ */
+int audio_in_peek(audio_in_h input, const void **buffer, unsigned int *length);
+
+/**
+ * @brief drop peeked audio buffer.
+ *
+ * @details This function works correctly only with read, write callback. Otherwise it won't operate as intended.
+ *
+ * @since_tizen 2.3
+ *
+ * @remarks @a Works only in asynchronous(event) mode. This will remove audio in data from actual stream buffer. Use this if peeked data is not needed anymore.
+ *
+ * @param[in] input The handle to the audio input
+ * @return 0 on success, otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #AUDIO_IO_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #AUDIO_IO_ERROR_NOT_SUPPORTED Not supported
+ *
+ * @see audio_in_peek()
+ */
+int audio_in_drop(audio_in_h input);
+
+
+
+//
+// AUDIO OUTPUT
+//
+
+/**
+ * @}
+*/
+
+/**
+ * @addtogroup CAPI_MEDIA_AUDIO_OUT_MODULE
+ * @{
+ */
+
+/**
+ * @brief Called when audio out data can be written in asynchronous(event) mode.
+ *
+ * @since_tizen 2.3
+ *
+ * @remarks @a use audio_out_write() to write pcm data inside this callback.
+ * @param[in] handle The handle to the audio output
+ * @param[in] nbytes The amount of audio in data which can be written.
+ * @param[in] userdata The user data passed from the callback registration function
+ *
+ * @see audio_out_set_stream_cb()
+ */
+typedef void (*audio_out_stream_cb)(audio_out_h handle, size_t nbytes, void *userdata);
+
+/**
+ * @brief Creates an audio device instance and returns an output handle to play PCM (pulse-code modulation) data.
+
+ * @since_tizen 2.3
+ *
+ * @details This function is used for audio output initialization.
+ *
+ * @remarks @a output must be released by audio_out_destroy().
+ *
+ * @param[in] sample_rate The audio sample rate in 8000[Hz] ~ 48000[Hz]
+ * @param[in] channel The audio channel type (mono or stereo)
+ * @param[in] type The type of audio sample (8- or 16-bit)
+ * @param[in] sound_type The type of sound (#sound_type_e)
+ * @param[out] output An audio output handle is created on success
+ * @return @c 0 on success,
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #AUDIO_IO_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #AUDIO_IO_ERROR_DEVICE_NOT_OPENED Device not opened
+ * @retval #AUDIO_IO_ERROR_SOUND_POLICY Sound policy error
+ *
+ * @see audio_out_destroy()
+*/
+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);
+
+/**
+ * @brief Releases the audio output handle, along with all its resources.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] output The handle to the audio output to destroy
+ * @return @c 0 on success,
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #AUDIO_IO_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #AUDIO_IO_ERROR_DEVICE_NOT_CLOSED Device not closed
+ *
+ * @see audio_out_create()
+*/
+int audio_out_destroy(audio_out_h output);
+
+/**
+ * @brief Prepares playing audio output, this must be called before audio_out_write().
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] output The handle to the audio output
+ * @return @c 0 on success,
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ *
+ * @see audio_out_unprepare()
+ */
+int audio_out_prepare(audio_out_h output);
+
+/**
+ * @brief Unprepares playing audio output.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] output The handle to the audio output
+ * @return @c 0 on success,
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ *
+ * @see audio_out_prepare()
+ */
+int audio_out_unprepare(audio_out_h output);
+
+/**
+ * @brief Starts writing the audio data to the device.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] output The handle to the audio output
+ * @param[in,out] buffer The PCM buffer address
+ * @param[in] length The length of the PCM buffer (in bytes)
+ * @return The written data size on success, 
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #AUDIO_IO_ERROR_INVALID_BUFFER Invalid buffer pointer
+ * @retval #AUDIO_IO_ERROR_SOUND_POLICY Sound policy error
+*/
+int audio_out_write(audio_out_h output, void *buffer, unsigned int length);
+
+/**
+ * @brief Gets the size to be allocated for the audio output buffer.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] output The handle to the audio output
+ * @param[out] size The suggested buffer size (in bytes, the maximum size is 1 MB)
+ * @return  @c 0 on success,
+ *          otherwise a negative error value
+ * @retval  #AUDIO_IO_ERROR_NONE Successful
+ * @retval  #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ *
+ * @see audio_out_write()
+*/
+int audio_out_get_buffer_size(audio_out_h output, int *size);
+
+/**
+ * @brief Gets the sample rate of the audio output data stream.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] output The handle to the audio output
+ * @param[out] sample_rate The audio sample rate in Hertz (8000 ~ 48000)
+ * @return  @c 0 on success,
+ *          otherwise a negative error value
+ * @retval  #AUDIO_IO_ERROR_NONE Successful
+ * @retval  #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+*/
+int audio_out_get_sample_rate(audio_out_h output, int *sample_rate);
+
+/**
+ * @brief Gets the channel type of the audio output data stream.
+ * @details The audio channel type defines whether the audio is mono or stereo.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] output The handle to the audio output
+ * @param[out] channel The audio channel type
+ * @return @c 0 on success,
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+*/
+int audio_out_get_channel(audio_out_h output, audio_channel_e *channel);
+
+/**
+ * @brief Gets the sample audio format (8-bit or 16-bit) of the audio output data stream.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] output The handle to the audio output
+ * @param[out] type The audio sample type
+ * @return @c 0 on success,
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+*/
+int audio_out_get_sample_type(audio_out_h output, audio_sample_type_e *type);
+
+
+/**
+ * @brief Gets the sound type supported by the audio output device.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] output The handle to the audio output
+ * @param[out] type The sound type
+ * @return @c 0 on success,
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+*/
+int audio_out_get_sound_type(audio_out_h output, sound_type_e *type);
+
+/**
+ * @brief Registers a callback function to be invoked when the audio output handle is interrupted or the interrupt is completed.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] output The handle to the audio output
+ * @param[in] callback	The callback function to register
+ * @param[in] user_data	The user data to be passed to the callback function
+ * @return @c 0 on success,
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #AUDIO_IO_ERROR_INVALID_OPERATION Invalid operation
+ *
+ * @post audio_io_interrupted_cb() will be invoked.
+ * @see audio_out_unset_interrupted_cb()
+ * @see audio_io_interrupted_cb()
+ */
+int audio_out_set_interrupted_cb(audio_out_h output, audio_io_interrupted_cb callback, void *user_data);
+
+/**
+ * @brief Unregisters the callback function.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] output The handle to the audio output
+ * @return @c 0 on success,
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #AUDIO_IO_ERROR_INVALID_OPERATION Invalid operation
+ *
+ * @see audio_out_set_interrupted_cb()
+ */
+int audio_out_unset_interrupted_cb(audio_out_h output);
+
+/**
+ * @brief Ignores session for output.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] output The handle to the audio output
+ * @return @c 0 on success,
+ *         otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #AUDIO_IO_ERROR_INVALID_OPERATION Invalid operation
+ */
+int audio_out_ignore_session(audio_out_h output);
+
+/**
+ * @brief Sets an asynchronous(event) callback function to handle playing PCM (pulse-code modulation) data.
+ *
+ * @since_tizen 2.3
+ *
+ * @details @a callback will be called when you can write a PCM data.
+ * It might cause dead lock if change the state of audio handle in callback.
+ * (ex: audio_in_destroy, audio_in_prepare, audio_in_unprepare)
+ * Recommend to use as a VOIP only.
+ * Recommend not to hold callback too long.(it affects latency)
+ *
+ * @remarks @a output must be created using audio_out_create().
+ *
+ * @param[in] output   An audio output handle
+ * @param[in] callback notify stream callback when user can write data (#audio_out_stream_cb)
+ * @param[in] userdata user data to be retrieved when callback is called
+ * @return 0 on success, otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #AUDIO_IO_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #AUDIO_IO_ERROR_DEVICE_NOT_OPENED Device not opened
+ * @retval #AUDIO_IO_ERROR_SOUND_POLICY Sound policy error
+ *
+ * @see audio_in_set_stream_cb()
+ */
+int audio_out_set_stream_cb(audio_out_h output, audio_out_stream_cb callback, void* userdata);
+
+/**
+ * @brief Unregisters the callback function.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] output The handle to the audio output
+ * @return 0 on success, otherwise a negative error value
+ * @retval #AUDIO_IO_ERROR_NONE Successful
+ * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #AUDIO_IO_ERROR_INVALID_OPERATION Invalid operation
+ *
+ * @see audio_out_set_stream_cb()
+ */
+int audio_out_unset_stream_cb(audio_out_h output);
+/**
+ * @}
+*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __TIZEN_MEDIA_AUDIO_IO_H__ */
diff --git a/include/audio_io_private.h b/include/audio_io_private.h
new file mode 100644
index 0000000..31bb83c
--- /dev/null
+++ b/include/audio_io_private.h
@@ -0,0 +1,88 @@
+/*
+* Copyright (c) 2011 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.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License. 
+*/
+
+#ifndef __TIZEN_MEDIA_AUDIO_IO_PRIVATE_H__
+#define __TIZEN_MEDIA_AUDIO_IO_PRIVATE_H__
+#include <sound_manager.h>
+#include <mm_sound.h>
+#include "audio_io.h"
+
+/*
+* Internal Macros
+*/
+
+#define AUDIO_IO_INTERRUPTED_BY_RESUMABLE_MEDIA       (AUDIO_IO_INTERRUPTED_BY_NOTIFICATION + 1)
+#define AUDIO_IO_INTERRUPTED_BY_RESUMABLE_CANCELED    (AUDIO_IO_INTERRUPTED_BY_NOTIFICATION + 2)
+
+#define AUDIO_IO_CHECK_CONDITION(condition,error,msg)   \
+                if(condition) {} else \
+                { LOGE("[%s] %s(0x%08x)",__FUNCTION__, msg,error); return error;}; \
+
+#define AUDIO_IO_NULL_ARG_CHECK(arg)	\
+	AUDIO_IO_CHECK_CONDITION(arg != NULL, AUDIO_IO_ERROR_INVALID_PARAMETER, "AUDIO_IO_ERROR_INVALID_PARAMETER" )
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct _audio_in_s{
+	MMSoundPcmHandle_t mm_handle;
+	int is_async;
+	int is_loopback;
+	int _buffer_size;
+	int _sample_rate;
+	audio_channel_e _channel;
+	audio_sample_type_e _type;
+	audio_io_interrupted_cb user_cb;
+	void* user_data;
+	audio_in_stream_cb stream_cb;
+	void* stream_userdata;
+} audio_in_s;
+
+typedef struct _audio_out_s{
+	MMSoundPcmHandle_t mm_handle;
+	int is_async;
+	int is_loopback;
+	int _buffer_size;
+	int _sample_rate;
+	audio_channel_e _channel;
+	audio_sample_type_e _type; 	
+	sound_type_e	_sound_type;
+	audio_io_interrupted_cb user_cb;
+	void* user_data;
+	audio_out_stream_cb stream_cb;
+	void* stream_userdata;
+} audio_out_s;
+
+int __convert_audio_io_error_code(int code, char *func_name);
+int __check_parameter(int sample_rate, audio_channel_e channel, audio_sample_type_e type);
+int __mm_sound_pcm_capture_msg_cb (int message, void *param, void *user_param);
+audio_io_interrupted_code_e __translate_interrupted_code (int code);
+
+int audio_in_create_private(int sample_rate, audio_channel_e channel, audio_sample_type_e type , int source_type, audio_in_h* input);
+
+int audio_in_set_callback_private(audio_in_h input, audio_in_stream_cb callback, void* userdata);
+
+int audio_out_create_private(int sample_rate, audio_channel_e channel, audio_sample_type_e type, sound_type_e sound_type, audio_out_h* output);
+
+int audio_out_set_callback_private(audio_out_h output, audio_out_stream_cb callback, void* userdata);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //__TIZEN_MEDIA_AUDIO_IO_PRIVATE_H__
diff --git a/mobile/AUTHORS b/mobile/AUTHORS
deleted file mode 100644
index 56edb13..0000000
--- a/mobile/AUTHORS
+++ /dev/null
@@ -1,3 +0,0 @@
-Kangho Hur <kanho.hur@samsung.com>
-Seungkeun Lee <sngn.lee@samsung.com>
-Seungbae Shin <seungbae.shin at samsung.com>
diff --git a/mobile/CMakeLists.txt b/mobile/CMakeLists.txt
deleted file mode 100755
index 08a3278..0000000
--- a/mobile/CMakeLists.txt
+++ /dev/null
@@ -1,105 +0,0 @@
-
-CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
-SET(fw_name "capi-media-audio-io")
-
-PROJECT(${fw_name})
-
-SET(CMAKE_INSTALL_PREFIX /usr)
-SET(PREFIX ${CMAKE_INSTALL_PREFIX})
-
-SET(INC_DIR include)
-INCLUDE_DIRECTORIES(${INC_DIR})
-
-SET(dependents "dlog mm-sound capi-base-common capi-media-sound-manager")
-SET(pc_dependents "capi-base-common capi-media-sound-manager")
-
-INCLUDE(FindPkgConfig)
-pkg_check_modules(${fw_name} REQUIRED ${dependents})
-FOREACH(flag ${${fw_name}_CFLAGS})
-    SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
-ENDFOREACH(flag)
-
-SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -Wall -Werror")
-SET(CMAKE_C_FLAGS_DEBUG "-O0 -g")
-
-IF("${ARCH}" STREQUAL "arm")
-    ADD_DEFINITIONS("-DTARGET")
-ENDIF("${ARCH}" STREQUAL "arm")
-
-ADD_DEFINITIONS("-DPREFIX=\"${CMAKE_INSTALL_PREFIX}\"")
-ADD_DEFINITIONS("-DTIZEN_DEBUG")
-
-SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -Wl,--rpath=${LIB_INSTALL_DIR}")
-
-aux_source_directory(src SOURCES)
-ADD_LIBRARY(${fw_name} SHARED ${SOURCES})
-
-SET_TARGET_PROPERTIES(${fw_name}
-     PROPERTIES
-     VERSION ${FULLVER}
-     SOVERSION ${MAJORVER}
-     CLEAN_DIRECT_OUTPUT 1
-)
-
-TARGET_LINK_LIBRARIES(${fw_name} ${${fw_name}_LDFLAGS})
-
-SET_TARGET_PROPERTIES(${fw_name}
-     PROPERTIES
-     VERSION ${FULLVER}
-     SOVERSION ${MAJORVER}
-     CLEAN_DIRECT_OUTPUT 1
-)
-
-INSTALL(TARGETS ${fw_name} DESTINATION ${LIB_INSTALL_DIR})
-INSTALL(
-        DIRECTORY ${INC_DIR}/ DESTINATION include/media
-        FILES_MATCHING
-        PATTERN "*_private.h" EXCLUDE
-        PATTERN "${INC_DIR}/*.h"
-        )
-
-SET(PC_NAME ${fw_name})
-SET(PC_REQUIRED ${pc_dependents})
-SET(PC_LDFLAGS -l${fw_name})
-SET(PC_CFLAGS -I\${includedir}/media)
-
-CONFIGURE_FILE(
-    ${fw_name}.pc.in
-    ${CMAKE_CURRENT_SOURCE_DIR}/${fw_name}.pc
-    @ONLY
-)
-INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${fw_name}.pc DESTINATION ${LIB_INSTALL_DIR}/pkgconfig)
-
-ADD_SUBDIRECTORY(test)
-
-IF(UNIX)
-
-ADD_CUSTOM_TARGET (distclean @echo cleaning for source distribution)
-ADD_CUSTOM_COMMAND(
-        DEPENDS clean 
-        COMMENT "distribution clean"
-        COMMAND find
-        ARGS    . 
-        -not -name config.cmake -and \(
-        -name tester.c -or
-        -name Testing -or
-        -name CMakeFiles -or
-        -name cmake.depends -or
-        -name cmake.check_depends -or
-        -name CMakeCache.txt -or
-        -name cmake.check_cache -or
-        -name *.cmake -or
-        -name Makefile -or
-        -name core -or
-        -name core.* -or
-        -name gmon.out -or
-        -name install_manifest.txt -or
-        -name *.pc -or
-        -name *~ \)
-        | grep -v TC | xargs rm -rf
-        TARGET  distclean
-        VERBATIM
-)
-
-ENDIF(UNIX)
-
diff --git a/mobile/LICENSE.APLv2 b/mobile/LICENSE.APLv2
deleted file mode 100644
index f94008a..0000000
--- a/mobile/LICENSE.APLv2
+++ /dev/null
@@ -1,206 +0,0 @@
-Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-
-
-
diff --git a/mobile/NOTICE b/mobile/NOTICE
deleted file mode 100644
index ccdad52..0000000
--- a/mobile/NOTICE
+++ /dev/null
@@ -1,3 +0,0 @@
-Copyright (c) Samsung Electronics Co., Ltd. All rights reserved.
-Except as noted, this software is licensed under Apache License, Version 2.
-Please, see the LICENSE file for Apache License terms and conditions.
diff --git a/mobile/capi-media-audio-io.pc.in b/mobile/capi-media-audio-io.pc.in
deleted file mode 100644
index 1997d91..0000000
--- a/mobile/capi-media-audio-io.pc.in
+++ /dev/null
@@ -1,15 +0,0 @@
-
-# Package Information for pkg-config
-
-prefix=@PREFIX@
-exec_prefix=/usr
-libdir=@LIB_INSTALL_DIR@
-includedir=/usr/include/media
-
-Name: @PC_NAME@
-Description: @PACKAGE_DESCRIPTION@
-Version: @VERSION@
-Requires: @PC_REQUIRED@ 
-Libs: -L${libdir} @PC_LDFLAGS@
-Cflags: -I${includedir}
-
diff --git a/mobile/include/audio_io.h b/mobile/include/audio_io.h
deleted file mode 100644
index b9e7d6d..0000000
--- a/mobile/include/audio_io.h
+++ /dev/null
@@ -1,523 +0,0 @@
-/*
-* Copyright (c) 2011 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.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License. 
-*/
-
-#ifndef __TIZEN_MEDIA_AUDIO_IO_H__
-#define __TIZEN_MEDIA_AUDIO_IO_H__
-
-#include <tizen.h>
-#include <sound_manager.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-#define AUDIO_IO_ERROR_CLASS          TIZEN_ERROR_MULTIMEDIA_CLASS | 0x40
-
-/**
- * @file audio_io.h
- * @brief This file contains the Audio Input and Output API.
- */
-
-/**
- * @addtogroup CAPI_MEDIA_AUDIO_IN_MODULE
- * @{
-*/
-
-/**
- * @brief Audio input handle type.
- */
-typedef struct audio_in_s *audio_in_h;
-
-/**
- * @}
-*/
-
-/**
- * @addtogroup CAPI_MEDIA_AUDIO_OUT_MODULE
- * @{
- */
- 
-/**
- * @brief Audio output handle type.
- */
-typedef struct audio_out_s *audio_out_h;
-
- /**
- * @}
- */
-
-/**
- * @addtogroup CAPI_MEDIA_AUDIO_IO_MODULE
- * @{
- */
-
-/**
- * @brief Enumerations of audio sample type with bit depth
- */
-typedef enum
-{
-    AUDIO_SAMPLE_TYPE_U8 = 0x70,   /**< Unsigned 8-bit audio samples */
-    AUDIO_SAMPLE_TYPE_S16_LE,   /**< Signed 16-bit audio samples */
-} audio_sample_type_e;
-
-/**
- * @brief Enumerations of audio channel
- */
-typedef enum {
-    AUDIO_CHANNEL_MONO = 0x80,    /**< 1 channel, mono */
-    AUDIO_CHANNEL_STEREO,      /**< 2 channel, stereo */
-} audio_channel_e;
-
-/**
- * @brief Enumerations of audio input and output error code
- */
-typedef enum{
-    AUDIO_IO_ERROR_NONE                = TIZEN_ERROR_NONE,                /**<Successful */
-    AUDIO_IO_ERROR_OUT_OF_MEMORY       = TIZEN_ERROR_OUT_OF_MEMORY,     /**< Out of memory */
-    AUDIO_IO_ERROR_INVALID_PARAMETER   = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
-    AUDIO_IO_ERROR_INVALID_OPERATION   = TIZEN_ERROR_INVALID_OPERATION, /**< Invalid operation */
-    AUDIO_IO_ERROR_DEVICE_NOT_OPENED   = AUDIO_IO_ERROR_CLASS | 0x01, /**< Device open error */
-    AUDIO_IO_ERROR_DEVICE_NOT_CLOSED   = AUDIO_IO_ERROR_CLASS | 0x02, /**< Device close error */
-    AUDIO_IO_ERROR_INVALID_BUFFER      = AUDIO_IO_ERROR_CLASS | 0x03, /**< Invalid buffer pointer */
-    AUDIO_IO_ERROR_SOUND_POLICY        = AUDIO_IO_ERROR_CLASS | 0x04, /**< Sound policy error */
-} audio_io_error_e;
-
-/**
- * @brief Enumerations of audio io interrupted type
- */
-typedef enum
-{
-    AUDIO_IO_INTERRUPTED_COMPLETED = 0, 				/**< Interrupt completed*/
-    AUDIO_IO_INTERRUPTED_BY_MEDIA, 				/**< Interrupted by non-resumable media application*/
-    AUDIO_IO_INTERRUPTED_BY_CALL,						/**< Interrupted by incoming call*/
-    AUDIO_IO_INTERRUPTED_BY_EARJACK_UNPLUG,			/**< Interrupted by unplugging headphone*/
-    AUDIO_IO_INTERRUPTED_BY_RESOURCE_CONFLICT,		/**< Interrupted by resource conflict*/
-    AUDIO_IO_INTERRUPTED_BY_ALARM,					/**< Interrupted by alarm*/
-    AUDIO_IO_INTERRUPTED_BY_EMERGENCY,					/**< Interrupted by emergency*/
-    AUDIO_IO_INTERRUPTED_BY_RESUMABLE_MEDIA, 				/**< Interrupted by resumable media application*/
-} audio_io_interrupted_code_e;
-
-/**
- * @brief  Called when the audio input or output is interrupted.
- * @param[in]	error_code	The interrupted error code
- * @param[in]	user_data	The user data passed from the callback registration function
- * @see audio_in_set_interrupted_cb()
- * @see audio_out_set_interrupted_cb()
- * @see audio_in_unset_interrupted_cb()
- * @see audio_out_unset_interrupted_cb()
- */
-typedef void (*audio_io_interrupted_cb)(audio_io_interrupted_code_e code, void *user_data);
-
-/**
- * @}
-*/
-
-/**
- * @addtogroup CAPI_MEDIA_AUDIO_IN_MODULE
- * @{
-*/
-
-
-//
-//AUDIO INPUT
-//
-
-
-/**
- * @brief    Creates an audio device instance and returns an input handle to record PCM (pulse-code modulation) data
- * @details  This function is used for audio input initialization.
- *
- * @remarks @a input must be release audio_in_destroy() by you.
- *
- * @param[in]  sample_rate	The audio sample rate in 8000[Hz] ~ 48000[Hz]
- * @param[in]  channel	The audio channel type, mono, or stereo
- * @param[in]  type	The type of audio sample (8- or 16-bit)
- * @param[out] input	An audio input handle will be created, if successful
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #AUDIO_IO_ERROR_OUT_OF_MEMORY Out of memory
- * @retval #AUDIO_IO_ERROR_DEVICE_NOT_OPENED Device not opened
- * @retval #AUDIO_IO_ERROR_SOUND_POLICY    Sound policy error
- * @see audio_in_destroy()
- */
-int audio_in_create(int sample_rate, audio_channel_e channel, audio_sample_type_e type , audio_in_h *input);
-
-
-
-/**
- * @brief    Releases the audio input handle and all its resources associated with an audio stream
- *
- * @param[in]	input	The handle to the audio input to destroy
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #AUDIO_IO_ERROR_DEVICE_NOT_CLOSED Device not closed
- * @see audio_in_create()
- */
-int audio_in_destroy(audio_in_h input);
-
-
-
-/**
- * @brief   Prepare reading audio in by starting buffering the audio data from the device
- * @param[in]	input	The handle to the audio input
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @see audio_in_unprepare()
- */
-int audio_in_prepare(audio_in_h input);
-
-
-
-/**
- * @brief    Unprepare reading audio in by stopping buffering the audio data from the device
- * @param[in]	input	The handle to the audio input
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @see audio_in_prepare()
- */
-int audio_in_unprepare(audio_in_h input);
-
-
-
-/**
- * @brief   Reads audio data from the audio input buffer
- *
- * @param[in]	input	The handle to the audio input
- * @param[out]	buffer	The PCM buffer address
- * @param[in]	length	The length of PCM data buffer (in bytes)
- *
- * @return  Number of read bytes on success, otherwise a negative error value.
- * @retval  #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval  #AUDIO_IO_ERROR_INVALID_BUFFER  Invalid buffer pointer
- * @retval  #AUDIO_IO_ERROR_SOUND_POLICY    Sound policy error
- * @retval  #AUDIO_IO_ERROR_INVALID_OPERATION Invalid operation
- * @pre audio_in_start_recording() 
-*/
-int audio_in_read(audio_in_h input, void *buffer, unsigned int length);
-
-
-
-/**
- * @brief    Gets the size to be allocated for audio input buffer
- * @param[in]   input	The handle to the audio input
- * @param[out]  size	The buffer size (in bytes). \n The maximum size is 1 MB.
- *
- * @return  0 on success, otherwise a negative error value.
- * @retval  #AUDIO_IO_ERROR_NONE Successful
- * @retval  #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @see audio_in_read()
-*/
-int audio_in_get_buffer_size(audio_in_h input, int *size);
-
-
-
-/**
- * @brief    Gets the sample rate of the audio input data stream
- *
- * @param[in]   input	The handle to the audio input
- * @param[out]  sample_rate  The audio sample rate in Hertz (8000 ~ 48000)
- *
- * @return  0 on success, otherwise a negative error value.
- * @retval  #AUDIO_IO_ERROR_NONE Successful
- * @retval  #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
-*/
-int audio_in_get_sample_rate(audio_in_h input, int *sample_rate);
-
-
-
-/**
- * @brief    Gets the channel type of audio input data stream
- *
- * @details  The audio channel type defines whether the audio is mono or stereo.
- *
- * @param[in]   input   The handle to the audio input
- * @param[out]  channel The audio channel type
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
-*/
-int audio_in_get_channel(audio_in_h input, audio_channel_e *channel);
-
-
-
-/**
- * @brief    Gets the sample audio format (8-bit or 16-bit) of audio input data stream
- *
- * @param[in]  input    The handle to the audio input
- * @param[out] type     The audio sample type
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
-*/
-int audio_in_get_sample_type(audio_in_h input, audio_sample_type_e *type);
-
-
-/**
- * @brief Registers a callback function to be invoked when the audio input handle is interrupted or interrupt completed.
- * @param[in] input    The handle to the audio input
- * @param[in] callback	The callback function to register
- * @param[in] user_data	The user data to be passed to the callback function
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #AUDIO_IO_ERROR_INVALID_OPERATION Invalid operation
- * @post  audio_io_interrupted_cb() will be invoked
- * @see audio_in_unset_interrupted_cb()
- * @see audio_io_interrupted_cb()
- */
-int audio_in_set_interrupted_cb(audio_in_h input, audio_io_interrupted_cb callback, void *user_data);
-
-/**
- * @brief Unregisters the callback function.
- * @param[in]  input   The handle to the audio input
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #AUDIO_IO_ERROR_INVALID_OPERATION Invalid operation
- * @see audio_in_set_interrupted_cb()
- */
-int audio_in_unset_interrupted_cb(audio_in_h input);
-
-/**
- * @brief Ignore session for input
- * @param[in]  input   The handle to the audio input
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #AUDIO_IO_ERROR_INVALID_OPERATION Invalid operation
- * @see
- */
-int audio_in_ignore_session(audio_in_h input);
-
-//
-//  AUDIO OUTPUT
-//
-
-/**
- * @}
-*/
-
-/**
- * @addtogroup CAPI_MEDIA_AUDIO_OUT_MODULE
- * @{
- */
-
-/**
- * @brief    Creates an audio device instance and returns an output handle to play PCM (pulse-code modulation) data
- * @details  This function is used for audio output initialization. 
- * @remarks @a output must be released audio_out_destroy() by you.
- *
- * @param[in]  sample_rate  The audio sample rate in 8000[Hz] ~ 48000[Hz]
- * @param[in]  channel      The audio channel type, mono, or stereo
- * @param[in]  type         The type of audio sample (8- or 16-bit)
- * @param[in]  sound_type   The type of sound (#sound_type_e)
- * @param[out] output       An audio output handle will be created, if successful
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #AUDIO_IO_ERROR_OUT_OF_MEMORY Out of memory
- * @retval #AUDIO_IO_ERROR_DEVICE_NOT_OPENED Device not opened
- * @retval #AUDIO_IO_ERROR_SOUND_POLICY    Sound policy error
- *
- * @see audio_out_destroy()
-*/
-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);
-
-
-
-/**
- * @brief    Releases the audio output handle, along with all its resources
- *
- * @param[in]	output The handle to the audio output to destroy
- *
- * @return  0 on success, otherwise a negative error value.
- * @retval  #AUDIO_IO_ERROR_NONE Successful
- * @retval  #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval  #AUDIO_IO_ERROR_OUT_OF_MEMORY Out of memory
- * @retval  #AUDIO_IO_ERROR_DEVICE_NOT_CLOSED Device not closed
- *
- * @see audio_out_create()
-*/
-int audio_out_destroy(audio_out_h output);
-
-/**
- * @brief   Prepare playing audio out, this must be called before audio_out_write()
- * @param[in]	output	The handle to the audio output
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @see audio_out_unprepare()
- */
-int audio_out_prepare(audio_out_h output);
-
-
-
-/**
- * @brief    Unprepare playing audio out.
- * @param[in]	output	The handle to the audio output
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @see audio_out_prepare()
- */
-int audio_out_unprepare(audio_out_h output);
-
-
-
-
-/**
- * @brief    Starts writing the audio data to the device
- *
- * @param[in]       output  The handle to the audio output
- * @param[in,out]   buffer  The PCM buffer address
- * @param[in]       length  The length of PCM buffer (in bytes)
- *
- * @return  Written data size on success, otherwise a negative error value.
- * @retval  #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval  #AUDIO_IO_ERROR_INVALID_BUFFER  Invalid buffer pointer
- * @retval  #AUDIO_IO_ERROR_SOUND_POLICY    Sound policy error
-*/
-int audio_out_write(audio_out_h output, void *buffer, unsigned int length);
-
-
-
-/**
- * @brief    Gets the size to be allocated for audio output buffer
- * @param[in]     output  The handle to the audio output
- * @param[out]    size    The suggested buffer size (in bytes). \n The maximum size is 1 MB.
- *
- * @return  0 on success, otherwise a negative error value.
- * @retval  #AUDIO_IO_ERROR_NONE Successful
- * @retval  #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @see audio_out_write()
- *
-*/
-int audio_out_get_buffer_size(audio_out_h output, int *size);
-
-
-
-/**
- * @brief    Gets the sample rate of audio output data stream
- *
- * @param[in]   output       The handle to the audio output
- * @param[out]  sample_rate  The audio sample rate in Hertz (8000 ~ 48000)
- *
- * @return  0 on success, otherwise a negative error value.
- * @retval  #AUDIO_IO_ERROR_NONE Successful
- * @retval  #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
-*/
-int audio_out_get_sample_rate(audio_out_h output, int *sample_rate);
-
-
-
-/**
- * @brief    Gets the channel type of audio output data stream
- *
- * @details  The audio channel type defines whether the audio is mono or stereo.
- *
- * @param[in]   output  The handle to the audio output
- * @param[out]  channel The audio channel type
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
-*/
-int audio_out_get_channel(audio_out_h output, audio_channel_e *channel);
-
-
-
-/**
- * @brief    Gets the sample audio format (8-bit or 16-bit) of audio output data stream
- *
- * @param[in]   output  The handle to the audio output
- * @param[out]  type    The audio sample type
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
-*/
-int audio_out_get_sample_type(audio_out_h output, audio_sample_type_e *type);
-
-
-
-/**
- * @brief    Gets the sound type supported by the audio output device
- * @param[in]  output   The handle to the audio output
- * @param[out] type     The sound type
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
-*/
-int audio_out_get_sound_type(audio_out_h output, sound_type_e *type);
-
-
-/**
- * @brief Registers a callback function to be invoked when the audio out handle is interrupted or interrupt completed.
- * @param[in] output   The handle to the audio output
- * @param[in] callback	The callback function to register
- * @param[in] user_data	The user data to be passed to the callback function
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #AUDIO_IO_ERROR_INVALID_OPERATION Invalid operation
- * @post  audio_io_interrupted_cb() will be invoked
- * @see audio_out_unset_interrupted_cb()
- * @see audio_io_interrupted_cb()
- */
-int audio_out_set_interrupted_cb(audio_out_h output, audio_io_interrupted_cb callback, void *user_data);
-
-/**
- * @brief Unregisters the callback function.
- * @param[in]  output   The handle to the audio output
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #AUDIO_IO_ERROR_INVALID_OPERATION Invalid operation
- * @see audio_out_set_interrupted_cb()
- */
-int audio_out_unset_interrupted_cb(audio_out_h output);
-
-/**
- * @brief Ignore session for output
- * @param[in]  output   The handle to the audio output
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #AUDIO_IO_ERROR_INVALID_OPERATION Invalid operation
- * @see
- */
-int audio_out_ignore_session(audio_out_h output);
-
-
-/**
- * @}
-*/
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __TIZEN_MEDIA_AUDIO_IO_H__ */
diff --git a/mobile/include/audio_io_private.h b/mobile/include/audio_io_private.h
deleted file mode 100644
index d124cea..0000000
--- a/mobile/include/audio_io_private.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
-* Copyright (c) 2011 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.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License. 
-*/
-
-#ifndef __TIZEN_MEDIA_AUDIO_IO_PRIVATE_H__
-#define	__TIZEN_MEDIA_AUDIO_IO_PRIVATE_H__
-#include <audio_io.h>
-#include <sound_manager.h>
-#include <mm_sound.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-typedef struct _audio_in_s{
-	MMSoundPcmHandle_t mm_handle;
-	int _buffer_size;
-	int _sample_rate;
-	audio_channel_e _channel;
-	audio_sample_type_e _type;
-	audio_io_interrupted_cb user_cb;
-	void* user_data;
-} audio_in_s;
-
-typedef struct _audio_out_s{
-	MMSoundPcmHandle_t mm_handle;
-	int _buffer_size;
-	int _sample_rate;
-	audio_channel_e _channel;
-	audio_sample_type_e _type; 	
-	sound_type_e	_sound_type;
-	audio_io_interrupted_cb user_cb;
-	void* user_data;
-} audio_out_s;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif //__TIZEN_MEDIA_AUDIO_IO_PRIVATE_H__
diff --git a/mobile/test/audio_io_test.c b/mobile/test/audio_io_test.c
deleted file mode 100755
index 9aba129..0000000
--- a/mobile/test/audio_io_test.c
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
-* Copyright (c) 2011 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.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License. 
-*/
- 
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <audio_io.h>	
-
-int audio_io_test()
-{
-	int ret, size;
-	audio_in_h input;
-	if ((ret = audio_in_create(44100, AUDIO_CHANNEL_STEREO ,AUDIO_SAMPLE_TYPE_S16_LE, &input)) == AUDIO_IO_ERROR_NONE) {
-		ret = audio_in_ignore_session(input);
-		if (ret != 0) {
-			printf ("ERROR, set session mix\n");
-			audio_in_destroy(input);
-			return 0;
-		}
-
-		audio_in_prepare(input);
-		if ((ret = audio_in_get_buffer_size(input, &size)) == AUDIO_IO_ERROR_NONE) {
-			size = 500000;
-			char *buffer = alloca(size);
-			if ((ret = audio_in_read(input, (void*)buffer, size)) > AUDIO_IO_ERROR_NONE) {
-				FILE* fp = fopen ("/root/test.raw", "wb+");
-				fwrite (buffer, size, sizeof(char), fp);
-				fclose (fp);
-				printf ("PASS, size=%d, ret=%d\n", size, ret);
-			}
-			else {
-				printf ("FAIL, size=%d, ret=%d\n", size, ret);
-			}
-		}
-		audio_in_destroy(input);
-	}
-
-	return 1;
-}
-
-int main(int argc, char ** argv)
-{
-	audio_io_test();
-	return 0;
-}
-
diff --git a/packaging/capi-media-audio-io-0.2.0.tar.gz b/packaging/capi-media-audio-io-0.2.0.tar.gz
deleted file mode 100644
index 02b1c91..0000000
--- a/packaging/capi-media-audio-io-0.2.0.tar.gz
+++ /dev/null
diff --git a/packaging/capi-media-audio-io.spec b/packaging/capi-media-audio-io.spec
index abfb610..7dea3ba 100644
--- a/packaging/capi-media-audio-io.spec
+++ b/packaging/capi-media-audio-io.spec
@@ -1,26 +1,20 @@
+#sbs-git:slp/api/audio-io capi-media-audio-io 0.1.0 da265a7364928d92084360809316e36f666f053f
 Name:       capi-media-audio-io
 Summary:    An Audio Input & Audio Output library in Tizen Native API
-%if 0%{?tizen_profile_mobile}
-Version: 0.2.0
+Version: 0.2.27
 Release:    0
-%else
-Version: 0.2.9
-Release:    0
-%endif
 Group:      TO_BE/FILLED_IN
-License:    Apache-2.0
+License:    TO BE FILLED IN
 Source0:    %{name}-%{version}.tar.gz
 BuildRequires:  cmake
 BuildRequires:  pkgconfig(dlog)
-%if "%{_repository}" == "wearable"
-BuildRequires:  pkgconfig(mm-pcmsound)
-%else
 BuildRequires:  pkgconfig(mm-sound)
-%endif
+BuildRequires:  pkgconfig(glib-2.0)
 BuildRequires:  pkgconfig(capi-media-sound-manager)
 BuildRequires:  pkgconfig(capi-base-common)
 Requires(post): /sbin/ldconfig  
 Requires(postun): /sbin/ldconfig
+Requires(post): libprivilege-control
 
 %description
 An Audio Input & Audio Output library in Tizen Native API
@@ -38,48 +32,27 @@ An Audio Input & Audio Output library in Tizen Native API (DEV)
 
 
 %build
-%if 0%{?tizen_profile_mobile}
-cd mobile
-%else
-cd wearable
-%endif
 MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'`
-%if 0%{?tizen_profile_wearable}
 cmake . -DCMAKE_INSTALL_PREFIX=/usr -DFULLVER=%{version} -DMAJORVER=${MAJORVER}
-%else
-%cmake . -DFULLVER=%{version} -DMAJORVER=${MAJORVER}
-%endif
+
 
 make %{?jobs:-j%jobs}
 
 %install
 rm -rf %{buildroot}
-%if 0%{?tizen_profile_mobile}
-cd mobile
-%else
-cd wearable
-%endif
-mkdir -p %{buildroot}/usr/share/license
-%if 0%{?tizen_profile_wearable}
-cp LICENSE %{buildroot}/usr/share/license/%{name}
-%else
-cp LICENSE.APLv2 %{buildroot}/usr/share/license/%{name}
-%endif
 %make_install
+mkdir -p %{buildroot}/usr/share/privilege-control
 
-%post -p /sbin/ldconfig
+%post
+/sbin/ldconfig
+/usr/bin/api_feature_loader --verbose --dir=/usr/share/privilege-control
 
 %postun -p /sbin/ldconfig
 
 
 %files
 %{_libdir}/libcapi-media-audio-io.so.*
-%{_datadir}/license/%{name}
-%if 0%{?tizen_profile_mobile}
-%manifest mobile/capi-media-audio-io.manifest
-%else
-%manifest wearable/capi-media-audio-io.manifest
-%endif
+%manifest capi-media-audio-io.manifest
 
 %files devel
 %{_includedir}/media/audio_io.h
diff --git a/mobile/src/audio_io.c b/src/audio_io.c
index 76304d9..ebdbdcd 100644
--- a/mobile/src/audio_io.c
+++ b/src/audio_io.c
@@ -18,8 +18,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <mm.h>
-#include <glib.h>
-#include <audio_io_private.h>
+#include "audio_io_private.h"
 #include <dlog.h>
 
 #ifdef LOG_TAG
@@ -27,169 +26,10 @@
 #endif
 #define LOG_TAG "TIZEN_N_AUDIO_IO"
 
-/*
-* Internal Macros
-*/
-#define AUDIO_IO_CHECK_CONDITION(condition,error,msg)	\
-		if(condition) {} else \
-		{ LOGE("[%s] %s(0x%08x)",__FUNCTION__, msg,error); return error;}; \
-
-#define AUDIO_IO_NULL_ARG_CHECK(arg)	\
-	AUDIO_IO_CHECK_CONDITION(arg != NULL, AUDIO_IO_ERROR_INVALID_PARAMETER, "AUDIO_IO_ERROR_INVALID_PARAMETER" )
-
+#include <mm_sound_pcm_async.h>
 /*
 * Internal Implementation
 */
-static int __convert_error_code(int code, char *func_name)
-{
-	int ret = AUDIO_IO_ERROR_NONE;
-	char* msg = "AUDIO_IO_ERROR_NONE";
-
-	switch(code)
-	{
-		case MM_ERROR_NONE:
-			ret = AUDIO_IO_ERROR_NONE;
-			msg = "AUDIO_IO_ERROR_NONE";
-			break;
-		case MM_ERROR_INVALID_ARGUMENT:
-		case MM_ERROR_SOUND_DEVICE_INVALID_SAMPLERATE:
-		case MM_ERROR_SOUND_DEVICE_INVALID_CHANNEL:
-		case MM_ERROR_SOUND_DEVICE_INVALID_FORMAT:
-			ret = AUDIO_IO_ERROR_INVALID_PARAMETER;
-			msg = "AUDIO_IO_ERROR_INVALID_PARAMETER";
-			break;
-		case MM_ERROR_SOUND_DEVICE_NOT_OPENED:
-			ret = AUDIO_IO_ERROR_DEVICE_NOT_OPENED;
-			msg = "AUDIO_IO_ERROR_DEVICE_NOT_OPENED";
-			break;
-		case MM_ERROR_SOUND_INTERNAL:
-			ret = AUDIO_IO_ERROR_DEVICE_NOT_CLOSED;
-			msg = "AUDIO_IO_ERROR_DEVICE_NOT_CLOSED";
-			break;
-		case MM_ERROR_SOUND_INVALID_POINTER:
-			ret = AUDIO_IO_ERROR_INVALID_BUFFER;
-			msg = "AUDIO_IO_ERROR_INVALID_BUFFER";
-			break;		
-		case MM_ERROR_POLICY_BLOCKED:
-		case MM_ERROR_POLICY_INTERRUPTED:
-		case MM_ERROR_POLICY_INTERNAL:
-		case MM_ERROR_POLICY_DUPLICATED:
-			ret = AUDIO_IO_ERROR_SOUND_POLICY;
-			msg = "AUDIO_IO_ERROR_SOUND_POLICY";
-			break;
-	} 
-	LOGE("[%s] %s(0x%08x) : core fw error(0x%x)",func_name,msg, ret, code);
-	return ret;	
-}
-
-static int __check_parameter(int sample_rate, audio_channel_e channel, audio_sample_type_e type)
-{
-	if(sample_rate<8000 || sample_rate > 48000)	{
-		LOGE("[%s] AUDIO_IO_ERROR_INVALID_PARAMETER(0x%08x) :  Invalid sample rate (8000~48000Hz) : %d",__FUNCTION__, AUDIO_IO_ERROR_INVALID_PARAMETER,sample_rate);
-		return AUDIO_IO_ERROR_INVALID_PARAMETER;
-	}
-	if (channel < AUDIO_CHANNEL_MONO || channel > AUDIO_CHANNEL_STEREO) {
-		LOGE("[%s] AUDIO_IO_ERROR_INVALID_PARAMETER(0x%08x) :  Invalid audio channel : %d",__FUNCTION__, AUDIO_IO_ERROR_INVALID_PARAMETER,channel);
-		return AUDIO_IO_ERROR_INVALID_PARAMETER;
-	}
-	if (type < AUDIO_SAMPLE_TYPE_U8 || type > AUDIO_SAMPLE_TYPE_S16_LE) {
-		LOGE("[%s] AUDIO_IO_ERROR_INVALID_PARAMETER(0x%08x) :  Invalid sample typel : %d",__FUNCTION__, AUDIO_IO_ERROR_INVALID_PARAMETER,type);
-		return AUDIO_IO_ERROR_INVALID_PARAMETER;
-	}
-	return AUDIO_IO_ERROR_NONE;
-}
-
-
-static audio_io_interrupted_code_e __translate_interrupted_code (int code)
-{
-	audio_io_interrupted_code_e e = AUDIO_IO_INTERRUPTED_COMPLETED;
-
-	switch(code)
-	{
-	case MM_MSG_CODE_INTERRUPTED_BY_ALARM_END:
-	case MM_MSG_CODE_INTERRUPTED_BY_EMERGENCY_END:
-		e = AUDIO_IO_INTERRUPTED_COMPLETED;
-		break;
-
-	case MM_MSG_CODE_INTERRUPTED_BY_MEDIA:
-	case MM_MSG_CODE_INTERRUPTED_BY_OTHER_PLAYER_APP:
-		e = AUDIO_IO_INTERRUPTED_BY_MEDIA;
-		break;
-
-	case MM_MSG_CODE_INTERRUPTED_BY_CALL_START:
-		e = AUDIO_IO_INTERRUPTED_BY_CALL;
-		break;
-
-	case MM_MSG_CODE_INTERRUPTED_BY_EARJACK_UNPLUG:
-		e = AUDIO_IO_INTERRUPTED_BY_EARJACK_UNPLUG;
-		break;
-
-	case MM_MSG_CODE_INTERRUPTED_BY_RESOURCE_CONFLICT:
-		e = AUDIO_IO_INTERRUPTED_BY_RESOURCE_CONFLICT;
-		break;
-
-	case MM_MSG_CODE_INTERRUPTED_BY_ALARM_START:
-		e = AUDIO_IO_INTERRUPTED_BY_ALARM;
-		break;
-
-	case MM_MSG_CODE_INTERRUPTED_BY_EMERGENCY_START:
-		e = AUDIO_IO_INTERRUPTED_BY_EMERGENCY;
-		break;
-
-	case MM_MSG_CODE_INTERRUPTED_BY_RESUMABLE_MEDIA:
-		e = AUDIO_IO_INTERRUPTED_BY_RESUMABLE_MEDIA;
-		break;
-	}
-
-	return e;
-}
-
-static int __mm_sound_pcm_capture_msg_cb (int message, void *param, void *user_param)
-{
-	audio_io_interrupted_code_e e = AUDIO_IO_INTERRUPTED_COMPLETED;
-	audio_in_s *handle = (audio_in_s *) user_param;
-	MMMessageParamType *msg = (MMMessageParamType*)param;
-
-	LOGI("[%s] Got message type : 0x%x with code : %d" ,__FUNCTION__, message, msg->code);
-
-	if (handle->user_cb == NULL) {
-		LOGI("[%s] No interrupt callback is set. Skip this" ,__FUNCTION__);
-		return 0;
-	}
-
-	if (message == MM_MESSAGE_SOUND_PCM_INTERRUPTED) {
-		e = __translate_interrupted_code (msg->code);
-	} else if (message == MM_MESSAGE_SOUND_PCM_CAPTURE_RESTRICTED) {
-		/* TODO : handling restricted code is needed */
-		/* e = _translate_restricted_code (msg->code); */
-	}
-
-	handle->user_cb (e, handle->user_data);
-
-	return 0;
-}
-
-static int __mm_sound_pcm_playback_msg_cb (int message, void *param, void *user_param)
-{
-	audio_io_interrupted_code_e e = AUDIO_IO_INTERRUPTED_COMPLETED;
-	audio_out_s *handle = (audio_out_s *) user_param;
-	MMMessageParamType *msg = (MMMessageParamType*)param;
-
-	LOGI("[%s] Got message type : 0x%x with code : %d" ,__FUNCTION__, message, msg->code);
-
-	if (handle->user_cb == NULL) {
-		LOGI("[%s] No interrupt callback is set. Skip this" ,__FUNCTION__);
-		return 0;
-	}
-
-	if (message == MM_MESSAGE_SOUND_PCM_INTERRUPTED) {
-		e = __translate_interrupted_code (msg->code);
-	}
-
-	handle->user_cb (e, handle->user_data);
-
-	return 0;
-}
 
 
 /*
@@ -199,55 +39,28 @@ static int __mm_sound_pcm_playback_msg_cb (int message, void *param, void *user_
 /* Audio In */
 int audio_in_create(int sample_rate, audio_channel_e channel, audio_sample_type_e type , audio_in_h* input)
 {
-	int ret = 0;
-	audio_in_s *handle = NULL;
-
-	/* input condition check */
-	AUDIO_IO_NULL_ARG_CHECK(input);
-	if(__check_parameter(sample_rate, channel, type) != AUDIO_IO_ERROR_NONE)
-		return AUDIO_IO_ERROR_INVALID_PARAMETER;
-
-	/* Create Handle */
-	handle = (audio_in_s*)malloc( sizeof(audio_in_s));
-	if (handle != NULL) {
-		memset(handle, 0, sizeof(audio_in_s));
-	} else {
-		LOGE("[%s] ERROR :  AUDIO_IO_ERROR_OUT_OF_MEMORY(0x%08x)" ,__FUNCTION__, AUDIO_IO_ERROR_OUT_OF_MEMORY );
-		return AUDIO_IO_ERROR_OUT_OF_MEMORY;
-	}
-
-	ret = mm_sound_pcm_capture_open( &handle->mm_handle,sample_rate, channel, type);
-	if( ret < 0) {
-		free (handle);
-		return __convert_error_code(ret, (char*)__FUNCTION__);
-	}
-	LOGI("[%s] mm_sound_pcm_capture_open() success",__FUNCTION__);
-
-	/* Fill information */
-	*input = (audio_in_h)handle;
-	handle->_buffer_size= ret;
-	handle->_sample_rate= sample_rate;
-	handle->_channel= channel;
-	handle->_type= type;
-
-	/* Set message interrupt callback */
-	ret = mm_sound_pcm_set_message_callback(handle->mm_handle, __mm_sound_pcm_capture_msg_cb, handle);
-	if( ret < 0) {
-		return __convert_error_code(ret, (char*)__FUNCTION__);
-	}
-	LOGI("[%s] mm_sound_pcm_set_message_callback() success",__FUNCTION__);
+	return audio_in_create_private (sample_rate, channel, type, SUPPORT_SOURCE_TYPE_DEFAULT, input);
+}
 
-	return AUDIO_IO_ERROR_NONE;
+int audio_in_create_loopback(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_LOOPBACK, input);
 }
 
 int audio_in_destroy(audio_in_h input)
 {
 	AUDIO_IO_NULL_ARG_CHECK(input);
 	audio_in_s *handle = (audio_in_s *) input;
+	int ret = MM_ERROR_NONE;
 
-	int ret = mm_sound_pcm_capture_close(handle->mm_handle);
+	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) {
-		return __convert_error_code(ret, (char*)__FUNCTION__);
+		free(handle);
+		return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
 	}
 	free(handle);
 
@@ -259,10 +72,16 @@ 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);
+	}
 
-	int ret = mm_sound_pcm_capture_start(handle->mm_handle);
 	if (ret != MM_ERROR_NONE) {
-		return __convert_error_code(ret, (char*)__FUNCTION__);
+		return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
 	}
 
 	LOGI("[%s] mm_sound_pcm_capture_start() success",__FUNCTION__);
@@ -273,10 +92,15 @@ 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;
 
-	int ret = mm_sound_pcm_capture_stop(handle->mm_handle);
+	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_error_code(ret, (char*)__FUNCTION__);
+		return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
 	}
 
 	LOGI("[%s] mm_sound_pcm_capture_stop() success",__FUNCTION__);
@@ -291,11 +115,14 @@ int audio_in_read(audio_in_h input, void *buffer, unsigned int length )
 	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) {
-		LOGI("[%s] (%d/%d) bytes read" ,__FUNCTION__, ret, length);
+	if (ret > 0)
 		return ret;
-	}
 
 	switch(ret)
 	{
@@ -304,7 +131,7 @@ int audio_in_read(audio_in_h input, void *buffer, unsigned int length )
 			LOGE("[%s] (0x%08x) : Not recording started yet.",(char*)__FUNCTION__, AUDIO_IO_ERROR_INVALID_OPERATION);
 			break;
 		default:
-			result = __convert_error_code(ret, (char*)__FUNCTION__);
+			result = __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
 			break;
 	}
 	return result;
@@ -390,71 +217,113 @@ int audio_in_ignore_session(audio_in_h 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_error_code(ret, (char*)__FUNCTION__);
+		return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
 	}
 
 	LOGI("[%s] mm_sound_pcm_capture_ignore_session() success",__FUNCTION__);
 	return AUDIO_IO_ERROR_NONE;
 }
 
-/* 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_in_set_stream_cb(audio_in_h input, audio_in_stream_cb callback, void* userdata)
+{
+	AUDIO_IO_NULL_ARG_CHECK(input);
+	AUDIO_IO_NULL_ARG_CHECK(callback);
+	return audio_in_set_callback_private(input, callback, userdata);
+}
+
+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);
+}
+
+int audio_in_peek(audio_in_h input, const void **buffer, unsigned int *length)
 {
-	audio_out_s *handle = NULL;
+	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;
+	}
 
-	/* input condition check */
-	AUDIO_IO_NULL_ARG_CHECK(output);
-	if(__check_parameter(sample_rate, channel, type)!=AUDIO_IO_ERROR_NONE)
-		return AUDIO_IO_ERROR_INVALID_PARAMETER;
-	if(sound_type < SOUND_TYPE_SYSTEM || sound_type > SOUND_TYPE_CALL) {
-		LOGE("[%s] ERROR :  AUDIO_IO_ERROR_INVALID_PARAMETER(0x%08x) : Invalid sample sound type : %d" ,__FUNCTION__,AUDIO_IO_ERROR_INVALID_PARAMETER,sound_type );
-		return AUDIO_IO_ERROR_INVALID_PARAMETER;
+	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;
 	}
-	
-	/* Create Handle */
-	handle = (audio_out_s*)malloc( sizeof(audio_out_s));
-	if (handle != NULL) {
-		memset(handle, 0 , sizeof(audio_out_s));
-	} else {
-		LOGE("[%s] ERROR :  AUDIO_IO_ERROR_OUT_OF_MEMORY(0x%08x)" ,__FUNCTION__,AUDIO_IO_ERROR_OUT_OF_MEMORY );
-		return AUDIO_IO_ERROR_OUT_OF_MEMORY;
+	return result;
+}
+
+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;
 	}
-	ret = mm_sound_pcm_play_open(&handle->mm_handle,sample_rate, channel, type, sound_type);
-	if( ret < 0) {
-		free (handle);
-		return __convert_error_code(ret, (char*)__FUNCTION__);
+
+	ret = mm_sound_pcm_capture_drop(handle->mm_handle);
+	if (ret == MM_ERROR_NONE) {
+		return ret;
 	}
-	LOGI("[%s] mm_sound_pcm_play_open() success",__FUNCTION__);
-
-	/* Fill information */
-	*output = (audio_out_h)handle;
-	handle->_buffer_size = ret;
-	handle->_sample_rate = sample_rate;
-	handle->_channel = channel;
-	handle->_type = type;
-	handle->_sound_type = sound_type;
-
-	/* Set message interrupt callback */
-	ret = mm_sound_pcm_set_message_callback(handle->mm_handle, __mm_sound_pcm_playback_msg_cb, handle);
-	if( ret < 0) {
-		return __convert_error_code(ret, (char*)__FUNCTION__);
+
+	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;
 	}
-	LOGI("[%s] mm_sound_pcm_set_message_callback() success",__FUNCTION__);
+	return result;
+}
 
-	return AUDIO_IO_ERROR_NONE;
+
+/* 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)
+{
+	return audio_out_create_private(sample_rate, channel, type, sound_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;
 
-	int ret = mm_sound_pcm_play_close(handle->mm_handle);
+	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) {
-		return __convert_error_code(ret, (char*)__FUNCTION__);
+		free(handle);
+		return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
 	}
 	free(handle);
 
@@ -466,10 +335,16 @@ 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);
+	}
 
-	int ret = mm_sound_pcm_play_start(handle->mm_handle);
 	if (ret != MM_ERROR_NONE) {
-		return __convert_error_code(ret, (char*)__FUNCTION__);
+		return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
 	}
 
 	LOGI("[%s] mm_sound_pcm_play_start() success",__FUNCTION__);
@@ -480,10 +355,16 @@ 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);
+	}
 
-	int ret = mm_sound_pcm_play_stop(handle->mm_handle);
 	if (ret != MM_ERROR_NONE) {
-		return __convert_error_code(ret, (char*)__FUNCTION__);
+		return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
 	}
 
 	LOGI("[%s] mm_sound_pcm_play_stop() success",__FUNCTION__);
@@ -495,12 +376,17 @@ 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;
 
-	int ret = mm_sound_pcm_play_write(handle->mm_handle, (void*) buffer, length);
-	if (ret > 0) {
-		LOGI("[%s] (%d/%d) bytes written" ,__FUNCTION__, ret, length);
-		return ret;
+	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:
@@ -508,13 +394,12 @@ int audio_out_write(audio_out_h output, void* buffer, unsigned int length)
 			LOGE("[%s] (0x%08x) : Not playing started yet.",(char*)__FUNCTION__, AUDIO_IO_ERROR_INVALID_OPERATION);
 			break;
 		default:
-			ret = __convert_error_code(ret, (char*)__FUNCTION__);
+			ret = __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
 			break;
 	}
 	return ret;
 }
 
-
 int audio_out_get_buffer_size(audio_out_h output, int *size)
 {
 	AUDIO_IO_NULL_ARG_CHECK(output);
@@ -527,7 +412,6 @@ int audio_out_get_buffer_size(audio_out_h output, int *size)
 	return AUDIO_IO_ERROR_NONE;
 }
 
-
 int audio_out_get_sample_rate(audio_out_h output, int *sample_rate)
 {
 	AUDIO_IO_NULL_ARG_CHECK(output);
@@ -540,7 +424,6 @@ int audio_out_get_sample_rate(audio_out_h output, int *sample_rate)
 	return AUDIO_IO_ERROR_NONE;
 }
 
-
 int audio_out_get_channel(audio_out_h output, audio_channel_e *channel)
 {
 	AUDIO_IO_NULL_ARG_CHECK(output);
@@ -553,7 +436,6 @@ int audio_out_get_channel(audio_out_h output, audio_channel_e *channel)
 	return AUDIO_IO_ERROR_NONE;
 }
 
-
 int audio_out_get_sample_type(audio_out_h output, audio_sample_type_e *type)
 {
 	AUDIO_IO_NULL_ARG_CHECK(output);
@@ -566,7 +448,6 @@ int audio_out_get_sample_type(audio_out_h output, audio_sample_type_e *type)
 	return AUDIO_IO_ERROR_NONE;
 }
 
-
 int audio_out_get_sound_type(audio_out_h output, sound_type_e *type)
 {
 	AUDIO_IO_NULL_ARG_CHECK(output);
@@ -610,11 +491,29 @@ int audio_out_ignore_session(audio_out_h 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_error_code(ret, (char*)__FUNCTION__);
+		return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
 	}
 	LOGI("[%s] mm_sound_pcm_play_ignore_session() success",__FUNCTION__);
 
 	return AUDIO_IO_ERROR_NONE;
 }
+
+int audio_out_set_stream_cb(audio_out_h output, audio_out_stream_cb callback, void* userdata)
+{
+	AUDIO_IO_NULL_ARG_CHECK(output);
+	AUDIO_IO_NULL_ARG_CHECK(callback);
+	return audio_out_set_callback_private(output, callback, userdata);
+}
+
+int audio_out_unset_stream_cb(audio_out_h output)
+{
+	AUDIO_IO_NULL_ARG_CHECK(output);
+	return audio_out_set_callback_private(output, NULL, NULL);
+}
diff --git a/src/audio_io_private.c b/src/audio_io_private.c
new file mode 100644
index 0000000..73299eb
--- /dev/null
+++ b/src/audio_io_private.c
@@ -0,0 +1,454 @@
+/*
+* Copyright (c) 2011 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.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <mm.h>
+#include "audio_io_private.h"
+#include <dlog.h>
+
+#include <mm_sound_pcm_async.h>
+
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "TIZEN_N_AUDIO_IO"
+/*
+* Internal Implementation
+*/
+int __convert_audio_io_error_code(int code, char *func_name)
+{
+	int ret = AUDIO_IO_ERROR_INVALID_OPERATION;
+	char* msg = "AUDIO_IO_ERROR_INVALID_OPERATION";
+
+	switch(code)
+	{
+		case MM_ERROR_NONE:
+			ret = AUDIO_IO_ERROR_NONE;
+			msg = "AUDIO_IO_ERROR_NONE";
+			break;
+		case MM_ERROR_INVALID_ARGUMENT:
+		case MM_ERROR_SOUND_DEVICE_INVALID_SAMPLERATE:
+		case MM_ERROR_SOUND_DEVICE_INVALID_CHANNEL:
+		case MM_ERROR_SOUND_DEVICE_INVALID_FORMAT:
+			ret = AUDIO_IO_ERROR_INVALID_PARAMETER;
+			msg = "AUDIO_IO_ERROR_INVALID_PARAMETER";
+			break;
+		case MM_ERROR_SOUND_DEVICE_NOT_OPENED:
+			ret = AUDIO_IO_ERROR_DEVICE_NOT_OPENED;
+			msg = "AUDIO_IO_ERROR_DEVICE_NOT_OPENED";
+			break;
+		case MM_ERROR_SOUND_PERMISSION_DENIED:
+			ret = AUDIO_IO_ERROR_PERMISSION_DENIED;
+			msg = "AUDIO_IO_ERROR_PERMISSION_DENIED";
+			break;
+		case MM_ERROR_SOUND_INTERNAL:
+			ret = AUDIO_IO_ERROR_INVALID_OPERATION;
+			msg = "AUDIO_IO_ERROR_INVALID_OPERATION";
+			break;
+		case MM_ERROR_SOUND_INVALID_POINTER:
+			ret = AUDIO_IO_ERROR_INVALID_BUFFER;
+			msg = "AUDIO_IO_ERROR_INVALID_BUFFER";
+			break;
+		case MM_ERROR_POLICY_BLOCKED:
+		case MM_ERROR_POLICY_INTERRUPTED:
+		case MM_ERROR_POLICY_INTERNAL:
+		case MM_ERROR_POLICY_DUPLICATED:
+			ret = AUDIO_IO_ERROR_SOUND_POLICY;
+			msg = "AUDIO_IO_ERROR_SOUND_POLICY";
+			break;
+	} 
+	LOGE("[%s] %s(0x%08x) : core fw error(0x%x)",func_name,msg, ret, code);
+	return ret;
+}
+
+int __check_parameter(int sample_rate, audio_channel_e channel, audio_sample_type_e type)
+{
+	if(sample_rate<8000 || sample_rate > 48000)	{
+		LOGE("[%s] AUDIO_IO_ERROR_INVALID_PARAMETER(0x%08x) :  Invalid sample rate (8000~48000Hz) : %d",__FUNCTION__, AUDIO_IO_ERROR_INVALID_PARAMETER,sample_rate);
+		return AUDIO_IO_ERROR_INVALID_PARAMETER;
+	}
+	if (channel < AUDIO_CHANNEL_MONO || channel > AUDIO_CHANNEL_STEREO) {
+		LOGE("[%s] AUDIO_IO_ERROR_INVALID_PARAMETER(0x%08x) :  Invalid audio channel : %d",__FUNCTION__, AUDIO_IO_ERROR_INVALID_PARAMETER,channel);
+		return AUDIO_IO_ERROR_INVALID_PARAMETER;
+	}
+	if (type < AUDIO_SAMPLE_TYPE_U8 || type > AUDIO_SAMPLE_TYPE_S16_LE) {
+		LOGE("[%s] AUDIO_IO_ERROR_INVALID_PARAMETER(0x%08x) :  Invalid sample typel : %d",__FUNCTION__, AUDIO_IO_ERROR_INVALID_PARAMETER,type);
+		return AUDIO_IO_ERROR_INVALID_PARAMETER;
+	}
+	return AUDIO_IO_ERROR_NONE;
+}
+
+audio_io_interrupted_code_e __translate_interrupted_code (int code)
+{
+	audio_io_interrupted_code_e e = AUDIO_IO_INTERRUPTED_COMPLETED;
+
+	switch(code)
+	{
+	case MM_MSG_CODE_INTERRUPTED_BY_CALL_END:
+	case MM_MSG_CODE_INTERRUPTED_BY_ALARM_END:
+	case MM_MSG_CODE_INTERRUPTED_BY_EMERGENCY_END:
+	case MM_MSG_CODE_INTERRUPTED_BY_NOTIFICATION_END:
+		e = AUDIO_IO_INTERRUPTED_COMPLETED;
+		break;
+
+	case MM_MSG_CODE_INTERRUPTED_BY_MEDIA:
+	case MM_MSG_CODE_INTERRUPTED_BY_OTHER_PLAYER_APP:
+		e = AUDIO_IO_INTERRUPTED_BY_MEDIA;
+		break;
+
+	case MM_MSG_CODE_INTERRUPTED_BY_CALL_START:
+		e = AUDIO_IO_INTERRUPTED_BY_CALL;
+		break;
+
+	case MM_MSG_CODE_INTERRUPTED_BY_EARJACK_UNPLUG:
+		e = AUDIO_IO_INTERRUPTED_BY_EARJACK_UNPLUG;
+		break;
+
+	case MM_MSG_CODE_INTERRUPTED_BY_RESOURCE_CONFLICT:
+		e = AUDIO_IO_INTERRUPTED_BY_RESOURCE_CONFLICT;
+		break;
+
+	case MM_MSG_CODE_INTERRUPTED_BY_ALARM_START:
+		e = AUDIO_IO_INTERRUPTED_BY_ALARM;
+		break;
+
+	case MM_MSG_CODE_INTERRUPTED_BY_NOTIFICATION_START:
+		e = AUDIO_IO_INTERRUPTED_BY_NOTIFICATION;
+		break;
+
+	case MM_MSG_CODE_INTERRUPTED_BY_EMERGENCY_START:
+		e = AUDIO_IO_INTERRUPTED_BY_EMERGENCY;
+		break;
+
+	case MM_MSG_CODE_INTERRUPTED_BY_RESUMABLE_MEDIA:
+		e = AUDIO_IO_INTERRUPTED_BY_RESUMABLE_MEDIA;
+		break;
+
+	case MM_MSG_CODE_INTERRUPTED_BY_RESUMABLE_CANCELED:
+		e = AUDIO_IO_INTERRUPTED_BY_RESUMABLE_CANCELED;
+		break;
+	}
+
+	return e;
+}
+
+int __mm_sound_pcm_capture_msg_cb (int message, void *param, void *user_param)
+{
+	audio_io_interrupted_code_e e = AUDIO_IO_INTERRUPTED_COMPLETED;
+	audio_in_s *handle = (audio_in_s *) user_param;
+	MMMessageParamType *msg = (MMMessageParamType*)param;
+
+	LOGI("[%s] Got message type : 0x%x with code : %d" ,__FUNCTION__, message, msg->code);
+
+	if (handle->user_cb == NULL) {
+		LOGI("[%s] No interrupt callback is set. Skip this" ,__FUNCTION__);
+		return 0;
+	}
+
+	if (message == MM_MESSAGE_SOUND_PCM_INTERRUPTED) {
+		e = __translate_interrupted_code (msg->code);
+	} else if (message == MM_MESSAGE_SOUND_PCM_CAPTURE_RESTRICTED) {
+		/* TODO : handling restricted code is needed */
+		/* e = _translate_restricted_code (msg->code); */
+	}
+
+	handle->user_cb (e, handle->user_data);
+
+	return 0;
+}
+
+static int __mm_sound_pcm_playback_msg_cb (int message, void *param, void *user_param)
+{
+	audio_io_interrupted_code_e e = AUDIO_IO_INTERRUPTED_COMPLETED;
+	audio_out_s *handle = (audio_out_s *) user_param;
+	MMMessageParamType *msg = (MMMessageParamType*)param;
+
+	LOGI("[%s] Got message type : 0x%x with code : %d" ,__FUNCTION__, message, msg->code);
+
+	if (handle->user_cb == NULL) {
+		LOGI("[%s] No interrupt callback is set. Skip this" ,__FUNCTION__);
+		return 0;
+	}
+
+	if (message == MM_MESSAGE_SOUND_PCM_INTERRUPTED) {
+		e = __translate_interrupted_code (msg->code);
+	}
+
+	handle->user_cb (e, handle->user_data);
+
+	return 0;
+}
+
+static int __audio_in_stream_cb (void* p, int nbytes, void* userdata)
+{
+	audio_in_s *handle = (audio_in_s *) userdata;
+
+	LOGI("<< p=%p, nbytes=%d, userdata=%p", p, nbytes, userdata);
+
+	if (handle && handle->stream_cb) {
+		handle->stream_cb ((audio_in_h)handle, nbytes, handle->stream_userdata);
+		LOGI("<< handle->stream_cb(handle:%p, nbytes:%d, handle->stream_userdata:%p)", p, nbytes, userdata);
+	} else {
+		LOGI("No stream callback is set. Skip this");
+	}
+	return 0;
+}
+
+static int __audio_out_stream_cb (void* p, int nbytes, void* userdata)
+{
+	audio_out_s *handle = (audio_out_s *) userdata;
+	bool is_started = false;
+	char * dummy = NULL;
+
+	LOGI(">> p=%p, nbytes=%d, userdata=%p", p, nbytes, userdata);
+
+	if (handle) {
+		mm_sound_pcm_is_started_async(handle->mm_handle, &is_started);
+		if (is_started) {
+			if (handle->stream_cb) {
+				handle->stream_cb ((audio_out_h)handle, nbytes, handle->stream_userdata);
+			} else {
+				LOGI("Started state but No stream callback is set. Skip this");
+			}
+		} else {
+			LOGI("Not started....write dummy data");
+			dummy = (char*)malloc (nbytes);
+			memset (dummy, 0, nbytes);
+			mm_sound_pcm_play_write_async(handle->mm_handle, (void*) dummy, nbytes);
+			free (dummy);
+			LOGI("write done!!!");
+		}
+	} else {
+		LOGE("Handle is invalid...");
+	}
+
+	return 0;
+}
+
+int audio_in_create_private(int sample_rate, audio_channel_e channel, audio_sample_type_e type , int source_type, audio_in_h* input)
+{
+	int ret = 0;
+	audio_in_s *handle = NULL;
+
+	/* input condition check */
+	AUDIO_IO_NULL_ARG_CHECK(input);
+	if(__check_parameter(sample_rate, channel, type) != AUDIO_IO_ERROR_NONE)
+		return AUDIO_IO_ERROR_INVALID_PARAMETER;
+
+	/* Create Handle & Fill information */
+	if ((handle = (audio_in_s*)malloc( sizeof(audio_in_s))) == NULL) {
+		LOGE("ERROR :  AUDIO_IO_ERROR_OUT_OF_MEMORY(0x%08x)", AUDIO_IO_ERROR_OUT_OF_MEMORY);
+		return AUDIO_IO_ERROR_OUT_OF_MEMORY;
+	}
+	memset(handle, 0, sizeof(audio_in_s));
+
+
+	/* Capture open */
+	if ((ret = mm_sound_pcm_capture_open_ex(&handle->mm_handle, sample_rate, channel, type, source_type)) < 0) {
+		LOGE("mm_sound_pcm_capture_open_ex() failed [0x%x]", ret);
+		goto ERROR;
+	}
+	LOGI("mm_sound_pcm_capture_open_ex() success");
+
+
+	if (source_type == SUPPORT_SOURCE_TYPE_LOOPBACK)
+	{
+	    handle->is_loopback = 1;
+	}
+
+	handle->_buffer_size = ret; /* return by pcm_open */
+	handle->_sample_rate = sample_rate;
+	handle->_channel     = channel;
+	handle->_type        = type;
+
+	/* Set message interrupt callback */
+	if ((ret = mm_sound_pcm_set_message_callback(handle->mm_handle, __mm_sound_pcm_capture_msg_cb, handle)) < 0) {
+		LOGE("mm_sound_pcm_set_message_callback() failed [0x%x]", ret);
+		goto ERROR;
+	}
+	LOGI("mm_sound_pcm_set_message_callback() success");
+
+	/* Handle assign */
+	*input = (audio_in_h)handle;
+
+	return AUDIO_IO_ERROR_NONE;
+
+ERROR:
+	if (handle)
+		free (handle);
+	return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
+}
+
+int audio_in_set_callback_private(audio_in_h input, audio_in_stream_cb callback, void* userdata)
+{
+	AUDIO_IO_NULL_ARG_CHECK(input);
+
+	int         ret         = AUDIO_IO_ERROR_NONE;
+	int         source_type = SUPPORT_SOURCE_TYPE_DEFAULT;
+	audio_in_s* handle      = (audio_in_s*)input;
+
+	// at first, release existing audio handle
+	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) {
+		return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
+	}
+
+	// Initialize flags
+	handle->stream_cb       = NULL;
+	handle->stream_userdata = NULL;
+	handle->is_async        = 0;
+
+	// Checks loopback type
+	if (handle->is_loopback == 1) {
+		source_type = SUPPORT_SOURCE_TYPE_LOOPBACK;
+	}
+
+	/* Async (callback exists) or Sync (otherwise) */
+	if (callback != NULL) {
+		handle->stream_cb       = callback;
+		handle->stream_userdata = userdata;
+		handle->is_async        = 1;
+
+		/* Capture open */
+		if ((ret = mm_sound_pcm_capture_open_async(&handle->mm_handle, handle->_sample_rate, handle->_channel, handle->_type, source_type,
+				(mm_sound_pcm_stream_cb_t)__audio_in_stream_cb, handle)) < 0) {
+			LOGE("mm_sound_pcm_capture_open_async() failed [0x%x]", ret);
+			return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
+		}
+		LOGI("mm_sound_pcm_capture_open_async() success");
+	} else {
+		/* Capture open */
+		if ((ret = mm_sound_pcm_capture_open_ex(&handle->mm_handle, handle->_sample_rate, handle->_channel, handle->_type, source_type)) < 0) {
+			LOGE("mm_sound_pcm_capture_open_ex() failed [0x%x]", ret);
+			return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
+		}
+		LOGI("mm_sound_pcm_capture_open_ex() success");
+	}
+
+	handle->_buffer_size = ret; /* return by pcm_open */
+
+	return AUDIO_IO_ERROR_NONE;
+}
+
+int audio_out_create_private(int sample_rate, audio_channel_e channel, audio_sample_type_e type, sound_type_e sound_type, audio_out_h* output)
+{
+	audio_out_s *handle = NULL;
+	int ret = 0;
+
+	/* input condition check */
+	AUDIO_IO_NULL_ARG_CHECK(output);
+	if(__check_parameter(sample_rate, channel, type)!=AUDIO_IO_ERROR_NONE)
+		return AUDIO_IO_ERROR_INVALID_PARAMETER;
+	if(sound_type < SOUND_TYPE_SYSTEM || sound_type > SOUND_TYPE_VOICE) {
+		LOGE("ERROR :  AUDIO_IO_ERROR_INVALID_PARAMETER(0x%08x) : Invalid sample sound type : %d",
+				AUDIO_IO_ERROR_INVALID_PARAMETER,sound_type );
+		return AUDIO_IO_ERROR_INVALID_PARAMETER;
+	}
+
+	/* Create Handle & Fill information */
+	if ((handle = (audio_out_s*)malloc( sizeof(audio_out_s))) == NULL) {
+		LOGE("ERROR :  AUDIO_IO_ERROR_OUT_OF_MEMORY(0x%08x)", AUDIO_IO_ERROR_OUT_OF_MEMORY);
+		return AUDIO_IO_ERROR_OUT_OF_MEMORY;
+	}
+	memset(handle, 0 , sizeof(audio_out_s));
+
+
+	if ((ret = mm_sound_pcm_play_open(&handle->mm_handle,sample_rate, channel, type, sound_type)) < 0) {
+		LOGE("mm_sound_pcm_play_open() failed [0x%x]", ret);
+		goto ERROR;
+	}
+	LOGI("mm_sound_pcm_play_open() success");
+
+
+	handle->_buffer_size = ret; /* return by pcm_open */
+	handle->_sample_rate = sample_rate;
+	handle->_channel     = channel;
+	handle->_type        = type;
+	handle->_sound_type  = sound_type;
+
+	/* Set message interrupt callback */
+	if ((ret = mm_sound_pcm_set_message_callback(handle->mm_handle, __mm_sound_pcm_playback_msg_cb, handle)) < 0) {
+		LOGE("mm_sound_pcm_set_message_callback() failed [0x%x]", ret);
+		goto ERROR;
+	}
+	LOGI("mm_sound_pcm_set_message_callback() success");
+
+	/* Handle assign */
+	*output = (audio_out_h)handle;
+
+	return AUDIO_IO_ERROR_NONE;
+
+ERROR:
+	if (handle)
+		free (handle);
+	return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
+}
+
+int audio_out_set_callback_private(audio_out_h output, audio_out_stream_cb callback, void* userdata)
+{
+	AUDIO_IO_NULL_ARG_CHECK(output);
+
+	int          ret    = AUDIO_IO_ERROR_NONE;
+	audio_out_s* handle = (audio_out_s*)output;
+
+	// at first, release existing mm handle
+	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) {
+		return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
+	}
+
+	// Initialize flags
+	handle->stream_cb       = NULL;
+	handle->stream_userdata = NULL;
+	handle->is_async        = 0;
+
+	/* Async (callback exists) or Sync (otherwise) */
+	if (callback != NULL) {
+		handle->stream_cb       = callback;
+		handle->stream_userdata = userdata;
+		handle->is_async        = 1;
+
+		/* Playback open */
+		if ((ret = mm_sound_pcm_play_open_async(&handle->mm_handle, handle->_sample_rate, handle->_channel, handle->_type, handle->_sound_type,
+				(mm_sound_pcm_stream_cb_t)__audio_out_stream_cb, handle)) < 0) {
+			LOGE("mm_sound_pcm_play_open_async() failed [0x%x]", ret);
+			return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
+		}
+		LOGI("mm_sound_pcm_play_open_async() success");
+	} else {
+		if ((ret = mm_sound_pcm_play_open(&handle->mm_handle, handle->_sample_rate, handle->_channel, handle->_type, handle->_sound_type)) < 0) {
+			LOGE("mm_sound_pcm_play_open() failed [0x%x]", ret);
+			return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
+		}
+		LOGI("mm_sound_pcm_play_open() success");
+	}
+	handle->_buffer_size = ret; /* return by pcm_open */
+
+	return AUDIO_IO_ERROR_NONE;
+}
diff --git a/mobile/test/CMakeLists.txt b/test/CMakeLists.txt
index 795370d..795370d 100644
--- a/mobile/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
diff --git a/test/audio_io_test.c b/test/audio_io_test.c
new file mode 100644
index 0000000..37468d9
--- /dev/null
+++ b/test/audio_io_test.c
@@ -0,0 +1,446 @@
+/*
+* Copyright (c) 2011 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.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License. 
+*/
+ 
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <audio_io.h>
+
+static int ch_table[3] = { 0, AUDIO_CHANNEL_MONO, AUDIO_CHANNEL_STEREO };
+
+void play_file(char *file, int length, int ch)
+{
+	audio_out_h output;
+	FILE* fp = fopen (file, "r");
+
+	char * buf = malloc (length);
+
+	printf ("start to play [%s][%d][%d]\n", file, length, ch);
+	audio_out_create(44100, ch_table[ch] ,AUDIO_SAMPLE_TYPE_S16_LE, SOUND_TYPE_MEDIA, &output);
+	if (fread (buf, 1, length, fp) != length) {
+		printf ("error!!!!\n");
+	}
+
+	audio_out_prepare(output);
+	audio_out_write(output, buf, length);
+	audio_out_unprepare(output);
+
+	audio_out_destroy (output);
+
+	fclose (fp);
+
+	printf ("play done\n");
+}
+
+#define DUMP_FILE "/root/test.raw"
+
+
+void play_file_sample(char *file, int frequency, int ch, int type)
+{
+	audio_out_h output;
+	int file_size = 0;
+	int read_bytes = 0;
+	int buffer_size = 0;
+	char * buf = NULL;
+	FILE* fp = fopen (file, "r");
+	/*Get the size*/
+	fseek(fp, 0, SEEK_END);
+	file_size = ftell(fp);
+	fseek(fp, 0, SEEK_SET);
+
+	printf ("start to play [%s] of size [%d] with [%d][%d][%d]\n", file, file_size, frequency, ch, type);
+	if (type) {
+		audio_out_create(frequency, ch_table[ch] ,AUDIO_SAMPLE_TYPE_S16_LE, SOUND_TYPE_MEDIA, &output);
+	}
+	else {
+		audio_out_create(frequency, ch_table[ch] ,AUDIO_SAMPLE_TYPE_U8, SOUND_TYPE_MEDIA, &output);
+	}
+	audio_out_get_buffer_size(output, &buffer_size);
+
+	buf = (char *) malloc(buffer_size);
+	audio_out_prepare(output);
+
+	while (file_size > 0) {
+		read_bytes = fread (buf, 1, buffer_size, fp);
+		printf ("Read %d Requested - %d\n", read_bytes, buffer_size);
+		audio_out_write(output, buf, read_bytes);
+		file_size = file_size - read_bytes;
+	}
+
+	audio_out_unprepare(output);
+	audio_out_destroy (output);
+
+	free(buf);
+	fclose (fp);
+	printf ("play done\n");
+}
+
+int audio_io_test(int length, int num, int ch)
+{
+	int ret, size, i;
+	audio_in_h input;
+	if ((ret = audio_in_create(44100, ch_table[ch] ,AUDIO_SAMPLE_TYPE_S16_LE, &input)) == AUDIO_IO_ERROR_NONE) {
+		ret = audio_in_ignore_session(input);
+		if (ret != 0) {
+			printf ("ERROR, set session mix\n");
+			audio_in_destroy(input);
+			return 0;
+		}
+
+		ret = audio_in_prepare(input);
+		if (ret != 0) {
+			printf ("ERROR, prepare\n");
+			audio_in_destroy(input);
+			return 0;
+		}
+
+		FILE* fp = fopen (DUMP_FILE, "wb+");
+
+		if ((ret = audio_in_get_buffer_size(input, &size)) == AUDIO_IO_ERROR_NONE) {
+			size = length;
+			char *buffer = alloca(size);
+
+			for (i=0; i<num; i++) {
+				printf ("### loop = %d ============== \n", i);
+				if ((ret = audio_in_read(input, (void*)buffer, size)) > AUDIO_IO_ERROR_NONE) {
+					fwrite (buffer, size, sizeof(char), fp);
+					printf ("PASS, size=%d, ret=%d\n", size, ret);
+				}
+				else {
+					printf ("FAIL, size=%d, ret=%d\n", size, ret);
+				}
+			}
+		}
+
+		fclose (fp);
+
+		audio_in_destroy(input);
+	}
+
+	play_file (DUMP_FILE, length*num, ch);
+
+	return 1;
+}
+
+
+int audio_io_loopback_in_test()
+{
+    int ret, size;
+    audio_in_h input;
+    FILE* fp = fopen ("/tmp/dump_test.raw", "wb+");
+
+    if(fp == NULL) {
+        printf("open failed \n");
+        return 0;
+    }
+
+    if ((ret = audio_in_create(16000, AUDIO_CHANNEL_MONO , AUDIO_SAMPLE_TYPE_S16_LE, &input)) == AUDIO_IO_ERROR_NONE) {
+        ret = audio_in_ignore_session(input);
+        if (ret != 0) {
+            printf ("ERROR, set session mix\n");
+            goto exit;
+        }
+
+        ret = audio_in_prepare(input);
+        if (ret != 0) {
+            printf ("ERROR, prepare\n");
+            goto exit;
+        }
+
+        ret = audio_in_get_buffer_size(input, &size);
+        if(ret != AUDIO_IO_ERROR_NONE) {
+            printf ("audio_in_get_buffer_size failed.\n");
+            goto exit;
+        }
+
+        while(1) {
+            char *buffer = alloca(size);
+            if ((ret = audio_in_read(input, (void*)buffer, size)) > AUDIO_IO_ERROR_NONE) {
+                fwrite (buffer, size, sizeof(char), fp);
+                printf ("PASS, size=%d, ret=%d\n", size, ret);
+            }
+            else {
+                printf ("FAIL, size=%d, ret=%d\n", size, ret);
+            }
+        }
+    }
+
+exit:
+    audio_in_destroy(input);
+
+    fclose (fp);
+
+    return ret;
+
+}
+
+int audio_io_loopback_test()
+{
+    int ret, size;
+    audio_in_h input;
+    audio_out_h output;
+    char *buffer = NULL;
+
+    ret = audio_in_create(16000, AUDIO_CHANNEL_MONO , AUDIO_SAMPLE_TYPE_S16_LE, &input);
+    if(ret != AUDIO_IO_ERROR_NONE) {
+        printf ("audio_in_create_ex failed. \n");
+        return 0;
+    }
+
+    ret = audio_out_create(16000, AUDIO_CHANNEL_MONO , AUDIO_SAMPLE_TYPE_S16_LE, SOUND_TYPE_CALL, &output);
+    if(ret != AUDIO_IO_ERROR_NONE) {
+        printf ("audio_out_create failed. \n");
+        return 0;
+    }
+
+    ret = audio_in_prepare(input);
+    if (ret != 0) {
+        printf ("audio_in_prepare failed.\n");
+        audio_in_destroy(input);
+        return 0;
+    } else {
+        ret = audio_in_get_buffer_size(input, &size);
+        if(ret != AUDIO_IO_ERROR_NONE) {
+            printf ("audio_in_get_buffer_size failed.\n");
+            return 0;
+        }
+        else {
+            printf("size(%d)\n", size);
+            buffer = alloca(size);
+        }
+    }
+
+    ret = audio_out_prepare(output);
+    if (ret != 0) {
+        printf ("audio_out_prepare failed.\n");
+        audio_out_destroy(output);
+        return 0;
+    }
+
+    if(buffer == NULL) {
+        printf("buffer is null\n");
+        return 0;
+    }
+
+    while(1) {
+        ret = audio_in_read(input, (void*)buffer, size);
+        if(ret > AUDIO_IO_ERROR_NONE) {
+            ret = audio_out_write(output, buffer, size);
+            if(ret > AUDIO_IO_ERROR_NONE) {
+                printf("audio read/write success. buffer(%p), size(%d)\n", buffer, size);
+            } else {
+                printf("audio read success, write failed. buffer(%p), size(%d)\n", buffer, size);
+            }
+        } else
+            printf("audio read/write failed. buffer(%p), size(%d)\n", buffer, size);
+    }
+
+}
+
+audio_in_h input;
+audio_out_h output;
+
+FILE* fp_r = NULL;
+FILE* fp_w = NULL;
+
+static void _audio_io_stream_read_cb (audio_in_h handle, size_t nbytes, void *userdata)
+{
+	const void * buffer = NULL;
+
+//	printf("_audio_io_stream_read_cb : handle=%p, nbytes=%d, userdata=%p\n", handle, nbytes, userdata);
+
+	if (nbytes > 0) {
+		audio_in_peek (handle, &buffer, &nbytes);
+		if (fp_w) {
+			fwrite(buffer, sizeof(char), nbytes, fp_w);
+		}
+		audio_in_drop (handle);
+	}
+}
+
+static void _audio_io_stream_write_cb (audio_out_h handle, size_t nbytes, void *userdata)
+{
+	char* buffer = NULL;
+	int ret = 0;
+
+//	printf("_audio_io_stream_write_cb : handle=%p, nbytes=%d, userdata=%p\n", handle, nbytes, userdata);
+
+	if (nbytes > 0) {
+		buffer = malloc (nbytes);
+		memset (buffer, 0, nbytes);
+
+		ret = fread (buffer, 1, nbytes, fp_r);
+		if (ret != nbytes) {
+			printf ("Error!!!! %d/%d", ret, nbytes);
+		}
+
+		ret = audio_out_write(handle, buffer, nbytes);
+		if(ret > AUDIO_IO_ERROR_NONE) {
+//			printf("audio write success. buffer(%p), nbytes(%d)\n", buffer, nbytes);
+		}
+
+		free (buffer);
+	}
+}
+
+int audio_io_async_test(int mode)
+{
+	int ret, size;
+
+	char *buffer = NULL;
+	int i=0;
+
+	int read_mode = (mode & 0x02);
+	int write_mode = (mode & 0x01);
+
+	if (read_mode) {
+		printf ("audio_in_create\n");
+		ret = audio_in_create(44100, AUDIO_CHANNEL_STEREO , AUDIO_SAMPLE_TYPE_S16_LE, &input);
+		if(ret != AUDIO_IO_ERROR_NONE) {
+			printf ("audio_in_create_ex failed. \n");
+			return 0;
+		}
+		printf ("audio_in_create success!!! [%p]\n", input);
+
+		ret = audio_in_set_stream_cb(input, _audio_io_stream_read_cb, NULL);
+		if(ret != AUDIO_IO_ERROR_NONE) {
+			printf ("audio_in_set_stream_cb failed. \n");
+			return 0;
+		}
+		printf ("audio_in_set_stream_cb success!!! [%p]\n", input);
+
+		fp_w = fopen( "/tmp/pcm_w.raw", "w");
+	}
+
+	if (write_mode) {
+		printf ("before audio_out_create\n");
+		getchar();
+		printf ("audio_out_create\n");
+		ret = audio_out_create(44100, AUDIO_CHANNEL_STEREO , AUDIO_SAMPLE_TYPE_S16_LE, SOUND_TYPE_MEDIA, &output);
+		if(ret != AUDIO_IO_ERROR_NONE) {
+			printf ("audio_out_create failed. \n");
+			return 0;
+		}
+		printf ("audio_out_create success!!! [%p]\n", output);
+
+		ret = audio_out_set_stream_cb(output, _audio_io_stream_write_cb, NULL);
+		if(ret != AUDIO_IO_ERROR_NONE) {
+			printf ("audio_out_set_stream_cb failed. \n");
+			return 0;
+		}
+		printf ("audio_out_set_stream_cb success!!! [%p]\n", input);
+
+		fp_r = fopen( "/tmp/pcm.raw", "r");
+	}
+
+	if (read_mode) {
+		printf ("before audio_in_prepare\n");
+		getchar();
+		printf ("audio_in_prepare\n");
+		ret = audio_in_prepare(input);
+		if (ret != 0) {
+			printf ("audio_in_prepare failed.\n");
+			audio_in_destroy(input);
+			return 0;
+		} else {
+			ret = audio_in_get_buffer_size(input, &size);
+			if(ret != AUDIO_IO_ERROR_NONE) {
+				printf ("audio_in_get_buffer_size failed.\n");
+				return 0;
+			}
+			else {
+				printf("size(%d)\n", size);
+				buffer = alloca(size);
+			}
+		}
+
+		if(buffer == NULL) {
+			printf("buffer is null\n");
+			return 0;
+		}
+	}
+
+	if (write_mode) {
+		printf ("before audio_out_prepare\n");
+		getchar();
+		printf ("audio_out_prepare\n");
+		ret = audio_out_prepare(output);
+		if (ret != 0) {
+			printf ("audio_out_prepare failed.\n");
+			audio_out_destroy(output);
+			return 0;
+		}
+	}
+
+	//getchar();
+
+	printf ("loop start\n");
+	for (i=0; i<10; i++) {
+		printf ("-------- %d -------\n",i);
+		usleep (1000000);
+	}
+
+	//getchar();
+
+	if (read_mode) {
+		printf ("audio_in_unprepare\n");
+		audio_in_unprepare(input);
+		printf ("audio_in_destroy\n");
+		audio_in_destroy(input);
+
+		fclose(fp_w);
+		fp_w = NULL;
+	}
+
+	getchar();
+
+	if (write_mode) {
+		printf ("audio_out_unprepare\n");
+		audio_out_unprepare(output);
+		printf ("audio_out_destroy\n");
+		audio_out_destroy(output);
+
+		fclose(fp_r);
+		fp_r = NULL;
+	}
+
+	return 0;
+}
+
+int main(int argc, char ** argv)
+{
+	if ( argc == 2 && !strcmp(argv[1],"call-forwarding-loop")) {
+		audio_io_loopback_test();
+	} else if ( argc == 2 && !strcmp(argv[1],"call-forwarding-in")) {
+		audio_io_loopback_in_test();
+	} else if ( argc == 3 && !strcmp(argv[1],"async")) {
+		audio_io_async_test(atoi(argv[2]));
+	} else if (argc == 4) {
+		printf ("run with [%s][%s][%s]\n", argv[1],argv[2],argv[3]);
+#if 0
+		audio_io_test(atoi (argv[1]), atoi (argv[2]), atoi(argv[3]));
+#endif
+	} else if (argc == 6) {
+		play_file_sample(argv[2], atoi(argv[3]), atoi(argv[4]), atoi(argv[5]));
+	} else {
+		printf ("1. usage : audio_io_test [length to read] [number of iteration] [channels]\n");
+		printf ("2. usage : audio_io_test mirroring\n");
+		printf ("3. Uasge : audio_io_test play <filename> <sample rate> <channels> <type(0:U8)>");
+	}
+	return 0;
+}
+
diff --git a/wearable/TC/_export_env.sh b/wearable/TC/_export_env.sh
deleted file mode 100755
index 72a11ec..0000000
--- a/wearable/TC/_export_env.sh
+++ /dev/null
@@ -1,8 +0,0 @@
-#!/bin/sh
-
-. ./config
-export TET_INSTALL_PATH=$TET_INSTALL_HOST_PATH # tetware root path
-export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target # tetware target path
-export PATH=$TET_TARGET_PATH/bin:$PATH
-export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH
-export TET_ROOT=$TET_TARGET_PATH
diff --git a/wearable/TC/_export_target_env.sh b/wearable/TC/_export_target_env.sh
deleted file mode 100755
index 5ddaa53..0000000
--- a/wearable/TC/_export_target_env.sh
+++ /dev/null
@@ -1,7 +0,0 @@
-#!/bin/sh
-. ./config
-export TET_INSTALL_PATH=$TET_INSTALL_TARGET_PATH # path to path
-export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target
-export PATH=$TET_TARGET_PATH/bin:$PATH
-export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH
-export TET_ROOT=$TET_TARGET_PATH
diff --git a/wearable/TC/build.sh b/wearable/TC/build.sh
deleted file mode 100755
index 72aad6c..0000000
--- a/wearable/TC/build.sh
+++ /dev/null
@@ -1,16 +0,0 @@
-#!/bin/sh
-
-. ./_export_env.sh                              # setting environment variables
-
-export TET_SUITE_ROOT=`pwd`
-FILE_NAME_EXTENSION=`date +%s`
-
-RESULT_DIR=results
-HTML_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.html
-JOURNAL_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.journal
-
-mkdir -p $RESULT_DIR
-
-tcc -c -p ./
-tcc -b -j $JOURNAL_RESULT -p ./
-grw -c 7 -f chtml -o $HTML_RESULT $JOURNAL_RESULT
diff --git a/wearable/TC/clean.sh b/wearable/TC/clean.sh
deleted file mode 100755
index 29743e0..0000000
--- a/wearable/TC/clean.sh
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/bin/sh
-
-. ./_export_env.sh                              # setting environment variables
-
-export TET_SUITE_ROOT=`pwd`
-RESULT_DIR=results
-
-tcc -c -p ./                                # executing tcc, with clean option (-c)
-rm -r $RESULT_DIR
-rm -r tet_tmp_dir
-rm testcase/tet_captured
diff --git a/wearable/TC/config b/wearable/TC/config
deleted file mode 100755
index 04684f0..0000000
--- a/wearable/TC/config
+++ /dev/null
@@ -1,2 +0,0 @@
-TET_INSTALL_HOST_PATH=/home/rookiejava/dts_tool/TETware
-TET_INSTALL_TARGET_PATH=/mnt/nfs/dts_tool/TETware
diff --git a/wearable/TC/execute.sh b/wearable/TC/execute.sh
deleted file mode 100755
index a4f6095..0000000
--- a/wearable/TC/execute.sh
+++ /dev/null
@@ -1,15 +0,0 @@
-#!/bin/sh
-
-. ./_export_target_env.sh                    # setting environment variables
-
-export TET_SUITE_ROOT=`pwd`
-FILE_NAME_EXTENSION=`date +%s`
-
-RESULT_DIR=results
-HTML_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.html
-JOURNAL_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.journal
-
-mkdir -p $RESULT_DIR
-
-tcc -e -j $JOURNAL_RESULT -p ./
-grw -c 3 -f chtml -o $HTML_RESULT $JOURNAL_RESULT
diff --git a/wearable/TC/media_samsung.mp3 b/wearable/TC/media_samsung.mp3
deleted file mode 100644
index d871c5d..0000000
--- a/wearable/TC/media_samsung.mp3
+++ /dev/null
diff --git a/wearable/TC/push.sh b/wearable/TC/push.sh
deleted file mode 100755
index 5eb9510..0000000
--- a/wearable/TC/push.sh
+++ /dev/null
@@ -1,13 +0,0 @@
-#!/bin/sh
-
-. ./config
-
-TC_PATH=/opt/home/$PKG_NAME
-
-echo $TC_PATH
-
-sdb shell "mkdir -p $TC_PATH"
-
-sdb push . $TC_PATH
-
-
diff --git a/wearable/TC/run.sh b/wearable/TC/run.sh
deleted file mode 100755
index cec5778..0000000
--- a/wearable/TC/run.sh
+++ /dev/null
@@ -1,15 +0,0 @@
-#!/bin/sh
-
-source ./_export_target_env.sh
-
-export TET_SUITE_ROOT=`pwd`
-FILE_NAME_EXTENSION=`date +%s`
-
-RESULT_DIR=results
-HTML_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.html
-JOURNAL_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.journal
-
-mkdir -p $RESULT_DIR
-
-tcc -e -j $JOURNAL_RESULT -p ./
-grw -c 7 -f chtml -o $HTML_RESULT $JOURNAL_RESULT
diff --git a/wearable/TC/testcase/tslist b/wearable/TC/testcase/tslist
deleted file mode 100644
index c4f5399..0000000
--- a/wearable/TC/testcase/tslist
+++ /dev/null
@@ -1,2 +0,0 @@
-/testcase/utc_media_audio_input
-/testcase/utc_media_audio_output
diff --git a/wearable/TC/testcase/utc_media_audio_input.c b/wearable/TC/testcase/utc_media_audio_input.c
deleted file mode 100644
index 747bb9f..0000000
--- a/wearable/TC/testcase/utc_media_audio_input.c
+++ /dev/null
@@ -1,309 +0,0 @@
-/*
-* Copyright (c) 2011 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.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License. 
-*/
-
-#include <tet_api.h>
-#include <media/audio_io.h>
-
-enum {
-	POSITIVE_TC_IDX = 0x01,
-	NEGATIVE_TC_IDX,
-};
-
-static void startup(void);
-static void cleanup(void);
-
-void (*tet_startup)(void) = startup;
-void (*tet_cleanup)(void) = cleanup;
-
-static void utc_media_audio_in_create_p(void);
-static void utc_media_audio_in_create_n(void);
-static void utc_media_audio_in_destroy_p(void);
-static void utc_media_audio_in_destroy_n(void);
-static void utc_media_audio_in_read_p(void);
-static void utc_media_audio_in_read_n(void);
-static void utc_media_audio_in_get_buffer_size_p(void);
-static void utc_media_audio_in_get_buffer_size_n(void);
-static void utc_media_audio_in_get_sample_rate_p(void);
-static void utc_media_audio_in_get_sample_rate_n(void);
-static void utc_media_audio_in_get_channel_p(void);
-static void utc_media_audio_in_get_channel_n(void);
-static void utc_media_audio_in_get_sample_type_p(void);
-static void utc_media_audio_in_get_sample_type_n(void);
-
-
-struct tet_testlist tet_testlist[] = {
-	{ utc_media_audio_in_create_p , POSITIVE_TC_IDX },
-	{ utc_media_audio_in_create_n , NEGATIVE_TC_IDX },
-	{ utc_media_audio_in_destroy_p, POSITIVE_TC_IDX },
-	{ utc_media_audio_in_destroy_n, NEGATIVE_TC_IDX },
-	{ utc_media_audio_in_read_p, POSITIVE_TC_IDX },
-	{ utc_media_audio_in_read_n, NEGATIVE_TC_IDX },
-	{ utc_media_audio_in_get_buffer_size_p, POSITIVE_TC_IDX },
-	{ utc_media_audio_in_get_buffer_size_n, NEGATIVE_TC_IDX },
-	{ utc_media_audio_in_get_sample_rate_p, POSITIVE_TC_IDX },
-	{ utc_media_audio_in_get_sample_rate_n, NEGATIVE_TC_IDX },
-	{ utc_media_audio_in_get_channel_p , POSITIVE_TC_IDX },
-	{ utc_media_audio_in_get_channel_n, NEGATIVE_TC_IDX },
-	{ utc_media_audio_in_get_sample_type_p, POSITIVE_TC_IDX },
-	{ utc_media_audio_in_get_sample_type_n, NEGATIVE_TC_IDX },
-	{ NULL, 0 },
-};
-
-static void startup(void)
-{
-	/* start of TC */
-}
-
-static void cleanup(void)
-{
-	/* end of TC */
-}
-
-static void utc_media_audio_in_create_p(void)
-{
-	char* api_name = "audio_in_create";
-	int ret;
-    audio_in_h input;
-    if ((ret = audio_in_create(44100, AUDIO_CHANNEL_MONO ,AUDIO_SAMPLE_TYPE_S16_LE , &input)) == AUDIO_IO_ERROR_NONE)
-    {
-		audio_in_destroy(input);
-		dts_pass(api_name);
-    }
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_in_create_n(void)
-{
-	char* api_name = "audio_in_create";
-	int ret;
-    audio_in_h input;
-    if ((ret = audio_in_create(48100, AUDIO_CHANNEL_MONO ,AUDIO_SAMPLE_TYPE_S16_LE, &input)) != AUDIO_IO_ERROR_NONE)
-    {
-		dts_pass(api_name);
-    }
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_in_destroy_p(void)
-{
-	char* api_name = "audio_in_destroy";
-	int ret;
-    audio_in_h input;
-    if ((ret = audio_in_create(44100, AUDIO_CHANNEL_MONO ,AUDIO_SAMPLE_TYPE_S16_LE, &input)) == AUDIO_IO_ERROR_NONE)
-    {
-		if ((ret = audio_in_destroy(input)) == AUDIO_IO_ERROR_NONE)
-		{
-			dts_pass(api_name);
-		}
-	}
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_in_destroy_n(void)
-{
-	char* api_name = "audio_in_destroy";
-	int ret;
-	if ((ret = audio_in_destroy(NULL)) != AUDIO_IO_ERROR_NONE)
-	{
-		dts_pass(api_name);
-	}
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_in_read_p(void)
-{
-	char* api_name = "audio_in_read";
-	int ret, size;
-    audio_in_h input;
-    if ((ret = audio_in_create(44100, AUDIO_CHANNEL_MONO ,AUDIO_SAMPLE_TYPE_S16_LE, &input)) == AUDIO_IO_ERROR_NONE)
-    {
-		audio_in_prepare(input);
-		if ((ret = audio_in_get_buffer_size(input, &size)) == AUDIO_IO_ERROR_NONE)
-		{
-			char *buffer = NULL;
-			buffer = alloca(size);
-			if ((ret = audio_in_read(input, (void*)buffer, size)) > AUDIO_IO_ERROR_NONE)
-			{
-				audio_in_destroy(input);
-				dts_pass(api_name);
-			}
-		}
-		audio_in_destroy(input);
-	}
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_in_read_n(void)
-{
-	char* api_name = "audio_in_read";
-	int ret, size;
-    audio_in_h input;
-    if ((ret = audio_in_create(44100, AUDIO_CHANNEL_MONO ,AUDIO_SAMPLE_TYPE_S16_LE, &input)) == AUDIO_IO_ERROR_NONE)
-    {
-		if ((ret = audio_in_get_buffer_size(input, &size)) == AUDIO_IO_ERROR_NONE)
-		{
-			char *buffer = NULL;
-			buffer = alloca(size);
-			if ((ret = audio_in_read(input, (void*)buffer, 0)) == AUDIO_IO_ERROR_NONE)
-			{
-				audio_in_destroy(input);
-				dts_pass(api_name);
-			}
-		}
-		audio_in_destroy(input);
-	}
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_in_get_buffer_size_p(void)
-{
-	char* api_name = "audio_in_get_buffer_size";
-	int ret, size;
-    audio_in_h input;
-    if ((ret = audio_in_create(44100, AUDIO_CHANNEL_MONO ,AUDIO_SAMPLE_TYPE_S16_LE , &input)) == AUDIO_IO_ERROR_NONE)
-    {
-		if ((ret = audio_in_get_buffer_size(input, &size)) == AUDIO_IO_ERROR_NONE)
-		{
-			audio_in_destroy(input);
-			dts_pass(api_name);
-		}
-		audio_in_destroy(input);
-	}
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_in_get_buffer_size_n(void)
-{
-	char* api_name = "audio_in_get_buffer_size";
-	int ret, size;
-    audio_in_h input;
-    if ((ret = audio_in_create(44100, AUDIO_CHANNEL_MONO ,AUDIO_SAMPLE_TYPE_S16_LE , &input)) == AUDIO_IO_ERROR_NONE)
-    {
-		if ((ret = audio_in_get_buffer_size(input, NULL)) != AUDIO_IO_ERROR_NONE)
-		{
-			audio_in_destroy(input);
-			dts_pass(api_name);
-		}
-		audio_in_destroy(input);
-	}
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_in_get_sample_rate_p(void)
-{
-	char* api_name = "audio_in_get_sample_rate";
-	int ret;
-    audio_in_h input;
-    if ((ret = audio_in_create(44100, AUDIO_CHANNEL_MONO ,AUDIO_SAMPLE_TYPE_S16_LE , &input)) == AUDIO_IO_ERROR_NONE)
-    {
-		int sample_rate;
-		if ((ret = audio_in_get_sample_rate(input, &sample_rate)) == AUDIO_IO_ERROR_NONE)
-		{
-			audio_in_destroy(input);
-			dts_pass(api_name);
-		}
-		audio_in_destroy(input);
-	}
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_in_get_sample_rate_n(void)
-{
-	char* api_name = "audio_in_get_sample_rate";
-	int ret, sample_rate;
-    audio_in_h input = NULL;
-	if ((ret = audio_in_get_sample_rate(input, &sample_rate)) != AUDIO_IO_ERROR_NONE)
-	{
-		dts_pass(api_name);
-	}
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_in_get_channel_p(void)
-{
-	char* api_name = "audio_in_get_channel";
-	int ret;
-    audio_in_h input;
-    if ((ret = audio_in_create(44100, AUDIO_CHANNEL_MONO ,AUDIO_SAMPLE_TYPE_S16_LE , &input)) == AUDIO_IO_ERROR_NONE)
-    {
-		audio_channel_e channel;
-		if ((ret = audio_in_get_channel(input, &channel)) == AUDIO_IO_ERROR_NONE)
-		{
-			audio_in_destroy(input);
-			dts_pass(api_name);
-		}
-		audio_in_destroy(input);
-	}
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_in_get_channel_n(void)
-{
-	char* api_name = "audio_in_get_channel";
-	int ret;
-	audio_channel_e channel;
-    audio_in_h input = NULL;
-	if ((ret = audio_in_get_channel(input, &channel)) != AUDIO_IO_ERROR_NONE)
-	{
-		dts_pass(api_name);
-	}
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_in_get_sample_type_p(void)
-{
-	char* api_name = "audio_in_get_sample_type";
-	int ret;
-    audio_in_h input;
-    if ((ret = audio_in_create(44100, AUDIO_CHANNEL_MONO ,AUDIO_SAMPLE_TYPE_S16_LE , &input)) == AUDIO_IO_ERROR_NONE)
-    {
-		audio_sample_type_e type;
-		if ((ret = audio_in_get_sample_type(input, &type)) == AUDIO_IO_ERROR_NONE)
-		{
-			audio_in_destroy(input);
-			dts_pass(api_name);
-		}
-		audio_in_destroy(input);
-	}
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_in_get_sample_type_n(void)
-{
-	char* api_name = "audio_in_get_sample_type";
-	int ret;
-	audio_sample_type_e type;
-    audio_in_h input = NULL;
-	if ((ret = audio_in_get_sample_type(input, &type)) != AUDIO_IO_ERROR_NONE)
-	{
-		dts_pass(api_name);
-	}
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
diff --git a/wearable/TC/testcase/utc_media_audio_output.c b/wearable/TC/testcase/utc_media_audio_output.c
deleted file mode 100644
index 1eb0de5..0000000
--- a/wearable/TC/testcase/utc_media_audio_output.c
+++ /dev/null
@@ -1,379 +0,0 @@
-/*
-* Copyright (c) 2011 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.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License. 
-*/
-
-#include <tet_api.h>
-#include <media/audio_io.h>
-
-#define AUDIO_FILE "/mnt/nfs/workspace/capi/media/audio-io/TC/media_samsung.mp3"
-
-enum {
-	POSITIVE_TC_IDX = 0x01,
-	NEGATIVE_TC_IDX,
-};
-
-static void startup(void);
-static void cleanup(void);
-
-void (*tet_startup)(void) = startup;
-void (*tet_cleanup)(void) = cleanup;
-
-static void utc_media_audio_out_create_p(void);
-static void utc_media_audio_out_create_n(void);
-static void utc_media_audio_out_destroy_p(void);
-static void utc_media_audio_out_destroy_n(void);
-static void utc_media_audio_out_write_p(void);
-static void utc_media_audio_out_write_n(void);
-static void utc_media_audio_out_get_buffer_size_p(void);
-static void utc_media_audio_out_get_buffer_size_n(void);
-static void utc_media_audio_out_get_sample_rate_p(void);
-static void utc_media_audio_out_get_sample_rate_n(void);
-static void utc_media_audio_out_get_channel_p(void);
-static void utc_media_audio_out_get_channel_n(void);
-static void utc_media_audio_out_get_sample_type_p(void);
-static void utc_media_audio_out_get_sample_type_n(void);
-static void utc_media_audio_out_get_sound_type_p(void);
-static void utc_media_audio_out_get_sound_type_n(void);
-
-
-struct tet_testlist tet_testlist[] = {
-	{ utc_media_audio_out_create_p , POSITIVE_TC_IDX },
-	{ utc_media_audio_out_create_n , NEGATIVE_TC_IDX },
-	{ utc_media_audio_out_destroy_p, POSITIVE_TC_IDX },
-	{ utc_media_audio_out_destroy_n, NEGATIVE_TC_IDX },
-	{ utc_media_audio_out_write_p, POSITIVE_TC_IDX },
-	{ utc_media_audio_out_write_n, NEGATIVE_TC_IDX },
-	{ utc_media_audio_out_get_buffer_size_p, POSITIVE_TC_IDX },
-	{ utc_media_audio_out_get_buffer_size_n, NEGATIVE_TC_IDX },
-	{ utc_media_audio_out_get_sample_rate_p, POSITIVE_TC_IDX },
-	{ utc_media_audio_out_get_sample_rate_n, NEGATIVE_TC_IDX },
-	{ utc_media_audio_out_get_channel_p , POSITIVE_TC_IDX },
-	{ utc_media_audio_out_get_channel_n, NEGATIVE_TC_IDX },
-	{ utc_media_audio_out_get_sample_type_p, POSITIVE_TC_IDX },
-	{ utc_media_audio_out_get_sample_type_n, NEGATIVE_TC_IDX },
-	{ utc_media_audio_out_get_sound_type_p, POSITIVE_TC_IDX },
-	{ utc_media_audio_out_get_sound_type_n, NEGATIVE_TC_IDX },
-	{ NULL, 0 },
-};
-
-static void startup(void)
-{
-	/* start of TC */
-}
-
-static void cleanup(void)
-{
-	/* end of TC */
-}
-
-static void utc_media_audio_out_create_p(void)
-{
-	char* api_name = "audio_out_create";
-	int ret;
-    audio_out_h output;
-    if ((ret = audio_out_create(44100, AUDIO_CHANNEL_STEREO ,AUDIO_SAMPLE_TYPE_S16_LE , SOUND_TYPE_SYSTEM, &output)) == AUDIO_IO_ERROR_NONE)
-    {
-		audio_out_destroy(output);
-		dts_pass(api_name);
-    }
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_out_create_n(void)
-{
-	char* api_name = "audio_out_create";
-	int ret;
-    audio_out_h output;
-    if ((ret = audio_out_create(48100, AUDIO_CHANNEL_STEREO ,AUDIO_SAMPLE_TYPE_S16_LE, SOUND_TYPE_SYSTEM , &output)) != AUDIO_IO_ERROR_NONE)
-    {
-		dts_pass(api_name);
-    }
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_out_destroy_p(void)
-{
-	char* api_name = "audio_out_destroy";
-	int ret;
-    audio_out_h output;
-    if ((ret = audio_out_create(44100, AUDIO_CHANNEL_STEREO ,AUDIO_SAMPLE_TYPE_S16_LE, SOUND_TYPE_SYSTEM , &output)) == AUDIO_IO_ERROR_NONE)
-    {
-		if ((ret = audio_out_destroy(output)) == AUDIO_IO_ERROR_NONE)
-		{
-			dts_pass(api_name);
-		}
-	}
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_out_destroy_n(void)
-{
-	char* api_name = "audio_out_destroy";
-	int ret;
-	if ((ret = audio_out_destroy(NULL)) != AUDIO_IO_ERROR_NONE)
-	{
-		dts_pass(api_name);
-	}
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_out_write_p(void)
-{
-	char* api_name = "audio_out_write";
-	int ret, size;
-    audio_out_h output;
-    if ((ret = audio_out_create(44100, AUDIO_CHANNEL_STEREO ,AUDIO_SAMPLE_TYPE_S16_LE, SOUND_TYPE_SYSTEM , &output)) == AUDIO_IO_ERROR_NONE)
-    {
-		if ((ret = audio_out_get_buffer_size(output, &size)) == AUDIO_IO_ERROR_NONE)
-		{
-			FILE *fp = NULL;
-			fp = fopen(AUDIO_FILE,"r");
-			if(fp != NULL)
-			{
-				int read;
-				char *buffer = NULL;
-				buffer = alloca(size);
-				if((read = fread(buffer, size, sizeof(char), fp)) > 0 )
-				{
-					audio_out_prepare(output);
-					if ((ret = audio_out_write(output, (void*)buffer, read)) > AUDIO_IO_ERROR_NONE)
-					{
-						fclose(fp);
-						audio_out_destroy(output);
-						dts_pass(api_name);
-					}
-				}
-				else
-				{
-					ret = AUDIO_IO_ERROR_INVALID_BUFFER;
-				}
-				fclose(fp);
-			}
-			else
-			{
-				ret = AUDIO_IO_ERROR_INVALID_BUFFER ;
-			}
-		}
-		audio_out_destroy(output);
-	}
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_out_write_n(void)
-{
-	char* api_name = "audio_out_write";
-	int ret, size;
-    audio_out_h output;
-    if ((ret = audio_out_create(44100, AUDIO_CHANNEL_STEREO ,AUDIO_SAMPLE_TYPE_S16_LE, SOUND_TYPE_SYSTEM , &output)) == AUDIO_IO_ERROR_NONE)
-    {
-		if ((ret = audio_out_get_buffer_size(output, &size)) == AUDIO_IO_ERROR_NONE)
-		{
-			FILE *fp = NULL;
-			fp = fopen(AUDIO_FILE,"r");
-			if(fp != NULL)
-			{
-				char *buffer = NULL;
-				int read;
-				audio_out_prepare(output);
-				if ((ret = audio_out_write(output, (void*)buffer, read)) != AUDIO_IO_ERROR_NONE)
-				{
-					fclose(fp);
-					audio_out_destroy(output);
-					dts_pass(api_name);
-				}
-				fclose(fp);
-			}
-			else
-			{
-				ret = AUDIO_IO_ERROR_INVALID_BUFFER ;
-			}
-		}
-		audio_out_destroy(output);
-	}
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_out_get_buffer_size_p(void)
-{
-	char* api_name = "audio_out_get_buffer_size";
-	int ret, size;
-    audio_out_h output;
-    if ((ret = audio_out_create(44100, AUDIO_CHANNEL_STEREO ,AUDIO_SAMPLE_TYPE_S16_LE , SOUND_TYPE_SYSTEM, &output)) == AUDIO_IO_ERROR_NONE)
-    {
-		if ((ret = audio_out_get_buffer_size(output, &size)) == AUDIO_IO_ERROR_NONE)
-		{
-			audio_out_destroy(output);
-			dts_pass(api_name);
-		}
-		audio_out_destroy(output);
-	}
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_out_get_buffer_size_n(void)
-{
-	char* api_name = "audio_out_get_buffer_size";
-	int ret, size;
-    audio_out_h output;
-    if ((ret = audio_out_create(44100, AUDIO_CHANNEL_STEREO ,AUDIO_SAMPLE_TYPE_S16_LE , SOUND_TYPE_SYSTEM, &output)) == AUDIO_IO_ERROR_NONE)
-    {
-		if ((ret = audio_out_get_buffer_size(output, NULL)) != AUDIO_IO_ERROR_NONE)
-		{
-			audio_out_destroy(output);
-			dts_pass(api_name);
-		}
-		audio_out_destroy(output);
-	}
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_out_get_sample_rate_p(void)
-{
-	char* api_name = "audio_out_get_sample_rate";
-	int ret;
-    audio_out_h output;
-    if ((ret = audio_out_create(44100, AUDIO_CHANNEL_STEREO ,AUDIO_SAMPLE_TYPE_S16_LE , SOUND_TYPE_SYSTEM , &output)) == AUDIO_IO_ERROR_NONE)
-    {
-		int sample_rate;
-		if ((ret = audio_out_get_sample_rate(output, &sample_rate)) == AUDIO_IO_ERROR_NONE)
-		{
-			audio_out_destroy(output);
-			dts_pass(api_name);
-		}
-		audio_out_destroy(output);
-	}
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_out_get_sample_rate_n(void)
-{
-	char* api_name = "audio_in_get_sample_rate";
-	int ret, sample_rate;
-    audio_in_h input = NULL;
-	if ((ret = audio_in_get_sample_rate(input, &sample_rate)) != AUDIO_IO_ERROR_NONE)
-	{
-		dts_pass(api_name);
-	}
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_out_get_channel_p(void)
-{
-	char* api_name = "audio_out_get_channel";
-	int ret;
-    audio_out_h output;
-    if ((ret = audio_out_create(44100, AUDIO_CHANNEL_STEREO ,AUDIO_SAMPLE_TYPE_S16_LE , SOUND_TYPE_SYSTEM , &output)) == AUDIO_IO_ERROR_NONE)
-    {
-		audio_channel_e channel;
-		if ((ret = audio_out_get_channel(output, &channel)) == AUDIO_IO_ERROR_NONE)
-		{
-			audio_out_destroy(output);
-			dts_pass(api_name);
-		}
-		audio_out_destroy(output);
-	}
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_out_get_channel_n(void)
-{
-	char* api_name = "audio_out_get_channel";
-	int ret;
-	audio_channel_e channel;
-    audio_out_h output = NULL;
-	if ((ret = audio_out_get_channel(output, &channel)) != AUDIO_IO_ERROR_NONE)
-	{
-		dts_pass(api_name);
-	}
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_out_get_sample_type_p(void)
-{
-	char* api_name = "audio_out_get_sample_type";
-	int ret;
-    audio_out_h output;
-    if ((ret = audio_out_create(44100, AUDIO_CHANNEL_STEREO ,AUDIO_SAMPLE_TYPE_S16_LE , SOUND_TYPE_SYSTEM , &output)) == AUDIO_IO_ERROR_NONE)
-    {
-		audio_sample_type_e type;
-		if ((ret = audio_out_get_sample_type(output, &type)) == AUDIO_IO_ERROR_NONE)
-		{
-			audio_out_destroy(output);
-			dts_pass(api_name);
-		}
-		audio_out_destroy(output);
-	}
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_out_get_sample_type_n(void)
-{
-	char* api_name = "audio_out_get_sample_type";
-	int ret;
-	audio_sample_type_e type;
-    audio_out_h output = NULL;
-	if ((ret = audio_out_get_sample_type(output, &type)) != AUDIO_IO_ERROR_NONE)
-	{
-		dts_pass(api_name);
-	}
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_out_get_sound_type_p(void)
-{
-	char* api_name = "audio_out_get_sound_type";
-	int ret;
-    audio_out_h output;
-    if ((ret = audio_out_create(44100, AUDIO_CHANNEL_STEREO ,AUDIO_SAMPLE_TYPE_S16_LE , SOUND_TYPE_SYSTEM , &output)) == AUDIO_IO_ERROR_NONE)
-    {
-		sound_type_e type;
-		if ((ret = audio_out_get_sound_type(output, &type)) == AUDIO_IO_ERROR_NONE)
-		{
-			audio_out_destroy(output);
-			dts_pass(api_name);
-		}
-		audio_out_destroy(output);
-	}
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
-
-static void utc_media_audio_out_get_sound_type_n(void)
-{
-	char* api_name = "audio_out_get_sound_type";
-	int ret;
-	audio_sample_type_e type;
-    audio_out_h output = NULL;
-	if ((ret = audio_out_get_sample_type(output, &type)) != AUDIO_IO_ERROR_NONE)
-	{
-		dts_pass(api_name);
-	}
-	dts_message(api_name, "Call log: %d", ret);
-	dts_fail(api_name);
-}
diff --git a/wearable/TC/tet_scen b/wearable/TC/tet_scen
deleted file mode 100755
index 03f029a..0000000
--- a/wearable/TC/tet_scen
+++ /dev/null
@@ -1,7 +0,0 @@
-all
-	^TEST
-##### Scenarios for TEST #####
-
-# Test scenario
-TEST
-	:include:/testcase/tslist
diff --git a/wearable/TC/tetbuild.cfg b/wearable/TC/tetbuild.cfg
deleted file mode 100755
index f7eda55..0000000
--- a/wearable/TC/tetbuild.cfg
+++ /dev/null
@@ -1,5 +0,0 @@
-TET_OUTPUT_CAPTURE=True # capture option for build operation checking
-TET_BUILD_TOOL=make # build with using make command
-TET_BUILD_FILE=-f Makefile # execution file (Makefile) for build
-TET_API_COMPLIANT=True # use TET API in Test Case ?
-TET_PASS_TC_NAME=True # report passed TC name in Journal file?
diff --git a/wearable/TC/tetclean.cfg b/wearable/TC/tetclean.cfg
deleted file mode 100755
index 02d7030..0000000
--- a/wearable/TC/tetclean.cfg
+++ /dev/null
@@ -1,5 +0,0 @@
-TET_OUTPUT_CAPTURE=True # capture option
-TET_CLEAN_TOOL= make clean # clean tool
-TET_CLEAN_FILE= Makefile # file for clean
-TET_API_COMPLIANT=True # TET API useage 
-TET_PASS_TC_NAME=True # showing name , passed TC
diff --git a/wearable/TC/tetexec.cfg b/wearable/TC/tetexec.cfg
deleted file mode 100755
index ef3e452..0000000
--- a/wearable/TC/tetexec.cfg
+++ /dev/null
@@ -1,5 +0,0 @@
-TET_OUTPUT_CAPTURE=True # capturing execution or not
-TET_EXEC_TOOL=  # ex) exec : execution tool set up/ Optional
-TET_EXEC_FILE=   # ex) exectool : execution file/ Optional
-TET_API_COMPLIANT=True # Test case or Tool usesTET API?
-TET_PASS_TC_NAME=True # showing Passed TC name ?
diff --git a/wearable/capi-media-audio-io.manifest b/wearable/capi-media-audio-io.manifest
deleted file mode 100644
index a76fdba..0000000
--- a/wearable/capi-media-audio-io.manifest
+++ /dev/null
@@ -1,5 +0,0 @@
-<manifest>
-	<request>
-		<domain name="_" />
-	</request>
-</manifest>
diff --git a/wearable/debian/README b/wearable/debian/README
deleted file mode 100644
index e69de29..0000000
--- a/wearable/debian/README
+++ /dev/null
diff --git a/wearable/debian/capi-media-audio-io-dev.install b/wearable/debian/capi-media-audio-io-dev.install
deleted file mode 100644
index 761a28b..0000000
--- a/wearable/debian/capi-media-audio-io-dev.install
+++ /dev/null
@@ -1,4 +0,0 @@
-/usr/include/*
-/usr/include/*/*
-/usr/lib/pkgconfig/*.pc
-
diff --git a/wearable/debian/capi-media-audio-io-dev.postinst b/wearable/debian/capi-media-audio-io-dev.postinst
deleted file mode 100644
index 1a24852..0000000
--- a/wearable/debian/capi-media-audio-io-dev.postinst
+++ /dev/null
@@ -1 +0,0 @@
-#!/bin/sh
diff --git a/wearable/debian/capi-media-audio-io.install b/wearable/debian/capi-media-audio-io.install
deleted file mode 100644
index 4a755a4..0000000
--- a/wearable/debian/capi-media-audio-io.install
+++ /dev/null
@@ -1 +0,0 @@
-/usr/lib/lib*.so*
diff --git a/wearable/debian/capi-media-audio-io.postinst b/wearable/debian/capi-media-audio-io.postinst
deleted file mode 100644
index 1a24852..0000000
--- a/wearable/debian/capi-media-audio-io.postinst
+++ /dev/null
@@ -1 +0,0 @@
-#!/bin/sh
diff --git a/wearable/debian/changelog b/wearable/debian/changelog
deleted file mode 100644
index 619eb9c..0000000
--- a/wearable/debian/changelog
+++ /dev/null
@@ -1,87 +0,0 @@
-capi-media-audio-io (0.1.0-9) unstable; urgency=low
-
-  * Fix audio_in_read() bug.
-  * Git: slp-source.sec.samsung.net:slp/api/audio-io
-  * Tag: capi-media-audio-io_0.1.0-9 
-
- -- Kangho Hur <kangho.hur@samsung.com>  Wed, 04 Jul 2012 13:30:46 +0900
-
-capi-media-audio-io (0.1.0-8) unstable; urgency=low
-
-  * Add the start/stop recording APIs
-  * Git: slp-source.sec.samsung.net:slp/api/audio-io
-  * Tag: capi-media-audio-io_0.1.0-8
-
- -- Kangho Hur <kangho.hur@samsung.com>  Thu, 28 Jun 2012 20:25:31 +0900
-
-capi-media-audio-io (0.1.0-7) unstable; urgency=low
-
-  * The valid sample rate range updated.
-  * Git: slp-source.sec.samsung.net:slp/api/audio-io
-  * Tag: capi-media-audio-io_0.1.0-7
-
- -- Kangho Hur <kangho.hur@samsung.com>  Thu, 10 May 2012 21:18:26 +0900
-
-capi-media-audio-io (0.1.0-6) unstable; urgency=low
-
-  * Use 'static' to local function which is limited to the current source file.
-  * Git: slp-source.sec.samsung.net:slp/api/audio-io
-  * Tag: capi-media-audio-io_0.1.0-6 
-
- -- Kangho Hur <kangho.hur@samsung.com>  Tue, 21 Feb 2012 10:07:56 +0900
-
-capi-media-audio-io (0.1.0-5) unstable; urgency=low
-
-  * Apply the SOVERSION 
-  * Git: slp-source.sec.samsung.net:slp/api/audio-io
-  * Tag: capi-media-audio-io_0.1.0-5
-
- -- Kangho Hur <kangho.hur@samsung.com>  Tue, 14 Feb 2012 17:11:01 +0900
-
-capi-media-audio-io (0.1.0-4) unstable; urgency=low
-
-  * Changes the value of ERROR_NONE
-  * Git: slp-source.sec.samsung.net:slp/api/audio-io
-  * Tag: capi-media-audio-io_0.1.0-4 
-
- -- Kangho Hur <kangho.hur@samsung.com>  Mon, 05 Dec 2011 11:26:36 +0900
-
-capi-media-audio-io (0.1.0-3) unstable; urgency=low
-
-  * Apply the Tizen
-  * Git: slp-source.sec.samsung.net:slp/api/audio-io
-  * Tag: capi-media-audio-io_0.1.0-3
-
- -- Kangho Hur <kangho.hur@samsung.com>  Wed, 23 Nov 2011 15:52:29 +0900
-
-capi-media-audio-io (0.1.0-2) unstable; urgency=low
-
-  * Apply the error messages 
-  * Git: slp-source.sec.samsung.net:slp/api/audio-io
-  * Tag: capi-media-audio-io_0.1.0-2 
-
- -- Kangho Hur <kangho.hur@samsung.com>  Fri, 07 Oct 2011 21:08:17 +0900
-
-capi-media-audio-io (0.1.0-1) unstable; urgency=low
-
-  * Alpha Release
-  * Git: slp-source.sec.samsung.net:slp/api/audio-io
-  * Tag: capi-media-audio-io_0.1.0-1 
-
- -- Kangho Hur <kangho.hur@samsung.com>  Tue, 27 Sep 2011 19:44:18 +0900
-
-capi-media-audio-io (0.0.1-2) unstable; urgency=low
-
-  * Update API Description
-  * Git: slp-source.sec.samsung.net:slp/api/audio-io
-  * Tag: capi-media-audio-io_0.0.1-2 
-
- -- Kangho Hur <kangho.hur@samsung.com>  Mon, 19 Sep 2011 17:46:51 +0900
-
-capi-media-audio-io (0.0.1-1) unstable; urgency=low
-
-  * Initial Upload
-  * Git: slp-source.sec.samsung.net:slp/api/audio-io
-  * Tag: capi-media-audio-io_0.0.1-1
-
- -- Kangho Hur <kangho.hur@samsung.com> Thu, 04 Aug 2011 18:11:55 +0900
diff --git a/wearable/debian/compat b/wearable/debian/compat
deleted file mode 100644
index 7ed6ff8..0000000
--- a/wearable/debian/compat
+++ /dev/null
@@ -1 +0,0 @@
-5
diff --git a/wearable/debian/control b/wearable/debian/control
deleted file mode 100644
index 5a7bfd2..0000000
--- a/wearable/debian/control
+++ /dev/null
@@ -1,22 +0,0 @@
-
-Source: capi-media-audio-io
-Section: libs
-Priority: extra
-Maintainer: Kangho Hur <kangho.hur@samsung.com>, Seungkeun Lee <sngn.lee@samsung.com>
-Build-Depends: debhelper (>= 5), dlog-dev, libmm-sound-dev, capi-base-common-dev, capi-media-sound-manager-dev
-
-Package: capi-media-audio-io
-Architecture: any
-Depends: ${shlibs:Depends}, ${misc:Depends}
-Description: An Audio Input & Audio Output library in Tizen Native API
-
-Package: capi-media-audio-io-dev
-Architecture: any
-Depends: ${shlibs:Depends}, ${misc:Depends}, capi-media-audio-io (= ${Source-Version}), capi-base-common-dev, capi-media-sound-manager-dev
-Description: An Audio Input & Audio Output library in Tizen Native API (DEV)
-
-Package: capi-media-audio-io-dbg
-Architecture: any
-Depends: ${shlibs:Depends}, ${misc:Depends}, capi-media-audio-io (= ${Source-Version})
-Description: An Audio Input & Audio Output library in Tizen Native API (DBG)
-
diff --git a/wearable/debian/rules b/wearable/debian/rules
deleted file mode 100755
index 235c5ef..0000000
--- a/wearable/debian/rules
+++ /dev/null
@@ -1,68 +0,0 @@
-#!/usr/bin/make -f
-
-CFLAGS = -Wall -g
-
-FULLVER ?= $(shell dpkg-parsechangelog | grep Version: | cut -d ' ' -f 2 | cut -d '-' -f 1)
-MAJORVER ?= $(shell echo $(FULLVER) | cut -d '.' -f 1)
-
-ifneq (,$(findstring noopt,$(DEB_BUILD_OPTIONS)))
-	CFLAGS += -O0
-else
-	CFLAGS += -O2
-endif
-CMAKE_ROOT_DIR ?= $(CURDIR)
-CMAKE_BUILD_DIR ?= $(CURDIR)/cmake_build_tmp
-
-configure: configure-stamp
-configure-stamp:
-	dh_testdir
-	mkdir -p $(CMAKE_BUILD_DIR) && cd $(CMAKE_BUILD_DIR) && cmake .. -DFULLVER=${FULLVER} -DMAJORVER=${MAJORVER}
-	touch configure-stamp
-
-
-build: build-stamp
-build-stamp: configure-stamp 
-	dh_testdir
-	cd $(CMAKE_BUILD_DIR) && $(MAKE)
-	touch $@
-
-clean:
-	cd $(CMAKE_ROOT_DIR)
-	dh_testdir
-	dh_testroot
-	rm -f build-stamp configure-stamp
-	rm -f `find . -name *.pc`
-	rm -rf $(CMAKE_BUILD_DIR)
-	dh_clean
-	
-install: build
-	dh_testdir
-	dh_testroot
-	dh_clean -k 
-	dh_installdirs
-
-	cd $(CMAKE_BUILD_DIR) && $(MAKE) DESTDIR=$(CURDIR)/debian/tmp install
-
-binary-indep: build install
-
-binary-arch: build install
-	dh_testdir
-	dh_testroot
-	dh_installchangelogs 
-	dh_installdocs
-	dh_installexamples
-	dh_install --sourcedir=debian/tmp
-	dh_installman
-	dh_link
-	dh_strip --dbg-package=capi-media-audio-io-dbg
-	dh_fixperms
-	dh_makeshlibs
-	dh_installdeb
-	dh_shlibdeps
-	dh_gencontrol
-	dh_md5sums
-	dh_builddeb
-
-binary: binary-indep binary-arch
-.PHONY: build clean binary-indep binary-arch binary install configure
-
diff --git a/wearable/include/audio_io.h b/wearable/include/audio_io.h
deleted file mode 100644
index 6d1812e..0000000
--- a/wearable/include/audio_io.h
+++ /dev/null
@@ -1,586 +0,0 @@
-/*
-* Copyright (c) 2011 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.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License. 
-*/
-
-#ifndef __TIZEN_MEDIA_AUDIO_IO_H__
-#define __TIZEN_MEDIA_AUDIO_IO_H__
-
-#include <tizen.h>
-#include <sound_manager.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-#define AUDIO_IO_ERROR_CLASS          TIZEN_ERROR_MULTIMEDIA_CLASS | 0x40
-
-/**
- * @file audio_io.h
- * @brief This file contains the Audio Input and Output API.
- */
-
-/**
- * @addtogroup CAPI_MEDIA_AUDIO_IN_MODULE
- * @{
-*/
-
-/**
- * @brief Audio input handle type.
- */
-typedef struct audio_in_s *audio_in_h;
-
-/**
- * @}
-*/
-
-/**
- * @addtogroup CAPI_MEDIA_AUDIO_OUT_MODULE
- * @{
- */
- 
-/**
- * @brief Audio output handle type.
- */
-typedef struct audio_out_s *audio_out_h;
-
- /**
- * @}
- */
-
-/**
- * @addtogroup CAPI_MEDIA_AUDIO_IO_MODULE
- * @{
- */
-
-/**
- * @brief Enumerations of audio sample type with bit depth
- */
-typedef enum
-{
-    AUDIO_SAMPLE_TYPE_U8 = 0x70,   /**< Unsigned 8-bit audio samples */
-    AUDIO_SAMPLE_TYPE_S16_LE,   /**< Signed 16-bit audio samples */
-} audio_sample_type_e;
-
-
-/**
- * @brief Enumerations of audio source type
- */
-typedef enum {
-    AUDIO_IO_SUPPORT_SOURCE_TYPE_DEFAULT, /* High Gain with No filter */
-    AUDIO_IO_SOURCE_TYPE_MIRRORING,
-    AUDIO_IO_SOURCE_TYPE_VOICECONTROL, /* VoiceControl Gain with No filter */
-    AUDIO_IO_SOURCE_TYPE_SVR, /* VoiceRecognition Gain with No filter  */
-    AUDIO_IO_SOURCE_TYPE_VIDEOCALL, /* Not used for AudioIn now.... */
-    AUDIO_IO_SOURCE_TYPE_VOICERECORDING /* Low Gain with Boosting filter */
-} audio_io_source_type_e;
-
-/**
- * @brief Enumerations of audio channel
- */
-typedef enum {
-    AUDIO_CHANNEL_MONO = 0x80,    /**< 1 channel, mono */
-    AUDIO_CHANNEL_STEREO,      /**< 2 channel, stereo */
-} audio_channel_e;
-
-/**
- * @brief Enumerations of audio input and output error code
- */
-typedef enum{
-    AUDIO_IO_ERROR_NONE                = TIZEN_ERROR_NONE,                /**<Successful */
-    AUDIO_IO_ERROR_OUT_OF_MEMORY       = TIZEN_ERROR_OUT_OF_MEMORY,     /**< Out of memory */
-    AUDIO_IO_ERROR_INVALID_PARAMETER   = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
-    AUDIO_IO_ERROR_INVALID_OPERATION   = TIZEN_ERROR_INVALID_OPERATION, /**< Invalid operation */
-    AUDIO_IO_ERROR_DEVICE_NOT_OPENED   = AUDIO_IO_ERROR_CLASS | 0x01, /**< Device open error */
-    AUDIO_IO_ERROR_DEVICE_NOT_CLOSED   = AUDIO_IO_ERROR_CLASS | 0x02, /**< Device close error */
-    AUDIO_IO_ERROR_INVALID_BUFFER      = AUDIO_IO_ERROR_CLASS | 0x03, /**< Invalid buffer pointer */
-    AUDIO_IO_ERROR_SOUND_POLICY        = AUDIO_IO_ERROR_CLASS | 0x04, /**< Sound policy error */
-} audio_io_error_e;
-
-/**
- * @brief Enumerations of audio io interrupted type
- */
-typedef enum
-{
-    AUDIO_IO_INTERRUPTED_COMPLETED = 0, 				/**< Interrupt completed*/
-    AUDIO_IO_INTERRUPTED_BY_MEDIA, 				/**< Interrupted by non-resumable media application*/
-    AUDIO_IO_INTERRUPTED_BY_CALL,						/**< Interrupted by incoming call*/
-    AUDIO_IO_INTERRUPTED_BY_EARJACK_UNPLUG,			/**< Interrupted by unplugging headphone*/
-    AUDIO_IO_INTERRUPTED_BY_RESOURCE_CONFLICT,		/**< Interrupted by resource conflict*/
-    AUDIO_IO_INTERRUPTED_BY_ALARM,					/**< Interrupted by alarm*/
-    AUDIO_IO_INTERRUPTED_BY_EMERGENCY,					/**< Interrupted by emergency*/
-    AUDIO_IO_INTERRUPTED_BY_RESUMABLE_MEDIA, 				/**< Interrupted by resumable media application*/
-    AUDIO_IO_INTERRUPTED_BY_NOTIFICATION, 				/**< Interrupted by notification*/
-} audio_io_interrupted_code_e;
-
-/**
- * @brief  Called when the audio input or output is interrupted.
- * @param[in]	error_code	The interrupted error code
- * @param[in]	user_data	The user data passed from the callback registration function
- * @see audio_in_set_interrupted_cb()
- * @see audio_out_set_interrupted_cb()
- * @see audio_in_unset_interrupted_cb()
- * @see audio_out_unset_interrupted_cb()
- */
-typedef void (*audio_io_interrupted_cb)(audio_io_interrupted_code_e code, void *user_data);
-
-/**
- * @}
-*/
-
-/**
- * @addtogroup CAPI_MEDIA_AUDIO_IN_MODULE
- * @{
-*/
-
-
-//
-//AUDIO INPUT
-//
-
-
-/**
- * @brief    Creates an audio device instance and returns an input handle to record PCM (pulse-code modulation) data
- * @details  This function is used for audio input initialization.
- *
- * @remarks @a input must be release audio_in_destroy() by you.
- *
- * @param[in]  sample_rate	The audio sample rate in 8000[Hz] ~ 48000[Hz]
- * @param[in]  channel	The audio channel type, mono, or stereo
- * @param[in]  type	The type of audio sample (8- or 16-bit)
- * @param[out] input	An audio input handle will be created, if successful
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #AUDIO_IO_ERROR_OUT_OF_MEMORY Out of memory
- * @retval #AUDIO_IO_ERROR_DEVICE_NOT_OPENED Device not opened
- * @retval #AUDIO_IO_ERROR_SOUND_POLICY    Sound policy error
- * @see audio_in_destroy()
- */
-int audio_in_create(int sample_rate, audio_channel_e channel, audio_sample_type_e type , audio_in_h *input);
-
-
-
-/**
- * @brief    Creates an audio device instance and returns an input handle to record PCM (pulse-code modulation) data
- * @details  This function is used for audio input initialization.
- *
- * @remarks @a input must be release audio_in_destroy() by you.
- *
- * @param[in]  sample_rate	The audio sample rate in 8000[Hz] ~ 48000[Hz]
- * @param[in]  channel	The audio channel type, mono, or stereo
- * @param[in]  type	The type of audio sample (8- or 16-bit)
- * @param[in]  source_type	 The type of audio_io_support_source_type_e.
- * @param[out] input	An audio input handle will be created, if successful
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #AUDIO_IO_ERROR_OUT_OF_MEMORY Out of memory
- * @retval #AUDIO_IO_ERROR_DEVICE_NOT_OPENED Device not opened
- * @retval #AUDIO_IO_ERROR_SOUND_POLICY    Sound policy error
- * @see audio_in_destroy()
- */
-int audio_in_create_ex(int sample_rate, audio_channel_e channel, audio_sample_type_e type , audio_in_h* input, audio_io_source_type_e source_type);
-
-
-
-/**
- * @brief    Releases the audio input handle and all its resources associated with an audio stream
- *
- * @param[in]	input	The handle to the audio input to destroy
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #AUDIO_IO_ERROR_DEVICE_NOT_CLOSED Device not closed
- * @see audio_in_create()
- */
-int audio_in_destroy(audio_in_h input);
-
-
-
-/**
- * @brief   Prepare reading audio in by starting buffering the audio data from the device
- * @param[in]	input	The handle to the audio input
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @see audio_in_unprepare()
- */
-int audio_in_prepare(audio_in_h input);
-
-
-
-/**
- * @brief    Unprepare reading audio in by stopping buffering the audio data from the device
- * @param[in]	input	The handle to the audio input
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @see audio_in_prepare()
- */
-int audio_in_unprepare(audio_in_h input);
-
-
-
-/**
- * @brief   Reads audio data from the audio input buffer
- *
- * @param[in]	input	The handle to the audio input
- * @param[out]	buffer	The PCM buffer address
- * @param[in]	length	The length of PCM data buffer (in bytes)
- *
- * @return  Number of read bytes on success, otherwise a negative error value.
- * @retval  #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval  #AUDIO_IO_ERROR_INVALID_BUFFER  Invalid buffer pointer
- * @retval  #AUDIO_IO_ERROR_SOUND_POLICY    Sound policy error
- * @retval  #AUDIO_IO_ERROR_INVALID_OPERATION Invalid operation
- * @pre audio_in_start_recording() 
-*/
-int audio_in_read(audio_in_h input, void *buffer, unsigned int length);
-
-
-
-/**
- * @brief    Gets the size to be allocated for audio input buffer
- * @param[in]   input	The handle to the audio input
- * @param[out]  size	The buffer size (in bytes). \n The maximum size is 1 MB.
- *
- * @return  0 on success, otherwise a negative error value.
- * @retval  #AUDIO_IO_ERROR_NONE Successful
- * @retval  #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @see audio_in_read()
-*/
-int audio_in_get_buffer_size(audio_in_h input, int *size);
-
-
-
-/**
- * @brief    Gets the sample rate of the audio input data stream
- *
- * @param[in]   input	The handle to the audio input
- * @param[out]  sample_rate  The audio sample rate in Hertz (8000 ~ 48000)
- *
- * @return  0 on success, otherwise a negative error value.
- * @retval  #AUDIO_IO_ERROR_NONE Successful
- * @retval  #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
-*/
-int audio_in_get_sample_rate(audio_in_h input, int *sample_rate);
-
-
-
-/**
- * @brief    Gets the channel type of audio input data stream
- *
- * @details  The audio channel type defines whether the audio is mono or stereo.
- *
- * @param[in]   input   The handle to the audio input
- * @param[out]  channel The audio channel type
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
-*/
-int audio_in_get_channel(audio_in_h input, audio_channel_e *channel);
-
-
-
-/**
- * @brief    Gets the sample audio format (8-bit or 16-bit) of audio input data stream
- *
- * @param[in]  input    The handle to the audio input
- * @param[out] type     The audio sample type
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
-*/
-int audio_in_get_sample_type(audio_in_h input, audio_sample_type_e *type);
-
-
-/**
- * @brief    Gets the latency value of audio input data stream
- * @param[in]   input	The handle to the audio input
- * @param[out]  latency	The stream latency value(millisecond).
- *
- * @return  0 on success, otherwise a negative error value.
- * @retval  #AUDIO_IO_ERROR_NONE Successful
- * @retval  #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @see audio_out_get_latency()
-*/
-int audio_in_get_latency(audio_in_h input, int *latency);
-
-
-/**
- * @brief Registers a callback function to be invoked when the audio input handle is interrupted or interrupt completed.
- * @param[in] input    The handle to the audio input
- * @param[in] callback	The callback function to register
- * @param[in] user_data	The user data to be passed to the callback function
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #AUDIO_IO_ERROR_INVALID_OPERATION Invalid operation
- * @post  audio_io_interrupted_cb() will be invoked
- * @see audio_in_unset_interrupted_cb()
- * @see audio_io_interrupted_cb()
- */
-int audio_in_set_interrupted_cb(audio_in_h input, audio_io_interrupted_cb callback, void *user_data);
-
-/**
- * @brief Unregisters the callback function.
- * @param[in]  input   The handle to the audio input
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #AUDIO_IO_ERROR_INVALID_OPERATION Invalid operation
- * @see audio_in_set_interrupted_cb()
- */
-int audio_in_unset_interrupted_cb(audio_in_h input);
-
-/**
- * @brief Ignore session for input
- * @param[in]  input   The handle to the audio input
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #AUDIO_IO_ERROR_INVALID_OPERATION Invalid operation
- * @see
- */
-int audio_in_ignore_session(audio_in_h input);
-
-//
-//  AUDIO OUTPUT
-//
-
-/**
- * @}
-*/
-
-/**
- * @addtogroup CAPI_MEDIA_AUDIO_OUT_MODULE
- * @{
- */
-
-/**
- * @brief    Creates an audio device instance and returns an output handle to play PCM (pulse-code modulation) data
- * @details  This function is used for audio output initialization. 
- * @remarks @a output must be released audio_out_destroy() by you.
- *
- * @param[in]  sample_rate  The audio sample rate in 8000[Hz] ~ 48000[Hz]
- * @param[in]  channel      The audio channel type, mono, or stereo
- * @param[in]  type         The type of audio sample (8- or 16-bit)
- * @param[in]  sound_type   The type of sound (#sound_type_e)
- * @param[out] output       An audio output handle will be created, if successful
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #AUDIO_IO_ERROR_OUT_OF_MEMORY Out of memory
- * @retval #AUDIO_IO_ERROR_DEVICE_NOT_OPENED Device not opened
- * @retval #AUDIO_IO_ERROR_SOUND_POLICY    Sound policy error
- *
- * @see audio_out_destroy()
-*/
-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);
-
-
-
-/**
- * @brief    Releases the audio output handle, along with all its resources
- *
- * @param[in]	output The handle to the audio output to destroy
- *
- * @return  0 on success, otherwise a negative error value.
- * @retval  #AUDIO_IO_ERROR_NONE Successful
- * @retval  #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval  #AUDIO_IO_ERROR_OUT_OF_MEMORY Out of memory
- * @retval  #AUDIO_IO_ERROR_DEVICE_NOT_CLOSED Device not closed
- *
- * @see audio_out_create()
-*/
-int audio_out_destroy(audio_out_h output);
-
-/**
- * @brief   Prepare playing audio out, this must be called before audio_out_write()
- * @param[in]	output	The handle to the audio output
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @see audio_out_unprepare()
- */
-int audio_out_prepare(audio_out_h output);
-
-
-
-/**
- * @brief    Unprepare playing audio out.
- * @param[in]	output	The handle to the audio output
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @see audio_out_prepare()
- */
-int audio_out_unprepare(audio_out_h output);
-
-
-
-
-/**
- * @brief    Starts writing the audio data to the device
- *
- * @param[in]       output  The handle to the audio output
- * @param[in,out]   buffer  The PCM buffer address
- * @param[in]       length  The length of PCM buffer (in bytes)
- *
- * @return  Written data size on success, otherwise a negative error value.
- * @retval  #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval  #AUDIO_IO_ERROR_INVALID_BUFFER  Invalid buffer pointer
- * @retval  #AUDIO_IO_ERROR_SOUND_POLICY    Sound policy error
-*/
-int audio_out_write(audio_out_h output, void *buffer, unsigned int length);
-
-
-
-/**
- * @brief    Gets the size to be allocated for audio output buffer
- * @param[in]     output  The handle to the audio output
- * @param[out]    size    The suggested buffer size (in bytes). \n The maximum size is 1 MB.
- *
- * @return  0 on success, otherwise a negative error value.
- * @retval  #AUDIO_IO_ERROR_NONE Successful
- * @retval  #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @see audio_out_write()
- *
-*/
-int audio_out_get_buffer_size(audio_out_h output, int *size);
-
-
-
-/**
- * @brief    Gets the sample rate of audio output data stream
- *
- * @param[in]   output       The handle to the audio output
- * @param[out]  sample_rate  The audio sample rate in Hertz (8000 ~ 48000)
- *
- * @return  0 on success, otherwise a negative error value.
- * @retval  #AUDIO_IO_ERROR_NONE Successful
- * @retval  #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
-*/
-int audio_out_get_sample_rate(audio_out_h output, int *sample_rate);
-
-
-
-/**
- * @brief    Gets the channel type of audio output data stream
- *
- * @details  The audio channel type defines whether the audio is mono or stereo.
- *
- * @param[in]   output  The handle to the audio output
- * @param[out]  channel The audio channel type
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
-*/
-int audio_out_get_channel(audio_out_h output, audio_channel_e *channel);
-
-
-
-/**
- * @brief    Gets the sample audio format (8-bit or 16-bit) of audio output data stream
- *
- * @param[in]   output  The handle to the audio output
- * @param[out]  type    The audio sample type
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
-*/
-int audio_out_get_sample_type(audio_out_h output, audio_sample_type_e *type);
-
-
-/**
- * @brief    Gets the latency value of audio output data stream
- * @param[in]   input	The handle to the audio output
- * @param[out]  latency	The stream latency value(millisecond).
- *
- * @return  0 on success, otherwise a negative error value.
- * @retval  #AUDIO_IO_ERROR_NONE Successful
- * @retval  #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @see audio_in_get_latency()
-*/
-int audio_out_get_latency(audio_out_h output, int *latency);
-
-
-/**
- * @brief    Gets the sound type supported by the audio output device
- * @param[in]  output   The handle to the audio output
- * @param[out] type     The sound type
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
-*/
-int audio_out_get_sound_type(audio_out_h output, sound_type_e *type);
-
-
-/**
- * @brief Registers a callback function to be invoked when the audio out handle is interrupted or interrupt completed.
- * @param[in] output   The handle to the audio output
- * @param[in] callback	The callback function to register
- * @param[in] user_data	The user data to be passed to the callback function
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #AUDIO_IO_ERROR_INVALID_OPERATION Invalid operation
- * @post  audio_io_interrupted_cb() will be invoked
- * @see audio_out_unset_interrupted_cb()
- * @see audio_io_interrupted_cb()
- */
-int audio_out_set_interrupted_cb(audio_out_h output, audio_io_interrupted_cb callback, void *user_data);
-
-/**
- * @brief Unregisters the callback function.
- * @param[in]  output   The handle to the audio output
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #AUDIO_IO_ERROR_INVALID_OPERATION Invalid operation
- * @see audio_out_set_interrupted_cb()
- */
-int audio_out_unset_interrupted_cb(audio_out_h output);
-
-/**
- * @brief Ignore session for output
- * @param[in]  output   The handle to the audio output
- * @return 0 on success, otherwise a negative error value.
- * @retval #AUDIO_IO_ERROR_NONE Successful
- * @retval #AUDIO_IO_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #AUDIO_IO_ERROR_INVALID_OPERATION Invalid operation
- * @see
- */
-int audio_out_ignore_session(audio_out_h output);
-
-
-/**
- * @}
-*/
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __TIZEN_MEDIA_AUDIO_IO_H__ */
diff --git a/wearable/include/audio_io_private.h b/wearable/include/audio_io_private.h
deleted file mode 100644
index d124cea..0000000
--- a/wearable/include/audio_io_private.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
-* Copyright (c) 2011 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.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License. 
-*/
-
-#ifndef __TIZEN_MEDIA_AUDIO_IO_PRIVATE_H__
-#define	__TIZEN_MEDIA_AUDIO_IO_PRIVATE_H__
-#include <audio_io.h>
-#include <sound_manager.h>
-#include <mm_sound.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-typedef struct _audio_in_s{
-	MMSoundPcmHandle_t mm_handle;
-	int _buffer_size;
-	int _sample_rate;
-	audio_channel_e _channel;
-	audio_sample_type_e _type;
-	audio_io_interrupted_cb user_cb;
-	void* user_data;
-} audio_in_s;
-
-typedef struct _audio_out_s{
-	MMSoundPcmHandle_t mm_handle;
-	int _buffer_size;
-	int _sample_rate;
-	audio_channel_e _channel;
-	audio_sample_type_e _type; 	
-	sound_type_e	_sound_type;
-	audio_io_interrupted_cb user_cb;
-	void* user_data;
-} audio_out_s;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif //__TIZEN_MEDIA_AUDIO_IO_PRIVATE_H__
diff --git a/wearable/src/audio_io.c b/wearable/src/audio_io.c
deleted file mode 100644
index a3339c1..0000000
--- a/wearable/src/audio_io.c
+++ /dev/null
@@ -1,656 +0,0 @@
-/*
-* Copyright (c) 2011 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.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License. 
-*/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <mm.h>
-#include <audio_io_private.h>
-#include <dlog.h>
-
-#ifdef LOG_TAG
-#undef LOG_TAG
-#endif
-#define LOG_TAG "TIZEN_N_AUDIO_IO"
-
-/*
-* Internal Macros
-*/
-#define AUDIO_IO_CHECK_CONDITION(condition,error,msg)	\
-		if(condition) {} else \
-		{ LOGE("[%s] %s(0x%08x)",__FUNCTION__, msg,error); return error;}; \
-
-#define AUDIO_IO_NULL_ARG_CHECK(arg)	\
-	AUDIO_IO_CHECK_CONDITION(arg != NULL, AUDIO_IO_ERROR_INVALID_PARAMETER, "AUDIO_IO_ERROR_INVALID_PARAMETER" )
-
-/*
-* Internal Implementation
-*/
-static int __convert_error_code(int code, char *func_name)
-{
-	int ret = AUDIO_IO_ERROR_NONE;
-	char* msg = "AUDIO_IO_ERROR_NONE";
-
-	switch(code)
-	{
-		case MM_ERROR_NONE:
-			ret = AUDIO_IO_ERROR_NONE;
-			msg = "AUDIO_IO_ERROR_NONE";
-			break;
-		case MM_ERROR_INVALID_ARGUMENT:
-		case MM_ERROR_SOUND_DEVICE_INVALID_SAMPLERATE:
-		case MM_ERROR_SOUND_DEVICE_INVALID_CHANNEL:
-		case MM_ERROR_SOUND_DEVICE_INVALID_FORMAT:
-			ret = AUDIO_IO_ERROR_INVALID_PARAMETER;
-			msg = "AUDIO_IO_ERROR_INVALID_PARAMETER";
-			break;
-		case MM_ERROR_SOUND_DEVICE_NOT_OPENED:
-			ret = AUDIO_IO_ERROR_DEVICE_NOT_OPENED;
-			msg = "AUDIO_IO_ERROR_DEVICE_NOT_OPENED";
-			break;
-		case MM_ERROR_SOUND_INTERNAL:
-			ret = AUDIO_IO_ERROR_DEVICE_NOT_CLOSED;
-			msg = "AUDIO_IO_ERROR_DEVICE_NOT_CLOSED";
-			break;
-		case MM_ERROR_SOUND_INVALID_POINTER:
-			ret = AUDIO_IO_ERROR_INVALID_BUFFER;
-			msg = "AUDIO_IO_ERROR_INVALID_BUFFER";
-			break;		
-		case MM_ERROR_POLICY_BLOCKED:
-		case MM_ERROR_POLICY_INTERRUPTED:
-		case MM_ERROR_POLICY_INTERNAL:
-		case MM_ERROR_POLICY_DUPLICATED:
-			ret = AUDIO_IO_ERROR_SOUND_POLICY;
-			msg = "AUDIO_IO_ERROR_SOUND_POLICY";
-			break;
-	} 
-	LOGE("[%s] %s(0x%08x) : core fw error(0x%x)",func_name,msg, ret, code);
-	return ret;	
-}
-
-static int __check_parameter(int sample_rate, audio_channel_e channel, audio_sample_type_e type)
-{
-	if(sample_rate<8000 || sample_rate > 48000)	{
-		LOGE("[%s] AUDIO_IO_ERROR_INVALID_PARAMETER(0x%08x) :  Invalid sample rate (8000~48000Hz) : %d",__FUNCTION__, AUDIO_IO_ERROR_INVALID_PARAMETER,sample_rate);
-		return AUDIO_IO_ERROR_INVALID_PARAMETER;
-	}
-	if (channel < AUDIO_CHANNEL_MONO || channel > AUDIO_CHANNEL_STEREO) {
-		LOGE("[%s] AUDIO_IO_ERROR_INVALID_PARAMETER(0x%08x) :  Invalid audio channel : %d",__FUNCTION__, AUDIO_IO_ERROR_INVALID_PARAMETER,channel);
-		return AUDIO_IO_ERROR_INVALID_PARAMETER;
-	}
-	if (type < AUDIO_SAMPLE_TYPE_U8 || type > AUDIO_SAMPLE_TYPE_S16_LE) {
-		LOGE("[%s] AUDIO_IO_ERROR_INVALID_PARAMETER(0x%08x) :  Invalid sample typel : %d",__FUNCTION__, AUDIO_IO_ERROR_INVALID_PARAMETER,type);
-		return AUDIO_IO_ERROR_INVALID_PARAMETER;
-	}
-	return AUDIO_IO_ERROR_NONE;
-}
-
-
-static audio_io_interrupted_code_e __translate_interrupted_code (int code)
-{
-	audio_io_interrupted_code_e e = AUDIO_IO_INTERRUPTED_COMPLETED;
-
-	switch(code)
-	{
-	case MM_MSG_CODE_INTERRUPTED_BY_ALARM_END:
-	case MM_MSG_CODE_INTERRUPTED_BY_EMERGENCY_END:
-	case MM_MSG_CODE_INTERRUPTED_BY_NOTIFICATION_END:
-		e = AUDIO_IO_INTERRUPTED_COMPLETED;
-		break;
-
-	case MM_MSG_CODE_INTERRUPTED_BY_MEDIA:
-	case MM_MSG_CODE_INTERRUPTED_BY_OTHER_PLAYER_APP:
-		e = AUDIO_IO_INTERRUPTED_BY_MEDIA;
-		break;
-
-	case MM_MSG_CODE_INTERRUPTED_BY_CALL_START:
-		e = AUDIO_IO_INTERRUPTED_BY_CALL;
-		break;
-
-	case MM_MSG_CODE_INTERRUPTED_BY_EARJACK_UNPLUG:
-		e = AUDIO_IO_INTERRUPTED_BY_EARJACK_UNPLUG;
-		break;
-
-	case MM_MSG_CODE_INTERRUPTED_BY_RESOURCE_CONFLICT:
-		e = AUDIO_IO_INTERRUPTED_BY_RESOURCE_CONFLICT;
-		break;
-
-	case MM_MSG_CODE_INTERRUPTED_BY_ALARM_START:
-		e = AUDIO_IO_INTERRUPTED_BY_ALARM;
-		break;
-
-	case MM_MSG_CODE_INTERRUPTED_BY_NOTIFICATION_START:
-		e = AUDIO_IO_INTERRUPTED_BY_NOTIFICATION;
-		break;
-
-	case MM_MSG_CODE_INTERRUPTED_BY_EMERGENCY_START:
-		e = AUDIO_IO_INTERRUPTED_BY_EMERGENCY;
-		break;
-
-	case MM_MSG_CODE_INTERRUPTED_BY_RESUMABLE_MEDIA:
-		e = AUDIO_IO_INTERRUPTED_BY_RESUMABLE_MEDIA;
-		break;
-	}
-
-	return e;
-}
-
-static int __mm_sound_pcm_capture_msg_cb (int message, void *param, void *user_param)
-{
-	audio_io_interrupted_code_e e = AUDIO_IO_INTERRUPTED_COMPLETED;
-	audio_in_s *handle = (audio_in_s *) user_param;
-	MMMessageParamType *msg = (MMMessageParamType*)param;
-
-	LOGI("[%s] Got message type : 0x%x with code : %d" ,__FUNCTION__, message, msg->code);
-
-	if (handle->user_cb == NULL) {
-		LOGI("[%s] No interrupt callback is set. Skip this" ,__FUNCTION__);
-		return 0;
-	}
-
-	if (message == MM_MESSAGE_SOUND_PCM_INTERRUPTED) {
-		e = __translate_interrupted_code (msg->code);
-	} else if (message == MM_MESSAGE_SOUND_PCM_CAPTURE_RESTRICTED) {
-		/* TODO : handling restricted code is needed */
-		/* e = _translate_restricted_code (msg->code); */
-	}
-
-	handle->user_cb (e, handle->user_data);
-
-	return 0;
-}
-
-static int __mm_sound_pcm_playback_msg_cb (int message, void *param, void *user_param)
-{
-	audio_io_interrupted_code_e e = AUDIO_IO_INTERRUPTED_COMPLETED;
-	audio_out_s *handle = (audio_out_s *) user_param;
-	MMMessageParamType *msg = (MMMessageParamType*)param;
-
-	LOGI("[%s] Got message type : 0x%x with code : %d" ,__FUNCTION__, message, msg->code);
-
-	if (handle->user_cb == NULL) {
-		LOGI("[%s] No interrupt callback is set. Skip this" ,__FUNCTION__);
-		return 0;
-	}
-
-	if (message == MM_MESSAGE_SOUND_PCM_INTERRUPTED) {
-		e = __translate_interrupted_code (msg->code);
-	}
-
-	handle->user_cb (e, handle->user_data);
-
-	return 0;
-}
-
-
-/*
-* 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_ex(sample_rate, channel, type , input, AUDIO_IO_SUPPORT_SOURCE_TYPE_DEFAULT);
-}
-
-/* Audio In */
-int audio_in_create_ex(int sample_rate, audio_channel_e channel, audio_sample_type_e type , audio_in_h* input, audio_io_source_type_e source_type)
-{
-	int ret = 0;
-	audio_in_s *handle = NULL;
-
-	/* input condition check */
-	AUDIO_IO_NULL_ARG_CHECK(input);
-	if(__check_parameter(sample_rate, channel, type) != AUDIO_IO_ERROR_NONE)
-		return AUDIO_IO_ERROR_INVALID_PARAMETER;
-
-	/* Create Handle */
-	handle = (audio_in_s*)malloc( sizeof(audio_in_s));
-	if (handle != NULL) {
-		memset(handle, 0, sizeof(audio_in_s));
-	} else {
-		LOGE("[%s] ERROR :  AUDIO_IO_ERROR_OUT_OF_MEMORY(0x%08x)" ,__FUNCTION__, AUDIO_IO_ERROR_OUT_OF_MEMORY );
-		return AUDIO_IO_ERROR_OUT_OF_MEMORY;
-	}
-
-	ret = mm_sound_pcm_capture_open_ex( &handle->mm_handle,sample_rate, channel, type, source_type);
-	if( ret < 0) {
-		free (handle);
-		return __convert_error_code(ret, (char*)__FUNCTION__);
-	}
-	LOGI("[%s] mm_sound_pcm_capture_open_ex() success",__FUNCTION__);
-
-	/* Fill information */
-	*input = (audio_in_h)handle;
-	handle->_buffer_size= ret;
-	handle->_sample_rate= sample_rate;
-	handle->_channel= channel;
-	handle->_type= type;
-
-	/* Set message interrupt callback */
-	ret = mm_sound_pcm_set_message_callback(handle->mm_handle, __mm_sound_pcm_capture_msg_cb, handle);
-	if( ret < 0) {
-		return __convert_error_code(ret, (char*)__FUNCTION__);
-	}
-	LOGI("[%s] mm_sound_pcm_set_message_callback() success",__FUNCTION__);
-
-	return AUDIO_IO_ERROR_NONE;
-}
-
-int audio_in_destroy(audio_in_h input)
-{
-	AUDIO_IO_NULL_ARG_CHECK(input);
-	audio_in_s *handle = (audio_in_s *) input;
-
-	int ret = mm_sound_pcm_capture_close(handle->mm_handle);
-	if (ret != MM_ERROR_NONE) {
-		return __convert_error_code(ret, (char*)__FUNCTION__);
-	}
-	free(handle);
-
-	LOGI("[%s] mm_sound_pcm_capture_close() success",__FUNCTION__);
-	return AUDIO_IO_ERROR_NONE;
-}
-
-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_sound_pcm_capture_start(handle->mm_handle);
-	if (ret != MM_ERROR_NONE) {
-		return __convert_error_code(ret, (char*)__FUNCTION__);
-	}
-
-	LOGI("[%s] mm_sound_pcm_capture_start() success",__FUNCTION__);
-	return AUDIO_IO_ERROR_NONE;
-}
-
-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_sound_pcm_capture_stop(handle->mm_handle);
-	if (ret != MM_ERROR_NONE) {
-		return __convert_error_code(ret, (char*)__FUNCTION__);
-	}
-
-	LOGI("[%s] mm_sound_pcm_capture_stop() 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;
-
-	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_error_code(ret, (char*)__FUNCTION__);
-			break;
-	}
-	return result;
-}
-
-int audio_in_get_buffer_size(audio_in_h input, int *size)
-{
-	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;
-}
-
-int audio_in_get_sample_rate(audio_in_h input, int *sample_rate)
-{
-	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;
-}
-
-
-int audio_in_get_channel(audio_in_h input, audio_channel_e *channel)
-{
-	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;
-}
-
-int audio_in_get_sample_type(audio_in_h input, audio_sample_type_e *type)
-{
-	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;
-}
-
-int audio_in_get_latency(audio_in_h input, int *latency)
-{
-	AUDIO_IO_NULL_ARG_CHECK(input);
-	AUDIO_IO_NULL_ARG_CHECK(latency);
-	audio_in_s *handle = (audio_in_s *) input;
-
-	int ret = mm_sound_pcm_get_latency(handle->mm_handle, latency);
-	if (ret != MM_ERROR_NONE) {
-		return __convert_error_code(ret, (char*)__FUNCTION__);
-	}
-
-	LOGI("[%s] latency = %d",__FUNCTION__, *latency);
-	return AUDIO_IO_ERROR_NONE;
-}
-
-int audio_in_set_interrupted_cb(audio_in_h input, audio_io_interrupted_cb callback, void *user_data)
-{
-	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;
-}
-
-int audio_in_unset_interrupted_cb(audio_in_h input)
-{
-	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;
-}
-
-int audio_in_ignore_session(audio_in_h input)
-{
-	AUDIO_IO_NULL_ARG_CHECK(input);
-	audio_in_s  * handle = (audio_in_s  *) input;
-	int ret = 0;
-
-	ret = mm_sound_pcm_capture_ignore_session(handle->mm_handle);
-	if (ret != MM_ERROR_NONE) {
-		return __convert_error_code(ret, (char*)__FUNCTION__);
-	}
-
-	LOGI("[%s] mm_sound_pcm_capture_ignore_session() success",__FUNCTION__);
-	return AUDIO_IO_ERROR_NONE;
-}
-
-/* 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)
-{
-	audio_out_s *handle = NULL;
-	int ret = 0;
-
-	/* input condition check */
-	AUDIO_IO_NULL_ARG_CHECK(output);
-	if(__check_parameter(sample_rate, channel, type)!=AUDIO_IO_ERROR_NONE)
-		return AUDIO_IO_ERROR_INVALID_PARAMETER;
-	if(sound_type < SOUND_TYPE_SYSTEM || sound_type > SOUND_TYPE_VOIP) {
-		LOGE("[%s] ERROR :  AUDIO_IO_ERROR_INVALID_PARAMETER(0x%08x) : Invalid sample sound type : %d" ,__FUNCTION__,AUDIO_IO_ERROR_INVALID_PARAMETER,sound_type );
-		return AUDIO_IO_ERROR_INVALID_PARAMETER;
-	}
-	
-	/* Create Handle */
-	handle = (audio_out_s*)malloc( sizeof(audio_out_s));
-	if (handle != NULL) {
-		memset(handle, 0 , sizeof(audio_out_s));
-	} else {
-		LOGE("[%s] ERROR :  AUDIO_IO_ERROR_OUT_OF_MEMORY(0x%08x)" ,__FUNCTION__,AUDIO_IO_ERROR_OUT_OF_MEMORY );
-		return AUDIO_IO_ERROR_OUT_OF_MEMORY;
-	}
-	ret = mm_sound_pcm_play_open(&handle->mm_handle,sample_rate, channel, type, sound_type);
-	if( ret < 0) {
-		free (handle);
-		return __convert_error_code(ret, (char*)__FUNCTION__);
-	}
-	LOGI("[%s] mm_sound_pcm_play_open() success",__FUNCTION__);
-
-	/* Fill information */
-	*output = (audio_out_h)handle;
-	handle->_buffer_size = ret;
-	handle->_sample_rate = sample_rate;
-	handle->_channel = channel;
-	handle->_type = type;
-	handle->_sound_type = sound_type;
-
-	/* Set message interrupt callback */
-	ret = mm_sound_pcm_set_message_callback(handle->mm_handle, __mm_sound_pcm_playback_msg_cb, handle);
-	if( ret < 0) {
-		return __convert_error_code(ret, (char*)__FUNCTION__);
-	}
-	LOGI("[%s] mm_sound_pcm_set_message_callback() success",__FUNCTION__);
-
-	return AUDIO_IO_ERROR_NONE;
-}
-
-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_sound_pcm_play_close(handle->mm_handle);
-	if (ret != MM_ERROR_NONE) {
-		return __convert_error_code(ret, (char*)__FUNCTION__);
-	}
-	free(handle);
-
-	LOGI("[%s] mm_sound_pcm_play_close() success",__FUNCTION__);
-	return AUDIO_IO_ERROR_NONE;
-}
-
-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_sound_pcm_play_start(handle->mm_handle);
-	if (ret != MM_ERROR_NONE) {
-		return __convert_error_code(ret, (char*)__FUNCTION__);
-	}
-
-	LOGI("[%s] mm_sound_pcm_play_start() success",__FUNCTION__);
-	return AUDIO_IO_ERROR_NONE;
-}
-
-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_sound_pcm_play_stop(handle->mm_handle);
-	if (ret != MM_ERROR_NONE) {
-		return __convert_error_code(ret, (char*)__FUNCTION__);
-	}
-
-	LOGI("[%s] mm_sound_pcm_play_stop() success",__FUNCTION__);
-	return AUDIO_IO_ERROR_NONE;
-}
-
-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_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_error_code(ret, (char*)__FUNCTION__);
-			break;
-	}
-	return ret;
-}
-
-
-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;
-}
-
-
-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;
-}
-
-
-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;
-}
-
-
-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;
-}
-
-int audio_out_get_latency(audio_out_h output, int *latency)
-{
-	AUDIO_IO_NULL_ARG_CHECK(output);
-	AUDIO_IO_NULL_ARG_CHECK(latency);
-	audio_out_s *handle = (audio_out_s *) output;
-
-	int ret = mm_sound_pcm_get_latency(handle->mm_handle, latency);
-	if (ret != MM_ERROR_NONE) {
-		return __convert_error_code(ret, (char*)__FUNCTION__);
-	}
-
-	LOGI("[%s] latency = %d",__FUNCTION__, *latency);
-	return AUDIO_IO_ERROR_NONE;
-}
-
-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;
-}
-
-int audio_out_set_interrupted_cb(audio_out_h output, audio_io_interrupted_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;
-}
-
-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)
-{
-	AUDIO_IO_NULL_ARG_CHECK(output);
-	audio_out_s *handle = (audio_out_s *) output;
-	int ret = 0;
-
-	ret = mm_sound_pcm_play_ignore_session(handle->mm_handle);
-	if (ret != MM_ERROR_NONE) {
-		return __convert_error_code(ret, (char*)__FUNCTION__);
-	}
-	LOGI("[%s] mm_sound_pcm_play_ignore_session() success",__FUNCTION__);
-
-	return AUDIO_IO_ERROR_NONE;
-}
diff --git a/wearable/test/CMakeLists.txt b/wearable/test/CMakeLists.txt
deleted file mode 100644
index 795370d..0000000
--- a/wearable/test/CMakeLists.txt
+++ /dev/null
@@ -1,18 +0,0 @@
-
-SET(fw_test "${fw_name}-test")
-
-INCLUDE(FindPkgConfig)
-FOREACH(flag ${${fw_test}_CFLAGS})
-    SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
-ENDFOREACH(flag)
-
-SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -Wall -Werror")
-
-aux_source_directory(. sources)
-FOREACH(src ${sources})
-    GET_FILENAME_COMPONENT(src_name ${src} NAME_WE)
-    MESSAGE("${src_name}")
-    ADD_EXECUTABLE(${src_name} ${src})
-    TARGET_LINK_LIBRARIES(${src_name} ${fw_name} ${${fw_test}_LDFLAGS})
-ENDFOREACH()
-
diff --git a/wearable/test/audio_io_test.c b/wearable/test/audio_io_test.c
deleted file mode 100644
index 32e4544..0000000
--- a/wearable/test/audio_io_test.c
+++ /dev/null
@@ -1,150 +0,0 @@
-/*
-* Copyright (c) 2011 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.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License. 
-*/
- 
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <audio_io.h>
-
-static int ch_table[3] = { 0, AUDIO_CHANNEL_MONO, AUDIO_CHANNEL_STEREO };
-
-void play_file(char *file, int length, int ch)
-{
-	audio_out_h output;
-	FILE* fp = fopen (file, "r");
-
-	char * buf = malloc (length);
-
-	printf ("start to play [%s][%d][%d]\n", file, length, ch);
-	audio_out_create(44100, ch_table[ch] ,AUDIO_SAMPLE_TYPE_S16_LE, SOUND_TYPE_MEDIA, &output);
-	if (fread (buf, 1, length, fp) != length) {
-		printf ("error!!!!\n");
-	}
-
-	audio_out_prepare(output);
-	audio_out_write(output, buf, length);
-	audio_out_unprepare(output);
-
-	audio_out_destroy (output);
-
-	fclose (fp);
-
-	printf ("play done\n");
-}
-
-#define DUMP_FILE "/root/test.raw"
-
-int audio_io_test(int length, int num, int ch)
-{
-	int ret, size, i;
-	audio_in_h input;
-	if ((ret = audio_in_create(44100, ch_table[ch] ,AUDIO_SAMPLE_TYPE_S16_LE, &input)) == AUDIO_IO_ERROR_NONE) {
-		ret = audio_in_ignore_session(input);
-		if (ret != 0) {
-			printf ("ERROR, set session mix\n");
-			audio_in_destroy(input);
-			return 0;
-		}
-
-		ret = audio_in_prepare(input);
-		if (ret != 0) {
-			printf ("ERROR, prepare\n");
-			audio_in_destroy(input);
-			return 0;
-		}
-
-		FILE* fp = fopen (DUMP_FILE, "wb+");
-
-		if ((ret = audio_in_get_buffer_size(input, &size)) == AUDIO_IO_ERROR_NONE) {
-			size = length;
-			char *buffer = alloca(size);
-
-			for (i=0; i<num; i++) {
-				printf ("### loop = %d ============== \n", i);
-				if ((ret = audio_in_read(input, (void*)buffer, size)) > AUDIO_IO_ERROR_NONE) {
-					fwrite (buffer, size, sizeof(char), fp);
-					printf ("PASS, size=%d, ret=%d\n", size, ret);
-				}
-				else {
-					printf ("FAIL, size=%d, ret=%d\n", size, ret);
-				}
-			}
-		}
-
-		fclose (fp);
-
-		audio_in_destroy(input);
-	}
-
-	play_file (DUMP_FILE, length*num, ch);
-
-	return 1;
-}
-
-int audio_io_test_ex()
-{
-	int ret, size;
-	audio_in_h input;
-	if ((ret = audio_in_create_ex(44100, AUDIO_CHANNEL_STEREO , AUDIO_SAMPLE_TYPE_S16_LE, &input, 1)) == AUDIO_IO_ERROR_NONE) {
-		ret = audio_in_ignore_session(input);
-		if (ret != 0) {
-			printf ("ERROR, set session mix\n");
-			audio_in_destroy(input);
-			return 0;
-		}
-
-		ret = audio_in_prepare(input);
-		if (ret != 0) {
-			printf ("ERROR, prepare\n");
-			audio_in_destroy(input);
-			return 0;
-		}
-
-		if ((ret = audio_in_get_buffer_size(input, &size)) == AUDIO_IO_ERROR_NONE) {
-			size = 500000;
-			char *buffer = alloca(size);
-			if ((ret = audio_in_read(input, (void*)buffer, size)) > AUDIO_IO_ERROR_NONE) {
-				FILE* fp = fopen ("/root/test.raw", "wb+");
-				fwrite (buffer, size, sizeof(char), fp);
-				fclose (fp);
-				printf ("PASS, size=%d, ret=%d\n", size, ret);
-			}
-			else {
-				printf ("FAIL, size=%d, ret=%d\n", size, ret);
-			}
-		}
-		audio_in_destroy(input);
-	}
-
-	return 1;
-}
-
-int main(int argc, char ** argv)
-{
-	if((argc == 2)&&(!strcmp(argv[1], "mirroring"))) {
-		audio_io_test_ex();
-	} else if (argc == 4) {
-		printf ("run with [%s][%s][%s]\n", argv[1],argv[2],argv[3]);
-#if 0
-		audio_io_test(atoi (argv[1]), atoi (argv[2]), atoi(argv[3]));
-#endif
-	} else {
-		printf ("1. usage : audio_io_test [length to read] [number of iteration] [channels]\n");
-		printf ("2. usage : audio_io_test mirroring\n");
-	}
-	return 0;
-}
-