2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
21 #include <audio_io_private.h>
27 #define LOG_TAG "TIZEN_N_AUDIO_IO"
28 /* TODO : it will be added after updating libmm-sound */
29 //#include <mm_sound_pcm_async.h>
31 * Internal Implementation
36 * Public Implementation
40 int audio_in_create(int sample_rate, audio_channel_e channel, audio_sample_type_e type , audio_in_h* input)
42 return audio_in_create_private (sample_rate, channel, type, input);
45 int audio_in_create_loopback(int sample_rate, audio_channel_e channel, audio_sample_type_e type, audio_in_h* input)
47 return audio_in_create_private (sample_rate, channel, type, input);
50 int audio_in_destroy(audio_in_h input)
52 AUDIO_IO_NULL_ARG_CHECK(input);
53 audio_in_s *handle = (audio_in_s *) input;
54 int ret = MM_ERROR_NONE;
56 ret = mm_sound_pcm_capture_close(handle->mm_handle);
57 if (ret != MM_ERROR_NONE) {
59 return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
63 LOGI("[%s] mm_sound_pcm_capture_close() success",__FUNCTION__);
64 return AUDIO_IO_ERROR_NONE;
67 int audio_in_prepare(audio_in_h input)
69 AUDIO_IO_NULL_ARG_CHECK(input);
70 audio_in_s *handle = (audio_in_s *) input;
71 int ret = MM_ERROR_NONE;
73 ret = mm_sound_pcm_capture_start(handle->mm_handle);
74 if (ret != MM_ERROR_NONE) {
75 return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
78 LOGI("[%s] mm_sound_pcm_capture_start() success",__FUNCTION__);
79 return AUDIO_IO_ERROR_NONE;
82 int audio_in_unprepare(audio_in_h input)
84 AUDIO_IO_NULL_ARG_CHECK(input);
85 audio_in_s *handle = (audio_in_s *) input;
86 int ret = MM_ERROR_NONE;
88 ret = mm_sound_pcm_capture_stop(handle->mm_handle);
89 if (ret != MM_ERROR_NONE) {
90 return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
93 LOGI("[%s] mm_sound_pcm_capture_stop() success",__FUNCTION__);
94 return AUDIO_IO_ERROR_NONE;
97 int audio_in_flush(audio_in_h input)
99 AUDIO_IO_NULL_ARG_CHECK(input);
100 audio_in_s *handle = (audio_in_s *) input;
101 int ret = MM_ERROR_NONE;
103 ret = mm_sound_pcm_capture_flush(handle->mm_handle);
104 if (ret != MM_ERROR_NONE) {
105 return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
108 LOGI("[%s] mm_sound_pcm_capture_flush() success",__FUNCTION__);
109 return AUDIO_IO_ERROR_NONE;
112 int audio_in_read(audio_in_h input, void *buffer, unsigned int length )
114 AUDIO_IO_NULL_ARG_CHECK(input);
115 AUDIO_IO_NULL_ARG_CHECK(buffer);
116 audio_in_s *handle = (audio_in_s *) input;
120 ret = mm_sound_pcm_capture_read(handle->mm_handle, (void*) buffer, length);
126 case MM_ERROR_SOUND_INVALID_STATE:
127 result = AUDIO_IO_ERROR_INVALID_OPERATION;
128 LOGE("[%s] (0x%08x) : Not recording started yet.",(char*)__FUNCTION__, AUDIO_IO_ERROR_INVALID_OPERATION);
131 result = __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
137 int audio_in_get_buffer_size(audio_in_h input, int *size)
139 AUDIO_IO_NULL_ARG_CHECK(input);
140 AUDIO_IO_NULL_ARG_CHECK(size);
141 audio_in_s *handle = (audio_in_s *) input;
143 *size = handle->_buffer_size;
145 LOGI("[%s] buffer size = %d",__FUNCTION__, *size);
146 return AUDIO_IO_ERROR_NONE;
149 int audio_in_get_sample_rate(audio_in_h input, int *sample_rate)
151 AUDIO_IO_NULL_ARG_CHECK(input);
152 AUDIO_IO_NULL_ARG_CHECK(sample_rate);
153 audio_in_s *handle = (audio_in_s *) input;
155 *sample_rate = handle->_sample_rate;
157 LOGI("[%s] sample rate = %d",__FUNCTION__, *sample_rate);
158 return AUDIO_IO_ERROR_NONE;
162 int audio_in_get_channel(audio_in_h input, audio_channel_e *channel)
164 AUDIO_IO_NULL_ARG_CHECK(input);
165 AUDIO_IO_NULL_ARG_CHECK(channel);
166 audio_in_s *handle = (audio_in_s *) input;
168 *channel = handle->_channel;
170 LOGI("[%s] channel = %d",__FUNCTION__, *channel);
171 return AUDIO_IO_ERROR_NONE;
174 int audio_in_get_sample_type(audio_in_h input, audio_sample_type_e *type)
176 AUDIO_IO_NULL_ARG_CHECK(input);
177 AUDIO_IO_NULL_ARG_CHECK(type);
178 audio_in_s *handle = (audio_in_s *) input;
180 *type = handle->_type;
182 LOGI("[%s] sample type = %d",__FUNCTION__, *type);
183 return AUDIO_IO_ERROR_NONE;
186 int audio_in_set_interrupted_cb(audio_in_h input, audio_io_interrupted_cb callback, void *user_data)
188 AUDIO_IO_NULL_ARG_CHECK(input);
189 AUDIO_IO_NULL_ARG_CHECK(callback);
190 audio_in_s *handle = (audio_in_s *) input;
192 handle->user_cb = callback;
193 handle->user_data = user_data;
195 LOGI("[%s] current interrupted cb (%p) / data (%p)",__FUNCTION__, handle->user_cb, handle->user_data);
196 return AUDIO_IO_ERROR_NONE;
199 int audio_in_unset_interrupted_cb(audio_in_h input)
201 AUDIO_IO_NULL_ARG_CHECK(input);
202 audio_in_s * handle = (audio_in_s *) input;
204 handle->user_cb = NULL;
205 handle->user_data = NULL;
207 LOGI("[%s] current interrupted cb (%p) / data (%p)",__FUNCTION__, handle->user_cb, handle->user_data);
208 return AUDIO_IO_ERROR_NONE;
211 int audio_in_ignore_session(audio_in_h input)
213 AUDIO_IO_NULL_ARG_CHECK(input);
214 audio_in_s * handle = (audio_in_s *) input;
217 ret = mm_sound_pcm_capture_ignore_session(handle->mm_handle);
218 if (ret != MM_ERROR_NONE) {
219 return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
222 LOGI("[%s] mm_sound_pcm_capture_ignore_session() success",__FUNCTION__);
223 return AUDIO_IO_ERROR_NONE;
226 int audio_in_set_stream_cb(audio_in_h input, audio_in_stream_cb callback, void* userdata)
228 /* TODO : it will be added after updating libmm-sound */
229 return AUDIO_IO_ERROR_NONE;
232 int audio_in_unset_stream_cb(audio_in_h input)
234 /* TODO : it will be added after updating libmm-sound */
235 return AUDIO_IO_ERROR_NONE;
238 int audio_in_peek(audio_in_h input, const void **buffer, unsigned int *length)
240 /* TODO : it will be added after updating libmm-sound */
241 return AUDIO_IO_ERROR_NONE;
244 int audio_in_drop(audio_in_h input)
246 /* TODO : it will be added after updating libmm-sound */
247 return AUDIO_IO_ERROR_NONE;
252 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)
254 return audio_out_create_private(sample_rate, channel, type, sound_type, output);
257 int audio_out_destroy(audio_out_h output)
259 AUDIO_IO_NULL_ARG_CHECK(output);
260 audio_out_s *handle = (audio_out_s *) output;
261 int ret = MM_ERROR_NONE;
263 ret = mm_sound_pcm_play_close(handle->mm_handle);
264 if (ret != MM_ERROR_NONE) {
266 return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
270 LOGI("[%s] mm_sound_pcm_play_close() success",__FUNCTION__);
271 return AUDIO_IO_ERROR_NONE;
274 int audio_out_prepare(audio_out_h output)
276 AUDIO_IO_NULL_ARG_CHECK(output);
277 audio_out_s *handle = (audio_out_s *) output;
278 int ret = MM_ERROR_NONE;
280 ret = mm_sound_pcm_play_start(handle->mm_handle);
281 if (ret != MM_ERROR_NONE) {
282 return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
285 LOGI("[%s] mm_sound_pcm_play_start() success",__FUNCTION__);
286 return AUDIO_IO_ERROR_NONE;
289 int audio_out_unprepare(audio_out_h output)
291 AUDIO_IO_NULL_ARG_CHECK(output);
292 audio_out_s *handle = (audio_out_s *) output;
293 int ret = MM_ERROR_NONE;
295 ret = mm_sound_pcm_play_stop(handle->mm_handle);
296 if (ret != MM_ERROR_NONE) {
297 return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
300 LOGI("[%s] mm_sound_pcm_play_stop() success",__FUNCTION__);
301 return AUDIO_IO_ERROR_NONE;
304 int audio_out_drain(audio_out_h output)
306 AUDIO_IO_NULL_ARG_CHECK(output);
307 audio_out_s *handle = (audio_out_s *) output;
308 int ret = MM_ERROR_NONE;
310 ret = mm_sound_pcm_play_drain(handle->mm_handle);
311 if (ret != MM_ERROR_NONE) {
312 return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
315 LOGI("[%s] mm_sound_pcm_play_drain() success",__FUNCTION__);
316 return AUDIO_IO_ERROR_NONE;
319 int audio_out_flush(audio_out_h output)
321 AUDIO_IO_NULL_ARG_CHECK(output);
322 audio_out_s *handle = (audio_out_s *) output;
323 int ret = MM_ERROR_NONE;
325 ret = mm_sound_pcm_play_flush(handle->mm_handle);
326 if (ret != MM_ERROR_NONE) {
327 return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
330 LOGI("[%s] mm_sound_pcm_play_flush() success",__FUNCTION__);
331 return AUDIO_IO_ERROR_NONE;
334 int audio_out_write(audio_out_h output, void* buffer, unsigned int length)
336 AUDIO_IO_NULL_ARG_CHECK(output);
337 AUDIO_IO_NULL_ARG_CHECK(buffer);
338 audio_out_s *handle = (audio_out_s *) output;
339 int ret = MM_ERROR_NONE;
341 ret = mm_sound_pcm_play_write(handle->mm_handle, (void*) buffer, length);
343 LOGI("[%s] (%d/%d) bytes written" ,__FUNCTION__, ret, length);
348 case MM_ERROR_SOUND_INVALID_STATE:
349 ret = AUDIO_IO_ERROR_INVALID_OPERATION;
350 LOGE("[%s] (0x%08x) : Not playing started yet.",(char*)__FUNCTION__, AUDIO_IO_ERROR_INVALID_OPERATION);
353 ret = __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
360 int audio_out_get_buffer_size(audio_out_h output, int *size)
362 AUDIO_IO_NULL_ARG_CHECK(output);
363 AUDIO_IO_NULL_ARG_CHECK(size);
364 audio_out_s *handle = (audio_out_s *) output;
366 *size = handle->_buffer_size;
368 LOGI("[%s] buffer size = %d",__FUNCTION__, *size);
369 return AUDIO_IO_ERROR_NONE;
373 int audio_out_get_sample_rate(audio_out_h output, int *sample_rate)
375 AUDIO_IO_NULL_ARG_CHECK(output);
376 AUDIO_IO_NULL_ARG_CHECK(sample_rate);
377 audio_out_s *handle = (audio_out_s *) output;
379 *sample_rate = handle->_sample_rate;
381 LOGI("[%s] sample rate = %d",__FUNCTION__, *sample_rate);
382 return AUDIO_IO_ERROR_NONE;
386 int audio_out_get_channel(audio_out_h output, audio_channel_e *channel)
388 AUDIO_IO_NULL_ARG_CHECK(output);
389 AUDIO_IO_NULL_ARG_CHECK(channel);
390 audio_out_s *handle = (audio_out_s *) output;
392 *channel = handle->_channel;
394 LOGI("[%s] channel = %d",__FUNCTION__, *channel);
395 return AUDIO_IO_ERROR_NONE;
399 int audio_out_get_sample_type(audio_out_h output, audio_sample_type_e *type)
401 AUDIO_IO_NULL_ARG_CHECK(output);
402 AUDIO_IO_NULL_ARG_CHECK(type);
403 audio_out_s *handle = (audio_out_s *) output;
405 *type = handle->_type;
407 LOGI("[%s] sample type = %d",__FUNCTION__, *type);
408 return AUDIO_IO_ERROR_NONE;
412 int audio_out_get_sound_type(audio_out_h output, sound_type_e *type)
414 AUDIO_IO_NULL_ARG_CHECK(output);
415 AUDIO_IO_NULL_ARG_CHECK(type);
416 audio_out_s *handle = (audio_out_s *) output;
418 *type = handle->_sound_type;
420 LOGI("[%s] sound type = %d",__FUNCTION__, *type);
421 return AUDIO_IO_ERROR_NONE;
424 int audio_out_set_interrupted_cb(audio_out_h output, audio_io_interrupted_cb callback, void *user_data)
426 AUDIO_IO_NULL_ARG_CHECK(output);
427 AUDIO_IO_NULL_ARG_CHECK(callback);
428 audio_out_s *handle = (audio_out_s *) output;
430 handle->user_cb = callback;
431 handle->user_data = user_data;
433 LOGI("[%s] current interrupted cb (%p) / data (%p)",__FUNCTION__, handle->user_cb, handle->user_data);
434 return AUDIO_IO_ERROR_NONE;
437 int audio_out_unset_interrupted_cb(audio_out_h output)
439 AUDIO_IO_NULL_ARG_CHECK(output);
440 audio_out_s *handle = (audio_out_s *) output;
442 handle->user_cb = NULL;
443 handle->user_data = NULL;
445 LOGI("[%s] current interrupted cb (%p) / data (%p)",__FUNCTION__, handle->user_cb, handle->user_data);
446 return AUDIO_IO_ERROR_NONE;
449 int audio_out_ignore_session(audio_out_h output)
451 AUDIO_IO_NULL_ARG_CHECK(output);
452 audio_out_s *handle = (audio_out_s *) output;
455 ret = mm_sound_pcm_play_ignore_session(handle->mm_handle);
456 if (ret != MM_ERROR_NONE) {
457 return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
459 LOGI("[%s] mm_sound_pcm_play_ignore_session() success",__FUNCTION__);
461 return AUDIO_IO_ERROR_NONE;
464 int audio_out_set_stream_cb(audio_out_h output, audio_out_stream_cb callback, void* userdata)
466 /* TODO : it will be added after updating libmm-sound */
467 return AUDIO_IO_ERROR_NONE;
470 int audio_out_unset_stream_cb(audio_out_h output)
472 /* TODO : it will be added after updating libmm-sound */
473 return AUDIO_IO_ERROR_NONE;