tizen-audio-util.c

   1 /*
   2  * audio-hal
   3  *
   4  * Copyright (c) 2000 - 2013 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include <config.h>
  22 #endif
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <pthread.h>
  28
  29 #include "tizen-audio-internal.h"
  30
  31 audio_return_t _audio_util_init (audio_mgr_t *am)
  32 {
  33     pthread_mutex_init(&(am->mixer.mutex), NULL);
  34     return AUDIO_RET_OK;
  35 }
  36
  37 audio_return_t _audio_util_deinit (audio_mgr_t *am)
  38 {
  39     pthread_mutex_destroy(&(am->mixer.mutex));
  40     return AUDIO_RET_OK;
  41 }
  42
  43 #ifdef __MIXER_PARAM_DUMP
  44
  45 static void __dump_mixer_param(char *dump, long *param, int size)
  46 {
  47     int i, len;
  48
  49     for (i = 0; i < size; i++) {
  50         len = sprintf(dump, "%ld", *param);
  51         if (len > 0)
  52             dump += len;
  53         if (i != size -1) {
  54             *dump++ = ',';
  55         }
  56
  57         param++;
  58     }
  59     *dump = '\0';
  60 }
  61
  62 #endif
  63
  64 audio_return_t _audio_mixer_control_set_param(audio_mgr_t *am, const char* ctl_name, snd_ctl_elem_value_t* param, int size)
  65 {
  66     /* TODO. */
  67     return AUDIO_RET_OK;
  68 }
  69
  70 audio_return_t audio_mixer_control_get_value (void *userdata, const char *ctl_name, int *val)
  71 {
  72     audio_return_t audio_ret = AUDIO_RET_OK;
  73     audio_mgr_t *am = (audio_mgr_t *)userdata;
  74     audio_ret = _audio_mixer_control_get_value(am, ctl_name, val);
  75     return audio_ret;
  76 }
  77
  78 audio_return_t _audio_mixer_control_get_value(audio_mgr_t *am, const char *ctl_name, int *val)
  79 {
  80     snd_ctl_t *handle;
  81     snd_ctl_elem_value_t *control;
  82     snd_ctl_elem_id_t *id;
  83     snd_ctl_elem_info_t *info;
  84     snd_ctl_elem_type_t type;
  85
  86     int ret = 0, count = 0, i = 0;
  87
  88     pthread_mutex_lock(&(am->mixer.mutex));
  89
  90     ret = snd_ctl_open(&handle, ALSA_DEFAULT_CARD, 0);
  91     if (ret < 0) {
  92         AUDIO_LOG_ERROR ("snd_ctl_open error, %s\n", snd_strerror(ret));
  93         pthread_mutex_unlock(&(am->mixer.mutex));
  94         return AUDIO_ERR_IOCTL;
  95     }
  96
  97     // Get Element Info
  98
  99     snd_ctl_elem_id_alloca(&id);
 100     snd_ctl_elem_info_alloca(&info);
 101     snd_ctl_elem_value_alloca(&control);
 102
 103     snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);
 104     snd_ctl_elem_id_set_name(id, ctl_name);
 105
 106     snd_ctl_elem_info_set_id(info, id);
 107     if(snd_ctl_elem_info(handle, info) < 0 ) {
 108         AUDIO_LOG_ERROR ("Cannot find control element: %s\n", ctl_name);
 109         goto close;
 110     }
 111     snd_ctl_elem_info_get_id(info, id);
 112
 113     type = snd_ctl_elem_info_get_type(info);
 114     count = snd_ctl_elem_info_get_count(info);
 115
 116     snd_ctl_elem_value_set_id(control, id);
 117
 118     if(snd_ctl_elem_read(handle, control) < 0) {
 119         AUDIO_LOG_ERROR ("snd_ctl_elem_read failed \n");
 120         goto close;
 121 }
 122
 123     switch (type) {
 124     case SND_CTL_ELEM_TYPE_BOOLEAN:
 125         *val = snd_ctl_elem_value_get_boolean(control, i);
 126         break;
 127     case SND_CTL_ELEM_TYPE_INTEGER:
 128         for (i = 0; i < count; i++)
 129         *val = snd_ctl_elem_value_get_integer(control, i);
 130         break;
 131     case SND_CTL_ELEM_TYPE_ENUMERATED:
 132         for (i = 0; i < count; i++)
 133         *val = snd_ctl_elem_value_get_enumerated(control, i);
 134         break;
 135     default:
 136         AUDIO_LOG_WARN ("unsupported control element type\n");
 137         goto close;
 138     }
 139
 140     snd_ctl_close(handle);
 141
 142 #ifdef AUDIO_DEBUG
 143     AUDIO_LOG_INFO("get mixer(%s) = %d success", ctl_name, *val);
 144 #endif
 145
 146     pthread_mutex_unlock(&(am->mixer.mutex));
 147     return AUDIO_RET_OK;
 148
 149 close:
 150     AUDIO_LOG_ERROR ("Error\n");
 151     snd_ctl_close(handle);
 152     pthread_mutex_unlock(&(am->mixer.mutex));
 153     return AUDIO_ERR_UNDEFINED;
 154 }
 155
 156 audio_return_t _audio_mixer_control_set_value(audio_mgr_t *am, const char *ctl_name, int val)
 157 {
 158     snd_ctl_t *handle;
 159     snd_ctl_elem_value_t *control;
 160     snd_ctl_elem_id_t *id;
 161     snd_ctl_elem_info_t *info;
 162     snd_ctl_elem_type_t type;
 163
 164     char *card_name = NULL;
 165     int ret = 0, count = 0, i = 0;
 166
 167     pthread_mutex_lock(&(am->mixer.mutex));
 168
 169     ret = snd_ctl_open(&handle, ALSA_DEFAULT_CARD, 0);
 170     if (ret < 0) {
 171         AUDIO_LOG_ERROR("snd_ctl_open error, card: %s: %s", card_name, snd_strerror(ret));
 172         pthread_mutex_unlock(&(am->mixer.mutex));
 173         return AUDIO_ERR_IOCTL;
 174     }
 175
 176     // Get Element Info
 177
 178     snd_ctl_elem_id_alloca(&id);
 179     snd_ctl_elem_info_alloca(&info);
 180     snd_ctl_elem_value_alloca(&control);
 181
 182     snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);
 183     snd_ctl_elem_id_set_name(id, ctl_name);
 184
 185     snd_ctl_elem_info_set_id(info, id);
 186     if(snd_ctl_elem_info(handle, info) < 0 ) {
 187         AUDIO_LOG_ERROR("Cannot find control element: %s", ctl_name);
 188         goto close;
 189     }
 190     snd_ctl_elem_info_get_id(info, id);
 191
 192     type = snd_ctl_elem_info_get_type(info);
 193     count = snd_ctl_elem_info_get_count(info);
 194
 195     snd_ctl_elem_value_set_id(control, id);
 196
 197     snd_ctl_elem_read(handle, control);
 198
 199     switch (type) {
 200     case SND_CTL_ELEM_TYPE_BOOLEAN:
 201         for (i = 0; i < count; i++)
 202             snd_ctl_elem_value_set_boolean(control, i, val);
 203         break;
 204     case SND_CTL_ELEM_TYPE_INTEGER:
 205         for (i = 0; i < count; i++)
 206             snd_ctl_elem_value_set_integer(control, i,val);
 207         break;
 208     case SND_CTL_ELEM_TYPE_ENUMERATED:
 209         for (i = 0; i < count; i++)
 210             snd_ctl_elem_value_set_enumerated(control, i,val);
 211         break;
 212
 213     default:
 214         AUDIO_LOG_WARN("unsupported control element type");
 215         goto close;
 216     }
 217
 218     snd_ctl_elem_write(handle, control);
 219
 220     snd_ctl_close(handle);
 221
 222     AUDIO_LOG_INFO("set mixer(%s) = %d success", ctl_name, val);
 223
 224     pthread_mutex_unlock(&(am->mixer.mutex));
 225     return AUDIO_RET_OK;
 226
 227 close:
 228     AUDIO_LOG_ERROR("Error");
 229     snd_ctl_close(handle);
 230     pthread_mutex_unlock(&(am->mixer.mutex));
 231     return AUDIO_ERR_UNDEFINED;
 232 }
 233
 234 audio_return_t _audio_mixer_control_set_value_string(audio_mgr_t *am, const char* ctl_name, const char* value)
 235 {
 236     /* TODO. */
 237     return AUDIO_RET_OK;
 238 }
 239
 240
 241 audio_return_t _audio_mixer_control_get_element(audio_mgr_t *am, const char *ctl_name, snd_hctl_elem_t **elem)
 242 {
 243     /* TODO. */
 244     return AUDIO_RET_OK;
 245 }
 246
 247 /* Convert pcm format from pulse to alsa */
 248 static const uint32_t g_format_convert_table[] = {
 249     [AUDIO_SAMPLE_U8]        = SND_PCM_FORMAT_U8,
 250     [AUDIO_SAMPLE_ALAW]      = SND_PCM_FORMAT_A_LAW,
 251     [AUDIO_SAMPLE_ULAW]      = SND_PCM_FORMAT_MU_LAW,
 252     [AUDIO_SAMPLE_S16LE]     = SND_PCM_FORMAT_S16_LE,
 253     [AUDIO_SAMPLE_S16BE]     = SND_PCM_FORMAT_S16_BE,
 254     [AUDIO_SAMPLE_FLOAT32LE] = SND_PCM_FORMAT_FLOAT_LE,
 255     [AUDIO_SAMPLE_FLOAT32BE] = SND_PCM_FORMAT_FLOAT_BE,
 256     [AUDIO_SAMPLE_S32LE]     = SND_PCM_FORMAT_S32_LE,
 257     [AUDIO_SAMPLE_S32BE]     = SND_PCM_FORMAT_S32_BE,
 258     [AUDIO_SAMPLE_S24LE]     = SND_PCM_FORMAT_S24_3LE,
 259     [AUDIO_SAMPLE_S24BE]     = SND_PCM_FORMAT_S24_3BE,
 260     [AUDIO_SAMPLE_S24_32LE]  = SND_PCM_FORMAT_S24_LE,
 261     [AUDIO_SAMPLE_S24_32BE]  = SND_PCM_FORMAT_S24_BE
 262 };
 263
 264 uint32_t _convert_format(audio_sample_format_t format)
 265 {
 266     return g_format_convert_table[format];
 267 }
 268
 269 /* Generic snd pcm interface APIs */
 270 audio_return_t _audio_pcm_set_hw_params(snd_pcm_t *pcm, audio_pcm_sample_spec_t *sample_spec, uint8_t *use_mmap, snd_pcm_uframes_t *period_size, snd_pcm_uframes_t *buffer_size)
 271 {
 272     audio_return_t ret = AUDIO_RET_OK;
 273     snd_pcm_hw_params_t *hwparams;
 274     int err = 0;
 275     int dir;
 276     unsigned int val = 0;
 277     snd_pcm_uframes_t _period_size = period_size ? *period_size : 0;
 278     snd_pcm_uframes_t _buffer_size = buffer_size ? *buffer_size : 0;
 279     uint8_t _use_mmap = use_mmap && *use_mmap;
 280     uint32_t channels = 0;
 281
 282     snd_pcm_hw_params_alloca(&hwparams);
 283
 284     /* Skip parameter setting to null device. */
 285     if (snd_pcm_type(pcm) == SND_PCM_TYPE_NULL)
 286         return AUDIO_ERR_IOCTL;
 287
 288     /* Allocate a hardware parameters object. */
 289     snd_pcm_hw_params_alloca(&hwparams);
 290
 291     /* Fill it in with default values. */
 292     if(snd_pcm_hw_params_any(pcm, hwparams) < 0) {
 293         AUDIO_LOG_ERROR("snd_pcm_hw_params_any() : failed! - %s\n", snd_strerror(err));
 294         goto error;
 295     }
 296
 297     /* Set the desired hardware parameters. */
 298
 299     if (_use_mmap) {
 300
 301         if (snd_pcm_hw_params_set_access(pcm, hwparams, SND_PCM_ACCESS_MMAP_INTERLEAVED) < 0) {
 302
 303             /* mmap() didn't work, fall back to interleaved */
 304
 305             if ((ret = snd_pcm_hw_params_set_access(pcm, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
 306                 AUDIO_LOG_DEBUG("snd_pcm_hw_params_set_access() failed: %s", snd_strerror(ret));
 307                 goto error;
 308             }
 309
 310             _use_mmap = 0;
 311         }
 312
 313     } else if ((ret = snd_pcm_hw_params_set_access(pcm, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
 314         AUDIO_LOG_DEBUG("snd_pcm_hw_params_set_access() failed: %s", snd_strerror(ret));
 315         goto error;
 316     }
 317     AUDIO_LOG_DEBUG("setting rate - %d", sample_spec->rate);
 318     err = snd_pcm_hw_params_set_rate(pcm, hwparams, sample_spec->rate, 0);
 319     if (err < 0) {
 320         AUDIO_LOG_ERROR("snd_pcm_hw_params_set_rate() : failed! - %s\n", snd_strerror(err));
 321     }
 322
 323     err = snd_pcm_hw_params(pcm, hwparams);
 324     if (err < 0) {
 325         AUDIO_LOG_ERROR("snd_pcm_hw_params() : failed! - %s\n", snd_strerror(err));
 326         goto error;
 327     }
 328
 329     /* Dump current param */
 330
 331     if ((ret = snd_pcm_hw_params_current(pcm, hwparams)) < 0) {
 332         AUDIO_LOG_INFO("snd_pcm_hw_params_current() failed: %s", snd_strerror(ret));
 333         goto error;
 334     }
 335
 336     if ((ret = snd_pcm_hw_params_get_period_size(hwparams, &_period_size, &dir)) < 0 ||
 337         (ret = snd_pcm_hw_params_get_buffer_size(hwparams, &_buffer_size)) < 0) {
 338         AUDIO_LOG_INFO("snd_pcm_hw_params_get_{period|buffer}_size() failed: %s", snd_strerror(ret));
 339         goto error;
 340     }
 341
 342     snd_pcm_hw_params_get_access(hwparams, (snd_pcm_access_t *) &val);
 343     AUDIO_LOG_DEBUG("access type = %s\n", snd_pcm_access_name((snd_pcm_access_t)val));
 344
 345     snd_pcm_hw_params_get_format(hwparams, &sample_spec->format);
 346     AUDIO_LOG_DEBUG("format = '%s' (%s)\n",
 347                     snd_pcm_format_name((snd_pcm_format_t)sample_spec->format),
 348                     snd_pcm_format_description((snd_pcm_format_t)sample_spec->format));
 349
 350     snd_pcm_hw_params_get_subformat(hwparams, (snd_pcm_subformat_t *)&val);
 351     AUDIO_LOG_DEBUG("subformat = '%s' (%s)\n",
 352                     snd_pcm_subformat_name((snd_pcm_subformat_t)val),
 353                     snd_pcm_subformat_description((snd_pcm_subformat_t)val));
 354
 355     snd_pcm_hw_params_get_channels(hwparams, &channels);
 356     sample_spec->channels = (uint8_t)channels;
 357     AUDIO_LOG_DEBUG("channels = %d\n", sample_spec->channels);
 358
 359     if (buffer_size)
 360         *buffer_size = _buffer_size;
 361
 362     if (period_size)
 363         *period_size = _period_size;
 364
 365     if (use_mmap)
 366         *use_mmap = _use_mmap;
 367
 368     return AUDIO_RET_OK;
 369
 370 error:
 371     return AUDIO_ERR_RESOURCE;
 372 }
 373
 374 audio_return_t _audio_pcm_set_sw_params(snd_pcm_t *pcm, snd_pcm_uframes_t avail_min, uint8_t period_event)
 375 {
 376     snd_pcm_sw_params_t *swparams;
 377     snd_pcm_uframes_t boundary;
 378     int err;
 379
 380     snd_pcm_sw_params_alloca(&swparams);
 381
 382     if ((err = snd_pcm_sw_params_current(pcm, swparams) < 0)) {
 383         AUDIO_LOG_WARN("Unable to determine current swparams: %s\n", snd_strerror(err));
 384         goto error;
 385     }
 386     if ((err = snd_pcm_sw_params_set_period_event(pcm, swparams, period_event)) < 0) {
 387         AUDIO_LOG_WARN("Unable to disable period event: %s\n", snd_strerror(err));
 388         goto error;
 389     }
 390     if ((err = snd_pcm_sw_params_set_tstamp_mode(pcm, swparams, SND_PCM_TSTAMP_ENABLE)) < 0) {
 391         AUDIO_LOG_WARN("Unable to enable time stamping: %s\n", snd_strerror(err));
 392         goto error;
 393     }
 394     if ((err = snd_pcm_sw_params_get_boundary(swparams, &boundary)) < 0) {
 395         AUDIO_LOG_WARN("Unable to get boundary: %s\n", snd_strerror(err));
 396         goto error;
 397     }
 398     if ((err = snd_pcm_sw_params_set_stop_threshold(pcm, swparams, boundary)) < 0) {
 399         AUDIO_LOG_WARN("Unable to set stop threshold: %s\n", snd_strerror(err));
 400         goto error;
 401     }
 402     if ((err = snd_pcm_sw_params_set_start_threshold(pcm, swparams, (snd_pcm_uframes_t) -1)) < 0) {
 403         AUDIO_LOG_WARN("Unable to set start threshold: %s\n", snd_strerror(err));
 404         goto error;
 405     }
 406     if ((err = snd_pcm_sw_params_set_avail_min(pcm, swparams, avail_min)) < 0) {
 407         AUDIO_LOG_WARN("snd_pcm_sw_params_set_avail_min() failed: %s", snd_strerror(err));
 408         goto error;
 409     }
 410     if ((err = snd_pcm_sw_params(pcm, swparams)) < 0) {
 411         AUDIO_LOG_WARN("Unable to set sw params: %s\n", snd_strerror(err));
 412         goto error;
 413     }
 414     return AUDIO_RET_OK;
 415 error:
 416     return err;
 417 }