tizen-audio.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 "tizen-audio-internal.h"
  25
  26 int audio_get_revision (void)
  27 {
  28     return AUDIO_REVISION;
  29 }
  30
  31 audio_return_t audio_init (void **userdata, void *platform_data)
  32 {
  33     audio_mgr_t *am;
  34     audio_return_t ret = AUDIO_RET_OK;
  35
  36     if (!(am = malloc(sizeof(audio_mgr_t)))) {
  37         AUDIO_LOG_ERROR("am malloc failed");
  38         return AUDIO_ERR_RESOURCE;
  39     }
  40     am->platform_data = platform_data;
  41     memset(&am->cb_intf, 0, sizeof(audio_cb_interface_t));
  42     if (AUDIO_IS_ERROR((ret = _audio_device_init(am)))) {
  43         AUDIO_LOG_ERROR("device init failed");
  44         goto error_exit;
  45     }
  46     if (AUDIO_IS_ERROR((ret = _audio_volume_init(am)))) {
  47         AUDIO_LOG_ERROR("stream init failed");
  48         goto error_exit;
  49     }
  50     if (AUDIO_IS_ERROR((ret = _audio_ucm_init(am)))) {
  51         AUDIO_LOG_ERROR("ucm init failed");
  52         goto error_exit;
  53     }
  54     if (AUDIO_IS_ERROR((ret = _audio_util_init(am)))) {
  55         AUDIO_LOG_ERROR("mixer init failed");
  56         goto error_exit;
  57     }
  58
  59     *userdata = (void *)am;
  60     return AUDIO_RET_OK;
  61
  62 error_exit:
  63     if (am)
  64         free(am);
  65
  66     return ret;
  67 }
  68
  69 audio_return_t audio_deinit (void **userdata)
  70 {
  71     audio_mgr_t *am = (audio_mgr_t *)*userdata;
  72
  73     if (am) {
  74         _audio_device_deinit(am);
  75         _audio_volume_deinit(am);
  76         _audio_ucm_deinit(am);
  77         _audio_util_deinit(am);
  78         free(am);
  79         *userdata = NULL;
  80     }
  81
  82     return AUDIO_RET_OK;
  83 }
  84
  85 audio_return_t audio_reset_volume (void **userdata)
  86 {
  87     audio_mgr_t *am = (audio_mgr_t *)*userdata;
  88     audio_return_t ret = AUDIO_RET_OK;
  89
  90     if (am) {
  91         _audio_volume_deinit(am);
  92
  93         if (AUDIO_IS_ERROR((ret = _audio_volume_init(am)))) {
  94             AUDIO_LOG_ERROR("stream init failed");
  95             goto error_exit;
  96         }
  97     }
  98
  99     return AUDIO_RET_OK;
 100
 101 error_exit:
 102     if (am)
 103         free(am);
 104     *userdata = NULL;
 105
 106     return ret;
 107 }
 108
 109 audio_return_t audio_set_callback (void *userdata, audio_cb_interface_t *cb_interface)
 110 {
 111     audio_mgr_t *am = (audio_mgr_t *)userdata;
 112
 113     if (am) {
 114         memcpy(&am->cb_intf, cb_interface, sizeof(audio_cb_interface_t));
 115         return AUDIO_RET_OK;
 116     } else {
 117         return AUDIO_ERR_PARAMETER;
 118     }
 119 }
 120
 121
 122 static const unsigned int SAMPLES_PER_PERIOD_DEFAULT         = 1536; /* Frames */
 123 static const unsigned int PERIODS_PER_BUFFER_FASTMODE        = 4;
 124 static const unsigned int PERIODS_PER_BUFFER_DEFAULT         = 6;
 125 static const unsigned int PERIODS_PER_BUFFER_VOIP            = 2;
 126 static const unsigned int PERIODS_PER_BUFFER_PLAYBACK        = 8;
 127 static const unsigned int PERIODS_PER_BUFFER_CAPTURE         = 12;
 128 static const unsigned int PERIODS_PER_BUFFER_VIDEO           = 10;
 129
 130
 131 /* Latency msec */
 132 static const unsigned int PERIOD_TIME_FOR_ULOW_LATENCY_MSEC  = 20;
 133 static const unsigned int PERIOD_TIME_FOR_LOW_LATENCY_MSEC   = 25;
 134 static const unsigned int PERIOD_TIME_FOR_MID_LATENCY_MSEC   = 50;
 135 static const unsigned int PERIOD_TIME_FOR_HIGH_LATENCY_MSEC  = 75;
 136 static const unsigned int PERIOD_TIME_FOR_UHIGH_LATENCY_MSEC = 150;
 137 static const unsigned int PERIOD_TIME_FOR_VOIP_LATENCY_MSEC  = 20;
 138
 139 static const uint32_t g_size_table[] = {
 140     [AUDIO_SAMPLE_U8]        = 1,
 141     [AUDIO_SAMPLE_ULAW]      = 1,
 142     [AUDIO_SAMPLE_ALAW]      = 1,
 143     [AUDIO_SAMPLE_S16LE]     = 2,
 144     [AUDIO_SAMPLE_S16BE]     = 2,
 145     [AUDIO_SAMPLE_FLOAT32LE] = 4,
 146     [AUDIO_SAMPLE_FLOAT32BE] = 4,
 147     [AUDIO_SAMPLE_S32LE]     = 4,
 148     [AUDIO_SAMPLE_S32BE]     = 4,
 149     [AUDIO_SAMPLE_S24LE]     = 3,
 150     [AUDIO_SAMPLE_S24BE]     = 3,
 151     [AUDIO_SAMPLE_S24_32LE]  = 4,
 152     [AUDIO_SAMPLE_S24_32BE]  = 4
 153 };
 154
 155 int _sample_spec_valid(uint32_t rate, audio_sample_format_t format, uint32_t channels)
 156 {
 157     if ((rate <= 0                 ||
 158         rate > (48000U*4U)         ||
 159         channels <= 0              ||
 160         channels > 32U             ||
 161         format >= AUDIO_SAMPLE_MAX ||
 162         format <  AUDIO_SAMPLE_U8))
 163         return 0;
 164
 165     AUDIO_LOG_ERROR("hal-latency - _sample_spec_valid() -> return true");
 166
 167     return 1;
 168 }
 169
 170 uint32_t _audio_usec_to_bytes(uint64_t t, uint32_t rate, audio_sample_format_t format, uint32_t channels)
 171 {
 172     uint32_t ret = (uint32_t) (((t * rate) / 1000000ULL)) * (g_size_table[format] * channels);
 173     AUDIO_LOG_DEBUG("hal-latency - return %d", ret);
 174     return ret;
 175 }
 176
 177 uint32_t _audio_sample_size(audio_sample_format_t format)
 178 {
 179     return g_size_table[format];
 180 }
 181 audio_return_t audio_get_buffer_attr(void                  *userdata,
 182                                      audio_latency_t       latency,
 183                                      uint32_t              samplerate,
 184                                      audio_sample_format_t format,
 185                                      uint32_t              channels,
 186                                      uint32_t              *maxlength,
 187                                      uint32_t              *tlength,
 188                                      uint32_t              *prebuf,
 189                                      uint32_t              *minreq,
 190                                      uint32_t              *fragsize)
 191 {
 192     assert(userdata);
 193     assert(maxlength);
 194     assert(tlength);
 195     assert(prebuf);
 196     assert(minreq);
 197     assert(fragsize);
 198
 199     AUDIO_LOG_DEBUG("hal-latency - audio_get_buffer_attr(latency:%d, samplerate:%d, format:%d, channels:%d)", latency, samplerate, format, channels);
 200
 201     audio_mgr_t *am = (audio_mgr_t *)userdata;
 202
 203     uint32_t period_time        = 0,
 204              sample_per_period  = 0,
 205              periods_per_buffer = 0;
 206
 207     if (_sample_spec_valid(samplerate, format, channels) == 0) {
 208         return AUDIO_ERR_PARAMETER;
 209     }
 210
 211     switch (latency) {
 212     case AUDIO_IN_LATENCY_LOW:
 213         AUDIO_LOG_DEBUG("AUDIO_IN_LATENCY_LOW");
 214         period_time        = PERIOD_TIME_FOR_LOW_LATENCY_MSEC;
 215         sample_per_period  = (samplerate * period_time) / 1000;
 216         periods_per_buffer = PERIODS_PER_BUFFER_FASTMODE;
 217         *prebuf            = 0;
 218         *minreq            = -1;
 219         *tlength           = -1;
 220         *maxlength         = -1;
 221         *fragsize          = sample_per_period * _audio_sample_size(format);
 222         break;
 223
 224     case AUDIO_IN_LATENCY_MID:
 225         AUDIO_LOG_DEBUG("AUDIO_IN_LATENCY_MID");
 226         period_time        = PERIOD_TIME_FOR_MID_LATENCY_MSEC;
 227         sample_per_period  = (samplerate * period_time) / 1000;
 228         periods_per_buffer = PERIODS_PER_BUFFER_DEFAULT;
 229         *prebuf            = 0;
 230         *minreq            = -1;
 231         *tlength           = -1;
 232         *maxlength         = -1;
 233         *fragsize          = _audio_usec_to_bytes(100000, samplerate, format, channels);
 234         break;
 235
 236     case AUDIO_IN_LATENCY_HIGH:
 237         AUDIO_LOG_DEBUG("AUDIO_IN_LATENCY_HIGH");
 238         period_time        = PERIOD_TIME_FOR_HIGH_LATENCY_MSEC;
 239         sample_per_period  = (samplerate * period_time) / 1000;
 240         periods_per_buffer = PERIODS_PER_BUFFER_CAPTURE;
 241         *prebuf            = 0;
 242         *minreq            = -1;
 243         *tlength           = -1;
 244         *maxlength         = -1;
 245         *fragsize          = sample_per_period * _audio_sample_size(format);
 246         break;
 247
 248     case AUDIO_IN_LATENCY_VOIP:
 249         AUDIO_LOG_DEBUG("AUDIO_IN_LATENCY_VOIP");
 250         period_time        = PERIOD_TIME_FOR_VOIP_LATENCY_MSEC;
 251         sample_per_period  = (samplerate * period_time) / 1000;
 252         periods_per_buffer = PERIODS_PER_BUFFER_VOIP;
 253         *prebuf            = 0;
 254         *minreq            = -1;
 255         *tlength           = -1;
 256         *maxlength         = -1;
 257         *fragsize          = sample_per_period * _audio_sample_size(format);
 258         break;
 259
 260     case AUDIO_OUT_LATENCY_LOW:
 261         AUDIO_LOG_DEBUG("AUDIO_OUT_LATENCY_LOW");
 262         period_time        = PERIOD_TIME_FOR_LOW_LATENCY_MSEC;
 263         sample_per_period  = (samplerate * period_time) / 1000;
 264         periods_per_buffer = PERIODS_PER_BUFFER_FASTMODE;
 265         *prebuf            = (samplerate / 100) * _audio_sample_size(format) * channels;
 266         *minreq            = -1;
 267         *tlength           = (samplerate / 10) * _audio_sample_size(format) * channels;
 268         *maxlength         = -1;
 269         *fragsize          = 0;
 270         break;
 271
 272     case AUDIO_OUT_LATENCY_MID:
 273         AUDIO_LOG_DEBUG("AUDIO_OUT_LATENCY_MID");
 274         period_time        = PERIOD_TIME_FOR_MID_LATENCY_MSEC;
 275         sample_per_period  = (samplerate * period_time) / 1000;
 276         periods_per_buffer = PERIODS_PER_BUFFER_DEFAULT;
 277         *prebuf            = -1;
 278         *minreq            = -1;
 279         *tlength           = (uint32_t) _audio_usec_to_bytes(350000, samplerate, format, channels);
 280         *maxlength         = -1;
 281         *fragsize          = -1;
 282         break;
 283
 284     case AUDIO_OUT_LATENCY_HIGH:
 285         AUDIO_LOG_DEBUG("AUDIO_OUT_LATENCY_HIGH");
 286         period_time        = PERIOD_TIME_FOR_HIGH_LATENCY_MSEC;
 287         sample_per_period  = (samplerate * period_time) / 1000;
 288         periods_per_buffer = PERIODS_PER_BUFFER_PLAYBACK;
 289         *prebuf            = 0;
 290         *minreq            = -1;
 291         *tlength           = (uint32_t) _audio_usec_to_bytes(500000, samplerate, format, channels);
 292         *maxlength         = -1;
 293         *fragsize          = -1;
 294         break;
 295
 296     case AUDIO_OUT_LATENCY_VOIP:
 297         AUDIO_LOG_DEBUG("AUDIO_OUT_LATENCY_VOIP");
 298         period_time        = PERIOD_TIME_FOR_VOIP_LATENCY_MSEC;
 299         sample_per_period  = (samplerate * period_time) / 1000;
 300         periods_per_buffer = PERIODS_PER_BUFFER_VOIP;
 301         *prebuf            = -1;
 302         *minreq            = _audio_usec_to_bytes(20000, samplerate, format, channels);
 303         *tlength           = _audio_usec_to_bytes(100000, samplerate, format, channels);
 304         *maxlength         = -1;
 305         *fragsize          = 0;
 306         break;
 307
 308     default:
 309         AUDIO_LOG_ERROR("hal-latency - The latency(%d) is undefined", latency);
 310         return AUDIO_ERR_UNDEFINED;
 311     }
 312
 313     AUDIO_LOG_INFO("hal-latency - return attr --> prebuf:%d, minreq:%d, tlength:%d, maxlength:%d, fragsize:%d", *prebuf, *minreq, *tlength, *maxlength, *fragsize);
 314     return AUDIO_RET_OK;
 315 }