src/audio_io.c

   1 /*
   2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   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
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  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.
  15 */
  16
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <mm.h>
  21 #include <audio_io_private.h>
  22 #include <dlog.h>
  23
  24 #ifdef LOG_TAG
  25 #undef LOG_TAG
  26 #endif
  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>
  30 /*
  31 * Internal Implementation
  32 */
  33
  34
  35 /*
  36 * Public Implementation
  37 */
  38
  39 /* Audio In */
  40 int audio_in_create(int sample_rate, audio_channel_e channel, audio_sample_type_e type , audio_in_h* input)
  41 {
  42         return audio_in_create_private (sample_rate, channel, type, input);
  43 }
  44
  45 int audio_in_create_loopback(int sample_rate, audio_channel_e channel, audio_sample_type_e type, audio_in_h* input)
  46 {
  47         return audio_in_create_private (sample_rate, channel, type, input);
  48 }
  49
  50 int audio_in_destroy(audio_in_h input)
  51 {
  52         AUDIO_IO_NULL_ARG_CHECK(input);
  53         audio_in_s *handle = (audio_in_s *) input;
  54         int ret = MM_ERROR_NONE;
  55
  56         ret = mm_sound_pcm_capture_close(handle->mm_handle);
  57         if (ret != MM_ERROR_NONE) {
  58                 free(handle);
  59                 return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
  60         }
  61         free(handle);
  62
  63         LOGI("[%s] mm_sound_pcm_capture_close() success",__FUNCTION__);
  64         return AUDIO_IO_ERROR_NONE;
  65 }
  66
  67 int audio_in_prepare(audio_in_h input)
  68 {
  69         AUDIO_IO_NULL_ARG_CHECK(input);
  70         audio_in_s *handle = (audio_in_s *) input;
  71         int ret = MM_ERROR_NONE;
  72
  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__);
  76         }
  77
  78         LOGI("[%s] mm_sound_pcm_capture_start() success",__FUNCTION__);
  79         return AUDIO_IO_ERROR_NONE;
  80 }
  81
  82 int audio_in_unprepare(audio_in_h input)
  83 {
  84         AUDIO_IO_NULL_ARG_CHECK(input);
  85         audio_in_s *handle = (audio_in_s *) input;
  86         int ret = MM_ERROR_NONE;
  87
  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__);
  91         }
  92
  93         LOGI("[%s] mm_sound_pcm_capture_stop() success",__FUNCTION__);
  94         return AUDIO_IO_ERROR_NONE;
  95 }
  96
  97 int audio_in_read(audio_in_h input, void *buffer, unsigned int length )
  98 {
  99         AUDIO_IO_NULL_ARG_CHECK(input);
 100         AUDIO_IO_NULL_ARG_CHECK(buffer);
 101         audio_in_s *handle = (audio_in_s *) input;
 102         int ret = 0;
 103         int result = 0;
 104
 105         ret = mm_sound_pcm_capture_read(handle->mm_handle, (void*) buffer, length);
 106         if (ret > 0)
 107                 return ret;
 108
 109         switch(ret)
 110         {
 111                 case MM_ERROR_SOUND_INVALID_STATE:
 112                         result = AUDIO_IO_ERROR_INVALID_OPERATION;
 113                         LOGE("[%s] (0x%08x) : Not recording started yet.",(char*)__FUNCTION__, AUDIO_IO_ERROR_INVALID_OPERATION);
 114                         break;
 115                 default:
 116                         result = __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
 117                         break;
 118         }
 119         return result;
 120 }
 121
 122 int audio_in_get_buffer_size(audio_in_h input, int *size)
 123 {
 124         AUDIO_IO_NULL_ARG_CHECK(input);
 125         AUDIO_IO_NULL_ARG_CHECK(size);
 126         audio_in_s *handle = (audio_in_s *) input;
 127
 128         *size = handle->_buffer_size;
 129
 130         LOGI("[%s] buffer size = %d",__FUNCTION__, *size);
 131         return AUDIO_IO_ERROR_NONE;
 132 }
 133
 134 int audio_in_get_sample_rate(audio_in_h input, int *sample_rate)
 135 {
 136         AUDIO_IO_NULL_ARG_CHECK(input);
 137         AUDIO_IO_NULL_ARG_CHECK(sample_rate);
 138         audio_in_s *handle = (audio_in_s *) input;
 139
 140         *sample_rate = handle->_sample_rate;
 141
 142         LOGI("[%s] sample rate = %d",__FUNCTION__, *sample_rate);
 143         return AUDIO_IO_ERROR_NONE;
 144 }
 145
 146
 147 int audio_in_get_channel(audio_in_h input, audio_channel_e *channel)
 148 {
 149         AUDIO_IO_NULL_ARG_CHECK(input);
 150         AUDIO_IO_NULL_ARG_CHECK(channel);
 151         audio_in_s *handle = (audio_in_s *) input;
 152
 153         *channel = handle->_channel;
 154
 155         LOGI("[%s] channel = %d",__FUNCTION__, *channel);
 156         return AUDIO_IO_ERROR_NONE;
 157 }
 158
 159 int audio_in_get_sample_type(audio_in_h input, audio_sample_type_e *type)
 160 {
 161         AUDIO_IO_NULL_ARG_CHECK(input);
 162         AUDIO_IO_NULL_ARG_CHECK(type);
 163         audio_in_s *handle = (audio_in_s *) input;
 164
 165         *type = handle->_type;
 166
 167         LOGI("[%s] sample type = %d",__FUNCTION__, *type);
 168         return AUDIO_IO_ERROR_NONE;
 169 }
 170
 171 int audio_in_set_interrupted_cb(audio_in_h input, audio_io_interrupted_cb callback, void *user_data)
 172 {
 173         AUDIO_IO_NULL_ARG_CHECK(input);
 174         AUDIO_IO_NULL_ARG_CHECK(callback);
 175         audio_in_s *handle = (audio_in_s *) input;
 176
 177         handle->user_cb = callback;
 178         handle->user_data = user_data;
 179
 180         LOGI("[%s] current interrupted cb (%p) / data (%p)",__FUNCTION__, handle->user_cb, handle->user_data);
 181         return AUDIO_IO_ERROR_NONE;
 182 }
 183
 184 int audio_in_unset_interrupted_cb(audio_in_h input)
 185 {
 186         AUDIO_IO_NULL_ARG_CHECK(input);
 187         audio_in_s  * handle = (audio_in_s  *) input;
 188
 189         handle->user_cb = NULL;
 190         handle->user_data = NULL;
 191
 192         LOGI("[%s] current interrupted cb (%p) / data (%p)",__FUNCTION__, handle->user_cb, handle->user_data);
 193         return AUDIO_IO_ERROR_NONE;
 194 }
 195
 196 int audio_in_ignore_session(audio_in_h input)
 197 {
 198         AUDIO_IO_NULL_ARG_CHECK(input);
 199         audio_in_s  * handle = (audio_in_s  *) input;
 200         int ret = 0;
 201
 202         ret = mm_sound_pcm_capture_ignore_session(handle->mm_handle);
 203         if (ret != MM_ERROR_NONE) {
 204                 return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
 205         }
 206
 207         LOGI("[%s] mm_sound_pcm_capture_ignore_session() success",__FUNCTION__);
 208         return AUDIO_IO_ERROR_NONE;
 209 }
 210
 211 int audio_in_set_stream_cb(audio_in_h input, audio_in_stream_cb callback, void* userdata)
 212 {
 213 /* TODO : it will be added after updating libmm-sound */
 214         return AUDIO_IO_ERROR_NONE;
 215 }
 216
 217 int audio_in_unset_stream_cb(audio_in_h input)
 218 {
 219 /* TODO : it will be added after updating libmm-sound */
 220         return AUDIO_IO_ERROR_NONE;
 221 }
 222
 223 int audio_in_peek(audio_in_h input, const void **buffer, unsigned int *length)
 224 {
 225 /* TODO : it will be added after updating libmm-sound */
 226         return AUDIO_IO_ERROR_NONE;
 227 }
 228
 229 int audio_in_drop(audio_in_h input)
 230 {
 231 /* TODO : it will be added after updating libmm-sound */
 232         return AUDIO_IO_ERROR_NONE;
 233 }
 234
 235
 236 /* Audio Out */
 237 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)
 238 {
 239         return audio_out_create_private(sample_rate, channel, type, sound_type, output);
 240 }
 241
 242 int audio_out_destroy(audio_out_h output)
 243 {
 244         AUDIO_IO_NULL_ARG_CHECK(output);
 245         audio_out_s *handle = (audio_out_s *) output;
 246         int ret = MM_ERROR_NONE;
 247
 248         ret = mm_sound_pcm_play_close(handle->mm_handle);
 249         if (ret != MM_ERROR_NONE) {
 250                 free(handle);
 251                 return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
 252         }
 253         free(handle);
 254
 255         LOGI("[%s] mm_sound_pcm_play_close() success",__FUNCTION__);
 256         return AUDIO_IO_ERROR_NONE;
 257 }
 258
 259 int audio_out_prepare(audio_out_h output)
 260 {
 261         AUDIO_IO_NULL_ARG_CHECK(output);
 262         audio_out_s *handle = (audio_out_s *) output;
 263         int ret = MM_ERROR_NONE;
 264
 265         ret = mm_sound_pcm_play_start(handle->mm_handle);
 266         if (ret != MM_ERROR_NONE) {
 267                 return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
 268         }
 269
 270         LOGI("[%s] mm_sound_pcm_play_start() success",__FUNCTION__);
 271         return AUDIO_IO_ERROR_NONE;
 272 }
 273
 274 int audio_out_unprepare(audio_out_h output)
 275 {
 276         AUDIO_IO_NULL_ARG_CHECK(output);
 277         audio_out_s *handle = (audio_out_s *) output;
 278         int ret = MM_ERROR_NONE;
 279
 280         ret = mm_sound_pcm_play_stop(handle->mm_handle);
 281         if (ret != MM_ERROR_NONE) {
 282                 return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
 283         }
 284
 285         LOGI("[%s] mm_sound_pcm_play_stop() success",__FUNCTION__);
 286         return AUDIO_IO_ERROR_NONE;
 287 }
 288
 289 int audio_out_write(audio_out_h output, void* buffer, unsigned int length)
 290 {
 291         AUDIO_IO_NULL_ARG_CHECK(output);
 292         AUDIO_IO_NULL_ARG_CHECK(buffer);
 293         audio_out_s *handle = (audio_out_s *) output;
 294         int ret = MM_ERROR_NONE;
 295
 296         ret = mm_sound_pcm_play_write(handle->mm_handle, (void*) buffer, length);
 297         if (ret > 0) {
 298                 LOGI("[%s] (%d/%d) bytes written" ,__FUNCTION__, ret, length);
 299                 return ret;
 300         }
 301         switch(ret)
 302         {
 303                 case MM_ERROR_SOUND_INVALID_STATE:
 304                         ret = AUDIO_IO_ERROR_INVALID_OPERATION;
 305                         LOGE("[%s] (0x%08x) : Not playing started yet.",(char*)__FUNCTION__, AUDIO_IO_ERROR_INVALID_OPERATION);
 306                         break;
 307                 default:
 308                         ret = __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
 309                         break;
 310         }
 311         return ret;
 312 }
 313
 314
 315 int audio_out_get_buffer_size(audio_out_h output, int *size)
 316 {
 317         AUDIO_IO_NULL_ARG_CHECK(output);
 318         AUDIO_IO_NULL_ARG_CHECK(size);
 319         audio_out_s *handle = (audio_out_s *) output;
 320
 321         *size = handle->_buffer_size;
 322
 323         LOGI("[%s] buffer size = %d",__FUNCTION__, *size);
 324         return AUDIO_IO_ERROR_NONE;
 325 }
 326
 327
 328 int audio_out_get_sample_rate(audio_out_h output, int *sample_rate)
 329 {
 330         AUDIO_IO_NULL_ARG_CHECK(output);
 331         AUDIO_IO_NULL_ARG_CHECK(sample_rate);
 332         audio_out_s *handle = (audio_out_s *) output;
 333
 334         *sample_rate = handle->_sample_rate;
 335
 336         LOGI("[%s] sample rate = %d",__FUNCTION__, *sample_rate);
 337         return AUDIO_IO_ERROR_NONE;
 338 }
 339
 340
 341 int audio_out_get_channel(audio_out_h output, audio_channel_e *channel)
 342 {
 343         AUDIO_IO_NULL_ARG_CHECK(output);
 344         AUDIO_IO_NULL_ARG_CHECK(channel);
 345         audio_out_s *handle = (audio_out_s *) output;
 346
 347         *channel = handle->_channel;
 348
 349         LOGI("[%s] channel = %d",__FUNCTION__, *channel);
 350         return AUDIO_IO_ERROR_NONE;
 351 }
 352
 353
 354 int audio_out_get_sample_type(audio_out_h output, audio_sample_type_e *type)
 355 {
 356         AUDIO_IO_NULL_ARG_CHECK(output);
 357         AUDIO_IO_NULL_ARG_CHECK(type);
 358         audio_out_s *handle = (audio_out_s *) output;
 359
 360         *type = handle->_type;
 361
 362         LOGI("[%s] sample type = %d",__FUNCTION__, *type);
 363         return AUDIO_IO_ERROR_NONE;
 364 }
 365
 366
 367 int audio_out_get_sound_type(audio_out_h output, sound_type_e *type)
 368 {
 369         AUDIO_IO_NULL_ARG_CHECK(output);
 370         AUDIO_IO_NULL_ARG_CHECK(type);
 371         audio_out_s *handle = (audio_out_s *) output;
 372
 373         *type = handle->_sound_type;
 374
 375         LOGI("[%s] sound type = %d",__FUNCTION__, *type);
 376         return AUDIO_IO_ERROR_NONE;
 377 }
 378
 379 int audio_out_set_interrupted_cb(audio_out_h output, audio_io_interrupted_cb callback, void *user_data)
 380 {
 381         AUDIO_IO_NULL_ARG_CHECK(output);
 382         AUDIO_IO_NULL_ARG_CHECK(callback);
 383         audio_out_s *handle = (audio_out_s *) output;
 384
 385         handle->user_cb = callback;
 386         handle->user_data = user_data;
 387
 388         LOGI("[%s] current interrupted cb (%p) / data (%p)",__FUNCTION__, handle->user_cb, handle->user_data);
 389         return AUDIO_IO_ERROR_NONE;
 390 }
 391
 392 int audio_out_unset_interrupted_cb(audio_out_h output)
 393 {
 394         AUDIO_IO_NULL_ARG_CHECK(output);
 395         audio_out_s *handle = (audio_out_s *) output;
 396
 397         handle->user_cb = NULL;
 398         handle->user_data = NULL;
 399
 400         LOGI("[%s] current interrupted cb (%p) / data (%p)",__FUNCTION__, handle->user_cb, handle->user_data);
 401         return AUDIO_IO_ERROR_NONE;
 402 }
 403
 404 int audio_out_ignore_session(audio_out_h output)
 405 {
 406         AUDIO_IO_NULL_ARG_CHECK(output);
 407         audio_out_s *handle = (audio_out_s *) output;
 408         int ret = 0;
 409
 410         ret = mm_sound_pcm_play_ignore_session(handle->mm_handle);
 411         if (ret != MM_ERROR_NONE) {
 412                 return __convert_audio_io_error_code(ret, (char*)__FUNCTION__);
 413         }
 414         LOGI("[%s] mm_sound_pcm_play_ignore_session() success",__FUNCTION__);
 415
 416         return AUDIO_IO_ERROR_NONE;
 417 }
 418
 419 int audio_out_set_stream_cb(audio_out_h output, audio_out_stream_cb callback, void* userdata)
 420 {
 421 /* TODO : it will be added after updating libmm-sound */
 422         return AUDIO_IO_ERROR_NONE;
 423 }
 424
 425 int audio_out_unset_stream_cb(audio_out_h output)
 426 {
 427 /* TODO : it will be added after updating libmm-sound */
 428         return AUDIO_IO_ERROR_NONE;
 429 }