From: jk7744.park Date: Sun, 1 Feb 2015 04:29:16 +0000 (+0900) Subject: tizen 2.3 release X-Git-Tag: submit/tizen_2.3/20150202.060724^0 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fheads%2Ftizen_2.3;p=framework%2Fapi%2Faudio-io.git tizen 2.3 release --- diff --git a/wearable/AUTHORS b/AUTHORS similarity index 100% rename from wearable/AUTHORS rename to AUTHORS diff --git a/wearable/CMakeLists.txt b/CMakeLists.txt similarity index 96% rename from wearable/CMakeLists.txt rename to 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 similarity index 100% rename from wearable/LICENSE rename to LICENSE diff --git a/wearable/capi-media-audio-io.manifest b/capi-media-audio-io.manifest similarity index 100% rename from wearable/capi-media-audio-io.manifest rename to capi-media-audio-io.manifest diff --git a/wearable/capi-media-audio-io.pc.in b/capi-media-audio-io.pc.in similarity index 100% rename from wearable/capi-media-audio-io.pc.in rename to capi-media-audio-io.pc.in diff --git a/wearable/doc/audio_io_doc.h b/doc/audio_io_doc.h similarity index 55% rename from wearable/doc/audio_io_doc.h rename to 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 * * @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 * - * @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 Feature Element. * */ /** + * @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 * - * @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 +#include +#include + +#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 +#include +#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 -Seungkeun Lee -Seungbae Shin 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.manifest b/mobile/capi-media-audio-io.manifest deleted file mode 100644 index a76fdba..0000000 --- a/mobile/capi-media-audio-io.manifest +++ /dev/null @@ -1,5 +0,0 @@ - - - - - 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 -#include - -#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, /** -#include -#include - -#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/CMakeLists.txt b/mobile/test/CMakeLists.txt deleted file mode 100644 index 795370d..0000000 --- a/mobile/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/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 -#include -#include -#include - -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 Binary files a/packaging/capi-media-audio-io-0.2.0.tar.gz and /dev/null differ 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 similarity index 50% rename from mobile/src/audio_io.c rename to src/audio_io.c index 76304d9..ebdbdcd 100644 --- a/mobile/src/audio_io.c +++ b/src/audio_io.c @@ -18,8 +18,7 @@ #include #include #include -#include -#include +#include "audio_io_private.h" #include #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 /* * 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 +#include +#include +#include +#include "audio_io_private.h" +#include + +#include + + +#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/wearable/test/CMakeLists.txt b/test/CMakeLists.txt similarity index 100% rename from wearable/test/CMakeLists.txt rename to 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 +#include +#include +#include +#include + +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 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 "); + } + 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 Binary files a/wearable/TC/media_samsung.mp3 and /dev/null differ 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 -#include - -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 -#include - -#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/debian/README b/wearable/debian/README deleted file mode 100644 index e69de29..0000000 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 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 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 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 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 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 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 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 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 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 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 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 , Seungkeun Lee -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 -#include - -#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, /** -#include -#include - -#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 -#include -#include -#include -#include -#include - -#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/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 -#include -#include -#include - -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 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; -} -