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_hal_t *ah)
  32 {
  33     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
  34
  35     pthread_mutex_init(&(ah->mixer.mutex), NULL);
  36     return AUDIO_RET_OK;
  37 }
  38
  39 audio_return_t _audio_util_deinit(audio_hal_t *ah)
  40 {
  41     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
  42
  43     pthread_mutex_destroy(&(ah->mixer.mutex));
  44     return AUDIO_RET_OK;
  45 }
  46
  47 #ifdef __MIXER_PARAM_DUMP
  48
  49 static void __dump_mixer_param(char *dump, long *param, int size)
  50 {
  51     int i, len;
  52
  53     for (i = 0; i < size; i++) {
  54         len = sprintf(dump, "%ld", *param);
  55         if (len > 0)
  56             dump += len;
  57         if (i != size -1) {
  58             *dump++ = ',';
  59         }
  60
  61         param++;
  62     }
  63     *dump = '\0';
  64 }
  65
  66 #endif
  67
  68 audio_return_t _audio_mixer_control_set_param(audio_hal_t *ah, const char* ctl_name, snd_ctl_elem_value_t* param, int size)
  69 {
  70     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
  71
  72     /* TODO. */
  73     return AUDIO_RET_OK;
  74 }
  75
  76 audio_return_t audio_mixer_control_get_value(audio_hal_t *ah, const char *ctl_name, int *val)
  77 {
  78     audio_return_t audio_ret = AUDIO_RET_OK;
  79
  80     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
  81     AUDIO_RETURN_VAL_IF_FAIL(ctl_name, AUDIO_ERR_PARAMETER);
  82     AUDIO_RETURN_VAL_IF_FAIL(val, AUDIO_ERR_PARAMETER);
  83
  84     audio_ret = _audio_mixer_control_get_value(ah, ALSA_DEFAULT_CARD, ctl_name, val);
  85     return audio_ret;
  86 }
  87
  88 audio_return_t _audio_mixer_control_get_value(audio_hal_t *ah, const char *card, const char *ctl_name, int *val)
  89 {
  90     snd_ctl_t *handle;
  91     snd_ctl_elem_value_t *control;
  92     snd_ctl_elem_id_t *id;
  93     snd_ctl_elem_info_t *info;
  94     snd_ctl_elem_type_t type;
  95
  96     int ret = 0, count = 0, i = 0;
  97
  98     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
  99     AUDIO_RETURN_VAL_IF_FAIL(card, AUDIO_ERR_PARAMETER);
 100     AUDIO_RETURN_VAL_IF_FAIL(ctl_name, AUDIO_ERR_PARAMETER);
 101     AUDIO_RETURN_VAL_IF_FAIL(val, AUDIO_ERR_PARAMETER);
 102
 103     pthread_mutex_lock(&(ah->mixer.mutex));
 104
 105     ret = snd_ctl_open(&handle, card, 0);
 106     if (ret < 0) {
 107         AUDIO_LOG_ERROR("snd_ctl_open error, %s\n", snd_strerror(ret));
 108         pthread_mutex_unlock(&(ah->mixer.mutex));
 109         return AUDIO_ERR_IOCTL;
 110     }
 111
 112     // Get Element Info
 113
 114     snd_ctl_elem_id_alloca(&id);
 115     snd_ctl_elem_info_alloca(&info);
 116     snd_ctl_elem_value_alloca(&control);
 117
 118     snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);
 119     snd_ctl_elem_id_set_name(id, ctl_name);
 120
 121     snd_ctl_elem_info_set_id(info, id);
 122     if (snd_ctl_elem_info(handle, info) < 0) {
 123         AUDIO_LOG_ERROR("Cannot find control element: %s\n", ctl_name);
 124         goto close;
 125     }
 126     snd_ctl_elem_info_get_id(info, id);
 127
 128     type = snd_ctl_elem_info_get_type(info);
 129     count = snd_ctl_elem_info_get_count(info);
 130
 131     snd_ctl_elem_value_set_id(control, id);
 132
 133     if (snd_ctl_elem_read(handle, control) < 0) {
 134         AUDIO_LOG_ERROR("snd_ctl_elem_read failed \n");
 135         goto close;
 136 }
 137
 138     switch (type) {
 139     case SND_CTL_ELEM_TYPE_BOOLEAN:
 140         *val = snd_ctl_elem_value_get_boolean(control, i);
 141         break;
 142     case SND_CTL_ELEM_TYPE_INTEGER:
 143         for (i = 0; i < count; i++)
 144         *val = snd_ctl_elem_value_get_integer(control, i);
 145         break;
 146     case SND_CTL_ELEM_TYPE_ENUMERATED:
 147         for (i = 0; i < count; i++)
 148         *val = snd_ctl_elem_value_get_enumerated(control, i);
 149         break;
 150     default:
 151         AUDIO_LOG_WARN("unsupported control element type\n");
 152         goto close;
 153     }
 154
 155     snd_ctl_close(handle);
 156
 157 #ifdef AUDIO_DEBUG
 158     AUDIO_LOG_INFO("get mixer(%s) = %d success", ctl_name, *val);
 159 #endif
 160
 161     pthread_mutex_unlock(&(ah->mixer.mutex));
 162     return AUDIO_RET_OK;
 163
 164 close:
 165     AUDIO_LOG_ERROR("Error\n");
 166     snd_ctl_close(handle);
 167     pthread_mutex_unlock(&(ah->mixer.mutex));
 168     return AUDIO_ERR_UNDEFINED;
 169 }
 170
 171 audio_return_t _audio_mixer_control_set_value(audio_hal_t *ah, const char *card, const char *ctl_name, int val)
 172 {
 173     snd_ctl_t *handle;
 174     snd_ctl_elem_value_t *control;
 175     snd_ctl_elem_id_t *id;
 176     snd_ctl_elem_info_t *info;
 177     snd_ctl_elem_type_t type;
 178
 179     char *card_name = NULL;
 180     int ret = 0, count = 0, i = 0;
 181
 182     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
 183     AUDIO_RETURN_VAL_IF_FAIL(card, AUDIO_ERR_PARAMETER);
 184     AUDIO_RETURN_VAL_IF_FAIL(ctl_name, AUDIO_ERR_PARAMETER);
 185
 186     pthread_mutex_lock(&(ah->mixer.mutex));
 187
 188     ret = snd_ctl_open(&handle, card, 0);
 189     if (ret < 0) {
 190         AUDIO_LOG_ERROR("snd_ctl_open error, card: %s: %s", card_name, snd_strerror(ret));
 191         pthread_mutex_unlock(&(ah->mixer.mutex));
 192         return AUDIO_ERR_IOCTL;
 193     }
 194
 195     // Get Element Info
 196
 197     snd_ctl_elem_id_alloca(&id);
 198     snd_ctl_elem_info_alloca(&info);
 199     snd_ctl_elem_value_alloca(&control);
 200
 201     snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);
 202     snd_ctl_elem_id_set_name(id, ctl_name);
 203
 204     snd_ctl_elem_info_set_id(info, id);
 205     if (snd_ctl_elem_info(handle, info) < 0) {
 206         AUDIO_LOG_ERROR("Cannot find control element: %s", ctl_name);
 207         goto close;
 208     }
 209     snd_ctl_elem_info_get_id(info, id);
 210
 211     type = snd_ctl_elem_info_get_type(info);
 212     count = snd_ctl_elem_info_get_count(info);
 213
 214     snd_ctl_elem_value_set_id(control, id);
 215
 216     snd_ctl_elem_read(handle, control);
 217
 218     switch (type) {
 219     case SND_CTL_ELEM_TYPE_BOOLEAN:
 220         for (i = 0; i < count; i++)
 221             snd_ctl_elem_value_set_boolean(control, i, val);
 222         break;
 223     case SND_CTL_ELEM_TYPE_INTEGER:
 224         for (i = 0; i < count; i++)
 225             snd_ctl_elem_value_set_integer(control, i, val);
 226         break;
 227     case SND_CTL_ELEM_TYPE_ENUMERATED:
 228         for (i = 0; i < count; i++)
 229             snd_ctl_elem_value_set_enumerated(control, i, val);
 230         break;
 231
 232     default:
 233         AUDIO_LOG_WARN("unsupported control element type");
 234         goto close;
 235     }
 236
 237     snd_ctl_elem_write(handle, control);
 238
 239     snd_ctl_close(handle);
 240
 241     AUDIO_LOG_INFO("set mixer(%s) = %d success", ctl_name, val);
 242
 243     pthread_mutex_unlock(&(ah->mixer.mutex));
 244     return AUDIO_RET_OK;
 245
 246 close:
 247     AUDIO_LOG_ERROR("Error");
 248     snd_ctl_close(handle);
 249     pthread_mutex_unlock(&(ah->mixer.mutex));
 250     return AUDIO_ERR_UNDEFINED;
 251 }
 252
 253 audio_return_t _audio_mixer_control_set_value_string(audio_hal_t *ah, const char* ctl_name, const char* value)
 254 {
 255     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
 256     AUDIO_RETURN_VAL_IF_FAIL(ctl_name, AUDIO_ERR_PARAMETER);
 257
 258     /* TODO. */
 259     return AUDIO_RET_OK;
 260 }
 261
 262
 263 audio_return_t _audio_mixer_control_get_element(audio_hal_t *ah, const char *ctl_name, snd_hctl_elem_t **elem)
 264 {
 265     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
 266     AUDIO_RETURN_VAL_IF_FAIL(ctl_name, AUDIO_ERR_PARAMETER);
 267     AUDIO_RETURN_VAL_IF_FAIL(elem, AUDIO_ERR_PARAMETER);
 268
 269     /* TODO. */
 270     return AUDIO_RET_OK;
 271 }
 272
 273 #ifdef __USE_TINYALSA__
 274 /* Convert pcm format from pulse to alsa */
 275 static const uint32_t g_format_convert_table[] = {
 276     [AUDIO_SAMPLE_U8]        = PCM_FORMAT_S8,
 277     [AUDIO_SAMPLE_S16LE]     = PCM_FORMAT_S16_LE,
 278     [AUDIO_SAMPLE_S32LE]     = PCM_FORMAT_S32_LE,
 279     [AUDIO_SAMPLE_S24_32LE]  = PCM_FORMAT_S24_LE
 280 };
 281 #else  /* alsa-lib */
 282 /* Convert pcm format from pulse to alsa */
 283 static const uint32_t g_format_convert_table[] = {
 284     [AUDIO_SAMPLE_U8]        = SND_PCM_FORMAT_U8,
 285     [AUDIO_SAMPLE_ALAW]      = SND_PCM_FORMAT_A_LAW,
 286     [AUDIO_SAMPLE_ULAW]      = SND_PCM_FORMAT_MU_LAW,
 287     [AUDIO_SAMPLE_S16LE]     = SND_PCM_FORMAT_S16_LE,
 288     [AUDIO_SAMPLE_S16BE]     = SND_PCM_FORMAT_S16_BE,
 289     [AUDIO_SAMPLE_FLOAT32LE] = SND_PCM_FORMAT_FLOAT_LE,
 290     [AUDIO_SAMPLE_FLOAT32BE] = SND_PCM_FORMAT_FLOAT_BE,
 291     [AUDIO_SAMPLE_S32LE]     = SND_PCM_FORMAT_S32_LE,
 292     [AUDIO_SAMPLE_S32BE]     = SND_PCM_FORMAT_S32_BE,
 293     [AUDIO_SAMPLE_S24LE]     = SND_PCM_FORMAT_S24_3LE,
 294     [AUDIO_SAMPLE_S24BE]     = SND_PCM_FORMAT_S24_3BE,
 295     [AUDIO_SAMPLE_S24_32LE]  = SND_PCM_FORMAT_S24_LE,
 296     [AUDIO_SAMPLE_S24_32BE]  = SND_PCM_FORMAT_S24_BE
 297 };
 298 #endif
 299
 300 uint32_t _convert_format(audio_sample_format_t format)
 301 {
 302     return g_format_convert_table[format];
 303 }
 304
 305 /* Generic snd pcm interface APIs */
 306 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)
 307 {
 308     audio_return_t ret = AUDIO_RET_OK;
 309     snd_pcm_hw_params_t *hwparams;
 310     int err = 0;
 311     int dir;
 312     unsigned int val = 0;
 313     snd_pcm_uframes_t _period_size = period_size ? *period_size : 0;
 314     snd_pcm_uframes_t _buffer_size = buffer_size ? *buffer_size : 0;
 315     uint8_t _use_mmap = use_mmap && *use_mmap;
 316     uint32_t channels = 0;
 317
 318     AUDIO_RETURN_VAL_IF_FAIL(pcm, AUDIO_ERR_PARAMETER);
 319
 320     snd_pcm_hw_params_alloca(&hwparams);
 321
 322     /* Skip parameter setting to null device. */
 323     if (snd_pcm_type(pcm) == SND_PCM_TYPE_NULL)
 324         return AUDIO_ERR_IOCTL;
 325
 326     /* Allocate a hardware parameters object. */
 327     snd_pcm_hw_params_alloca(&hwparams);
 328
 329     /* Fill it in with default values. */
 330     if (snd_pcm_hw_params_any(pcm, hwparams) < 0) {
 331         AUDIO_LOG_ERROR("snd_pcm_hw_params_any() : failed! - %s\n", snd_strerror(err));
 332         goto error;
 333     }
 334
 335     /* Set the desired hardware parameters. */
 336
 337     if (_use_mmap) {
 338
 339         if (snd_pcm_hw_params_set_access(pcm, hwparams, SND_PCM_ACCESS_MMAP_INTERLEAVED) < 0) {
 340
 341             /* mmap() didn't work, fall back to interleaved */
 342
 343             if ((ret = snd_pcm_hw_params_set_access(pcm, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
 344                 AUDIO_LOG_DEBUG("snd_pcm_hw_params_set_access() failed: %s", snd_strerror(ret));
 345                 goto error;
 346             }
 347
 348             _use_mmap = 0;
 349         }
 350
 351     } else if ((ret = snd_pcm_hw_params_set_access(pcm, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
 352         AUDIO_LOG_DEBUG("snd_pcm_hw_params_set_access() failed: %s", snd_strerror(ret));
 353         goto error;
 354     }
 355     AUDIO_LOG_DEBUG("setting rate - %d", sample_spec->rate);
 356     err = snd_pcm_hw_params_set_rate(pcm, hwparams, sample_spec->rate, 0);
 357     if (err < 0) {
 358         AUDIO_LOG_ERROR("snd_pcm_hw_params_set_rate() : failed! - %s\n", snd_strerror(err));
 359     }
 360
 361     err = snd_pcm_hw_params(pcm, hwparams);
 362     if (err < 0) {
 363         AUDIO_LOG_ERROR("snd_pcm_hw_params() : failed! - %s\n", snd_strerror(err));
 364         goto error;
 365     }
 366
 367     /* Dump current param */
 368
 369     if ((ret = snd_pcm_hw_params_current(pcm, hwparams)) < 0) {
 370         AUDIO_LOG_INFO("snd_pcm_hw_params_current() failed: %s", snd_strerror(ret));
 371         goto error;
 372     }
 373
 374     if ((ret = snd_pcm_hw_params_get_period_size(hwparams, &_period_size, &dir)) < 0 ||
 375         (ret = snd_pcm_hw_params_get_buffer_size(hwparams, &_buffer_size)) < 0) {
 376         AUDIO_LOG_INFO("snd_pcm_hw_params_get_{period|buffer}_size() failed: %s", snd_strerror(ret));
 377         goto error;
 378     }
 379
 380     snd_pcm_hw_params_get_access(hwparams, (snd_pcm_access_t *) &val);
 381     AUDIO_LOG_DEBUG("access type = %s\n", snd_pcm_access_name((snd_pcm_access_t)val));
 382
 383     snd_pcm_hw_params_get_format(hwparams, &sample_spec->format);
 384     AUDIO_LOG_DEBUG("format = '%s' (%s)\n",
 385                     snd_pcm_format_name((snd_pcm_format_t)sample_spec->format),
 386                     snd_pcm_format_description((snd_pcm_format_t)sample_spec->format));
 387
 388     snd_pcm_hw_params_get_subformat(hwparams, (snd_pcm_subformat_t *)&val);
 389     AUDIO_LOG_DEBUG("subformat = '%s' (%s)\n",
 390                     snd_pcm_subformat_name((snd_pcm_subformat_t)val),
 391                     snd_pcm_subformat_description((snd_pcm_subformat_t)val));
 392
 393     snd_pcm_hw_params_get_channels(hwparams, &channels);
 394     sample_spec->channels = (uint8_t)channels;
 395     AUDIO_LOG_DEBUG("channels = %d\n", sample_spec->channels);
 396
 397     if (buffer_size)
 398         *buffer_size = _buffer_size;
 399
 400     if (period_size)
 401         *period_size = _period_size;
 402
 403     if (use_mmap)
 404         *use_mmap = _use_mmap;
 405
 406     return AUDIO_RET_OK;
 407
 408 error:
 409     return AUDIO_ERR_RESOURCE;
 410 }
 411
 412 audio_return_t _audio_pcm_set_sw_params(snd_pcm_t *pcm, snd_pcm_uframes_t avail_min, uint8_t period_event)
 413 {
 414     snd_pcm_sw_params_t *swparams;
 415     snd_pcm_uframes_t boundary;
 416     int err;
 417
 418     AUDIO_RETURN_VAL_IF_FAIL(pcm, AUDIO_ERR_PARAMETER);
 419
 420     snd_pcm_sw_params_alloca(&swparams);
 421
 422     if ((err = snd_pcm_sw_params_current(pcm, swparams)) < 0) {
 423         AUDIO_LOG_WARN("Unable to determine current swparams: %s\n", snd_strerror(err));
 424         goto error;
 425     }
 426     if ((err = snd_pcm_sw_params_set_period_event(pcm, swparams, period_event)) < 0) {
 427         AUDIO_LOG_WARN("Unable to disable period event: %s\n", snd_strerror(err));
 428         goto error;
 429     }
 430     if ((err = snd_pcm_sw_params_set_tstamp_mode(pcm, swparams, SND_PCM_TSTAMP_ENABLE)) < 0) {
 431         AUDIO_LOG_WARN("Unable to enable time stamping: %s\n", snd_strerror(err));
 432         goto error;
 433     }
 434     if ((err = snd_pcm_sw_params_get_boundary(swparams, &boundary)) < 0) {
 435         AUDIO_LOG_WARN("Unable to get boundary: %s\n", snd_strerror(err));
 436         goto error;
 437     }
 438     if ((err = snd_pcm_sw_params_set_stop_threshold(pcm, swparams, boundary)) < 0) {
 439         AUDIO_LOG_WARN("Unable to set stop threshold: %s\n", snd_strerror(err));
 440         goto error;
 441     }
 442     if ((err = snd_pcm_sw_params_set_start_threshold(pcm, swparams, (snd_pcm_uframes_t) avail_min)) < 0) {
 443         AUDIO_LOG_WARN("Unable to set start threshold: %s\n", snd_strerror(err));
 444         goto error;
 445     }
 446     if ((err = snd_pcm_sw_params_set_avail_min(pcm, swparams, avail_min)) < 0) {
 447         AUDIO_LOG_WARN("snd_pcm_sw_params_set_avail_min() failed: %s", snd_strerror(err));
 448         goto error;
 449     }
 450     if ((err = snd_pcm_sw_params(pcm, swparams)) < 0) {
 451         AUDIO_LOG_WARN("Unable to set sw params: %s\n", snd_strerror(err));
 452         goto error;
 453     }
 454     return AUDIO_RET_OK;
 455 error:
 456     return err;
 457 }
 458
 459 /* ------ dump helper --------  */
 460 #define MAX(a, b) ((a) > (b) ? (a) : (b))
 461
 462 dump_data_t* dump_new(int length)
 463 {
 464     dump_data_t* dump = NULL;
 465
 466     if ((dump = malloc(sizeof(dump_data_t)))) {
 467         memset(dump, 0, sizeof(dump_data_t));
 468         if ((dump->strbuf = malloc(length))) {
 469             dump->p = &dump->strbuf[0];
 470             dump->left = length;
 471         } else {
 472             free(dump);
 473             dump = NULL;
 474         }
 475     }
 476
 477     return dump;
 478 }
 479
 480 void dump_add_str(dump_data_t *dump, const char *fmt, ...)
 481 {
 482     int len;
 483     va_list ap;
 484
 485     if (!dump)
 486         return;
 487
 488     va_start(ap, fmt);
 489     len = vsnprintf(dump->p, dump->left, fmt, ap);
 490     va_end(ap);
 491
 492     dump->p += MAX(0, len);
 493     dump->left -= MAX(0, len);
 494 }
 495
 496 char* dump_get_str(dump_data_t *dump)
 497 {
 498     return (dump) ? dump->strbuf : NULL;
 499 }
 500
 501 void dump_free(dump_data_t *dump)
 502 {
 503     if (dump) {
 504         if (dump->strbuf)
 505             free(dump->strbuf);
 506         free(dump);
 507     }
 508 }
 509 /* ------ dump helper --------  */