tizen-audio-internal.h

   1 #ifndef footizenaudiointernalfoo
   2 #define footizenaudiointernalfoo
   3
   4 /*
   5  * audio-hal
   6  *
   7  * Copyright (c) 2000 - 2013 Samsung Electronics Co., Ltd. All rights reserved.
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22
  23 #include <dlog.h>
  24 #include <time.h>
  25 #include <sys/types.h>
  26 #include <asoundlib.h>
  27 #ifdef __USE_TINYALSA__
  28 #include <tinyalsa/asoundlib.h>
  29 #endif
  30 #include <time.h>
  31 #include <pthread.h>
  32 #include <use-case.h>
  33 #include "tizen-audio.h"
  34 #include "vb_control_parameters.h"
  35
  36 /* Debug */
  37
  38 //#define AUDIO_DEBUG
  39 #define PROPERTY_VALUE_MAX 92
  40 #define BUF_SIZE 1024
  41 #define AUDIO_DUMP_STR_LEN              256
  42 #define AUDIO_DEVICE_INFO_LIST_MAX      16
  43 #ifdef USE_DLOG
  44 #ifdef DLOG_TAG
  45 #undef DLOG_TAG
  46 #endif
  47 #define DLOG_TAG "AUDIO_HAL"
  48 #define AUDIO_LOG_ERROR(...)            SLOG(LOG_ERROR, DLOG_TAG, __VA_ARGS__)
  49 #define AUDIO_LOG_WARN(...)             SLOG(LOG_WARN, DLOG_TAG, __VA_ARGS__)
  50 #define AUDIO_LOG_INFO(...)             SLOG(LOG_INFO, DLOG_TAG, __VA_ARGS__)
  51 #define AUDIO_LOG_DEBUG(...)            SLOG(LOG_DEBUG, DLOG_TAG, __VA_ARGS__)
  52 #define AUDIO_LOG_VERBOSE(...)          SLOG(LOG_DEBUG, DLOG_TAG, __VA_ARGS__)
  53 #else
  54 #define AUDIO_LOG_ERROR(...)            fprintf(stderr, __VA_ARGS__)
  55 #define AUDIO_LOG_WARN(...)             fprintf(stderr, __VA_ARGS__)
  56 #define AUDIO_LOG_INFO(...)             fprintf(stdout, __VA_ARGS__)
  57 #define AUDIO_LOG_DEBUG(...)            fprintf(stdout, __VA_ARGS__)
  58 #define AUDIO_LOG_VERBOSE(...)          fprintf(stdout, __VA_ARGS__)
  59 #endif
  60
  61 #define AUDIO_RETURN_IF_FAIL(expr) do { \
  62     if (!expr) { \
  63         AUDIO_LOG_ERROR("%s failed", #expr); \
  64         return; \
  65     } \
  66 } while (0)
  67 #define AUDIO_RETURN_VAL_IF_FAIL(expr, val) do { \
  68     if (!expr) { \
  69         AUDIO_LOG_ERROR("%s failed", #expr); \
  70         return val; \
  71     } \
  72 } while (0)
  73 #define AUDIO_RETURN_NULL_IF_FAIL(expr) do { \
  74     if (!expr) { \
  75         AUDIO_LOG_ERROR("%s failed", #expr); \
  76         return NULL; \
  77     } \
  78 } while (0)
  79
  80 #define MUTEX_LOCK(x_lock, lock_name) { \
  81     AUDIO_LOG_DEBUG("try lock [%s]", lock_name); \
  82     pthread_mutex_lock(&(x_lock)); \
  83     AUDIO_LOG_DEBUG("after lock [%s]", lock_name); \
  84 }
  85 #define MUTEX_UNLOCK(x_lock, lock_name) { \
  86     AUDIO_LOG_DEBUG("try unlock [%s]", lock_name); \
  87     pthread_mutex_unlock(&(x_lock)); \
  88     AUDIO_LOG_DEBUG("after unlock [%s]", lock_name); \
  89 }
  90 #define COND_TIMEDWAIT(x_cond, x_lock, x_cond_name, x_timeout_sec) { \
  91     AUDIO_LOG_DEBUG("try cond wait [%s]", x_cond_name); \
  92     struct timespec ts; \
  93     clock_gettime(CLOCK_REALTIME, &ts); \
  94     ts.tv_sec += x_timeout_sec; \
  95     if (!pthread_cond_timedwait(&(x_cond), &(x_lock), &ts)) \
  96         AUDIO_LOG_DEBUG("awaken cond [%s]", x_cond_name); \
  97     else \
  98         AUDIO_LOG_ERROR("awaken cond [%s] by timeout(%d sec)", x_cond_name, x_timeout_sec); \
  99 }
 100 #define COND_SIGNAL(x_cond, x_cond_name) { \
 101     AUDIO_LOG_DEBUG("send signal to cond [%s]", x_cond_name); \
 102     pthread_cond_signal(&(x_cond)); \
 103 }
 104 #define TIMEOUT_SEC 5
 105
 106 /* Signal */
 107 #define SIGNAL_ROUTING_FOR_VOICE_CALL    "routing_voice_call"
 108
 109 /* Devices : Normal  */
 110 #define AUDIO_DEVICE_OUT               0x00000000
 111 #define AUDIO_DEVICE_IN                0x80000000
 112 enum audio_device_type {
 113     AUDIO_DEVICE_NONE                 = 0,
 114
 115     /* output devices */
 116     AUDIO_DEVICE_OUT_SPEAKER          = AUDIO_DEVICE_OUT | 0x00000001,
 117     AUDIO_DEVICE_OUT_RECEIVER         = AUDIO_DEVICE_OUT | 0x00000002,
 118     AUDIO_DEVICE_OUT_JACK             = AUDIO_DEVICE_OUT | 0x00000004,
 119     AUDIO_DEVICE_OUT_BT_SCO           = AUDIO_DEVICE_OUT | 0x00000008,
 120     AUDIO_DEVICE_OUT_ALL              = (AUDIO_DEVICE_OUT_SPEAKER |
 121                                          AUDIO_DEVICE_OUT_RECEIVER |
 122                                          AUDIO_DEVICE_OUT_JACK |
 123                                          AUDIO_DEVICE_OUT_BT_SCO),
 124     /* input devices */
 125     AUDIO_DEVICE_IN_MAIN_MIC          = AUDIO_DEVICE_IN | 0x00000001,
 126     AUDIO_DEVICE_IN_SUB_MIC           = AUDIO_DEVICE_IN | 0x00000002,
 127     AUDIO_DEVICE_IN_JACK              = AUDIO_DEVICE_IN | 0x00000004,
 128     AUDIO_DEVICE_IN_BT_SCO            = AUDIO_DEVICE_IN | 0x00000008,
 129     AUDIO_DEVICE_IN_ALL               = (AUDIO_DEVICE_IN_MAIN_MIC |
 130                                          AUDIO_DEVICE_IN_SUB_MIC |
 131                                          AUDIO_DEVICE_IN_JACK |
 132                                          AUDIO_DEVICE_IN_BT_SCO),
 133 };
 134
 135 typedef struct device_type {
 136     uint32_t type;
 137     const char *name;
 138 } device_type_t;
 139
 140 /* Verbs */
 141 #define AUDIO_USE_CASE_VERB_INACTIVE                "Inactive"
 142 #define AUDIO_USE_CASE_VERB_HIFI                    "HiFi"
 143 #define AUDIO_USE_CASE_VERB_VOICECALL               "Voice"
 144 #define AUDIO_USE_CASE_VERB_LOOPBACK                "Loopback"
 145 #define AUDIO_USE_CASE_VERB_VIDEOCALL               "Video"
 146
 147 /* Modifiers */
 148 #define AUDIO_USE_CASE_MODIFIER_VOICESEARCH              "VoiceSearch"
 149 #define AUDIO_USE_CASE_MODIFIER_CAMCORDING               "Camcording"
 150 #define AUDIO_USE_CASE_MODIFIER_RINGTONE                 "Ringtone"
 151
 152 #define streq !strcmp
 153 #define strneq strcmp
 154
 155 #define ALSA_DEFAULT_CARD       "sprdphone"
 156 #define VOICE_PCM_DEVICE        "hw:sprdphone,1"
 157 #define PLAYBACK_PCM_DEVICE     "hw:sprdphone,0"
 158 #define CAPTURE_PCM_DEVICE      "hw:sprdphone,0"
 159
 160 #define PLAYBACK_CARD_ID        ALSA_DEFAULT_CARD
 161 #define PLAYBACK_PCM_DEVICE_ID  0
 162
 163 #define CAPTURE_CARD_ID         ALSA_DEFAULT_CARD
 164 #define CAPTURE_PCM_DEVICE_ID   0
 165
 166 #define MAX_DEVICES             5
 167 #define MAX_MODIFIERS           5
 168 #define MAX_NAME_LEN           32
 169
 170 /* type definitions */
 171 typedef signed char int8_t;
 172
 173 /* pcm */
 174 typedef struct {
 175     snd_pcm_format_t format;
 176     uint32_t rate;
 177     uint8_t channels;
 178 } audio_pcm_sample_spec_t;
 179
 180 /* Device */
 181 typedef enum audio_device_api {
 182     AUDIO_DEVICE_API_UNKNOWN,
 183     AUDIO_DEVICE_API_ALSA,
 184     AUDIO_DEVICE_API_BLUEZ,
 185 } audio_device_api_t;
 186
 187 typedef struct audio_device_alsa_info {
 188     char *card_name;
 189     uint32_t card_idx;
 190     uint32_t device_idx;
 191 } audio_device_alsa_info_t;
 192
 193 typedef struct audio_device_bluz_info {
 194     char *protocol;
 195     uint32_t nrec;
 196 } audio_device_bluez_info_t;
 197
 198 typedef struct audio_device_info {
 199     audio_device_api_t api;
 200     audio_direction_t direction;
 201     char *name;
 202     uint8_t is_default_device;
 203     union {
 204         audio_device_alsa_info_t alsa;
 205         audio_device_bluez_info_t bluez;
 206     };
 207 } audio_device_info_t;
 208
 209 typedef enum audio_route_mode {
 210     VERB_NORMAL,
 211     VERB_CALL,
 212     VERB_VOIP
 213 } audio_route_mode_t;
 214
 215 typedef struct audio_hal_device {
 216     uint32_t active_in;
 217     uint32_t active_out;
 218     snd_pcm_t *pcm_in;
 219     snd_pcm_t *pcm_out;
 220     pthread_mutex_t pcm_lock;
 221     uint32_t pcm_count;
 222     device_info_t *init_call_devices;
 223     uint32_t num_of_call_devices;
 224     audio_route_mode_t mode;
 225     pthread_cond_t device_cond;
 226     pthread_mutex_t device_lock;
 227 } audio_hal_device_t;
 228
 229 /* Stream */
 230 #define AUDIO_VOLUME_LEVEL_MAX 16
 231
 232 typedef enum audio_volume {
 233     AUDIO_VOLUME_TYPE_SYSTEM,           /**< System volume type */
 234     AUDIO_VOLUME_TYPE_NOTIFICATION,     /**< Notification volume type */
 235     AUDIO_VOLUME_TYPE_ALARM,            /**< Alarm volume type */
 236     AUDIO_VOLUME_TYPE_RINGTONE,         /**< Ringtone volume type */
 237     AUDIO_VOLUME_TYPE_MEDIA,            /**< Media volume type */
 238     AUDIO_VOLUME_TYPE_CALL,             /**< Call volume type */
 239     AUDIO_VOLUME_TYPE_VOIP,             /**< VOIP volume type */
 240     AUDIO_VOLUME_TYPE_VOICE,            /**< Voice volume type */
 241     AUDIO_VOLUME_TYPE_MAX,              /**< Volume type count */
 242 } audio_volume_t;
 243
 244 typedef enum audio_gain {
 245     AUDIO_GAIN_TYPE_DEFAULT,
 246     AUDIO_GAIN_TYPE_DIALER,
 247     AUDIO_GAIN_TYPE_TOUCH,
 248     AUDIO_GAIN_TYPE_AF,
 249     AUDIO_GAIN_TYPE_SHUTTER1,
 250     AUDIO_GAIN_TYPE_SHUTTER2,
 251     AUDIO_GAIN_TYPE_CAMCODING,
 252     AUDIO_GAIN_TYPE_MIDI,
 253     AUDIO_GAIN_TYPE_BOOTING,
 254     AUDIO_GAIN_TYPE_VIDEO,
 255     AUDIO_GAIN_TYPE_TTS,
 256     AUDIO_GAIN_TYPE_MAX,
 257 } audio_gain_t;
 258
 259 typedef struct audio_volume_value_table {
 260     double volume[AUDIO_VOLUME_TYPE_MAX][AUDIO_VOLUME_LEVEL_MAX];
 261     uint32_t volume_level_max[AUDIO_VOLUME_LEVEL_MAX];
 262     double gain[AUDIO_GAIN_TYPE_MAX];
 263 } audio_volume_value_table_t;
 264
 265 enum {
 266     AUDIO_VOLUME_DEVICE_DEFAULT,
 267     AUDIO_VOLUME_DEVICE_MAX,
 268 };
 269
 270 typedef struct audio_hal_volume {
 271     uint32_t volume_level[AUDIO_VOLUME_TYPE_MAX];
 272     audio_volume_value_table_t *volume_value_table;
 273 } audio_hal_volume_t;
 274
 275 typedef struct audio_hal_ucm {
 276     snd_use_case_mgr_t* uc_mgr;
 277 } audio_hal_ucm_t;
 278
 279 typedef struct audio_hal_mixer {
 280     snd_mixer_t *mixer;
 281     pthread_mutex_t mutex;
 282     struct {
 283         snd_ctl_elem_value_t *value;
 284         snd_ctl_elem_id_t *id;
 285         snd_ctl_elem_info_t *info;
 286     } control;
 287 } audio_hal_mixer_t;
 288
 289 /* Audio format */
 290 typedef enum audio_sample_format {
 291     AUDIO_SAMPLE_U8,
 292     AUDIO_SAMPLE_ALAW,
 293     AUDIO_SAMPLE_ULAW,
 294     AUDIO_SAMPLE_S16LE,
 295     AUDIO_SAMPLE_S16BE,
 296     AUDIO_SAMPLE_FLOAT32LE,
 297     AUDIO_SAMPLE_FLOAT32BE,
 298     AUDIO_SAMPLE_S32LE,
 299     AUDIO_SAMPLE_S32BE,
 300     AUDIO_SAMPLE_S24LE,
 301     AUDIO_SAMPLE_S24BE,
 302     AUDIO_SAMPLE_S24_32LE,
 303     AUDIO_SAMPLE_S24_32BE,
 304     AUDIO_SAMPLE_MAX,
 305     AUDIO_SAMPLE_INVALID = -1
 306 } audio_sample_format_t;
 307
 308 typedef struct audio_hal_modem {
 309
 310     struct {
 311         pthread_t voice_thread_handle;
 312         pthread_t voip_thread_handle;
 313         snd_pcm_t *voice_pcm_handle_p;
 314         snd_pcm_t *voice_pcm_handle_c;
 315         int exit_vbc_thread;
 316         int vbpipe_fd;
 317         int vbpipe_voip_fd;
 318         unsigned short vbpipe_count;
 319     } vbc;
 320
 321     struct {
 322         int fd;
 323     } at_cmd;
 324
 325     audio_modem_t  *cp;
 326     cp_type_t cp_type;
 327
 328     int samplerate;
 329     int sim_id;
 330     int is_connected;
 331 } audio_hal_modem_t;
 332
 333 typedef struct audio_hal_comm {
 334     message_cb msg_cb;
 335     void *user_data;
 336 } audio_hal_comm_t;
 337
 338 /* Overall */
 339 typedef struct audio_hal {
 340     audio_hal_device_t device;
 341     audio_hal_volume_t volume;
 342     audio_hal_ucm_t ucm;
 343     audio_hal_mixer_t mixer;
 344     audio_hal_modem_t modem;
 345     audio_hal_comm_t comm;
 346 } audio_hal_t;
 347
 348 audio_return_t _audio_volume_init(audio_hal_t *ah);
 349 audio_return_t _audio_volume_deinit(audio_hal_t *ah);
 350 audio_return_t _audio_device_init(audio_hal_t *ah);
 351 audio_return_t _audio_device_deinit(audio_hal_t *ah);
 352 audio_return_t _audio_ucm_init(audio_hal_t *ah);
 353 audio_return_t _audio_ucm_deinit(audio_hal_t *ah);
 354 audio_return_t _audio_modem_init(audio_hal_t *ah);
 355 audio_return_t _audio_modem_deinit(audio_hal_t *ah);
 356 audio_return_t _audio_comm_init(audio_hal_t *ah);
 357 audio_return_t _audio_comm_deinit(audio_hal_t *ah);
 358 audio_return_t _audio_util_init(audio_hal_t *ah);
 359 audio_return_t _audio_util_deinit(audio_hal_t *ah);
 360
 361 audio_return_t _audio_do_route_voicecall(audio_hal_t *ah, device_info_t *devices, int32_t num_of_devices);
 362 void _audio_ucm_get_device_name(audio_hal_t *ah, const char *use_case, audio_direction_t direction, const char **value);
 363 #define _audio_ucm_update_use_case _audio_ucm_set_use_case
 364 audio_return_t _audio_ucm_set_use_case(audio_hal_t *ah, const char *verb, const char *devices[], const char *modifiers[]);
 365 audio_return_t _audio_ucm_set_devices(audio_hal_t *ah, const char *verb, const char *devices[]);
 366 audio_return_t _audio_ucm_set_modifiers(audio_hal_t *ah, const char *verb, const char *modifiers[]);
 367 int _audio_ucm_fill_device_info_list(audio_hal_t *ah, audio_device_info_t *device_info_list, const char *verb);
 368 audio_return_t _audio_ucm_get_verb(audio_hal_t *ah, const char **value);
 369 audio_return_t _audio_ucm_reset_use_case(audio_hal_t *ah);
 370 int _audio_modem_is_call_connected(audio_hal_t *ah);
 371 audio_return_t _audio_comm_send_message(audio_hal_t *ah, const char *name, int value);
 372 audio_return_t _audio_mixer_control_set_param(audio_hal_t *ah, const char* ctl_name, snd_ctl_elem_value_t* value, int size);
 373 audio_return_t _audio_mixer_control_set_value(audio_hal_t *ah, const char *ctl_name, int val);
 374 audio_return_t _audio_mixer_control_set_value_string(audio_hal_t *ah, const char* ctl_name, const char* value);
 375 audio_return_t _audio_mixer_control_get_value(audio_hal_t *ah, const char *ctl_name, int *val);
 376 audio_return_t _audio_mixer_control_get_element(audio_hal_t *ah, const char *ctl_name, snd_hctl_elem_t **elem);
 377 audio_return_t _audio_pcm_set_sw_params(snd_pcm_t *pcm, snd_pcm_uframes_t avail_min, uint8_t period_event);
 378 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);
 379 uint32_t _convert_format(audio_sample_format_t format);
 380
 381 typedef struct _dump_data {
 382     char *strbuf;
 383     int left;
 384     char *p;
 385 } dump_data_t;
 386
 387 dump_data_t* dump_new(int length);
 388 void dump_add_str(dump_data_t *dump, const char *fmt, ...);
 389 char* dump_get_str(dump_data_t *dump);
 390 void dump_free(dump_data_t *dump);
 391
 392 #endif