avsys-audio.c

   1 /*
   2  * avsystem
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 #include <stdlib.h>
  23 #include <stdio.h>
  24 #include <pthread.h>
  25 #include <time.h>
  26 #include <sys/types.h>
  27 #include <sys/time.h>
  28 #include <unistd.h>
  29 #include <sys/syscall.h>
  30 #include <signal.h>
  31 #include <string.h>
  32 #include <fcntl.h>
  33
  34 #include "avsys-types.h"
  35 #include "avsys-error.h"
  36 #include "avsys-debug.h"
  37 #include "avsys-audio.h"
  38 #include "avsys-audio-logical-volume.h"
  39 #include "avsys-common.h"
  40
  41 #include "avsys-audio-path.h"
  42 #include "avsys-audio-alsa.h"
  43
  44 #include "avsys-audio-pasimple.h"
  45 #include "avsys-audio-pactrl.h"
  46
  47 /**
  48  * Internal functions definition
  49  */
  50 #define FADEUP_CALC_BIAS        (1)
  51
  52 static int __avsys_audio_set_info(avsys_audio_handle_t *p, avsys_audio_param_t *param);
  53
  54 void __init_module(void);
  55 void __fini_module(void);
  56
  57 #define AVSYS_GET_HANDLE_PTR(MODE) do { \
  58         err = avsys_audio_handle_get_ptr((int)handle, &p, MODE);        \
  59         if (AVSYS_FAIL(err)) {  \
  60                 return err;     \
  61         }       \
  62 } while (0)
  63
  64 #define AVSYS_RELEASE_HANDLE_PTR(MODE) do {     \
  65         if (AVSYS_FAIL(avsys_audio_handle_release_ptr((int)handle, MODE))) {    \
  66                 avsys_error(AVAUDIO, "audio handle release failed\n");  \
  67                 return AVSYS_STATE_ERR_INTERNAL;        \
  68         }       \
  69 } while (0)
  70
  71 #define AVSYS_STREAM_LOCK() do {        \
  72         pthread_mutex_lock(&gmutex);\
  73         avsys_info(AVAUDIO, "(+) LOCKED\n");    \
  74 } while (0)
  75
  76 #define AVSYS_STREAM_UNLOCK() do {      \
  77         pthread_mutex_unlock(&gmutex);\
  78         avsys_info(AVAUDIO, "(-) UNLOCKED\n");  \
  79 } while (0)
  80
  81 /**
  82  * Internal global variable
  83  */
  84 static pthread_mutex_t gmutex = PTHREAD_MUTEX_INITIALIZER;
  85
  86
  87 /****************************************************************************
  88  *
  89  *  Interface
  90  *
  91  ***************************************************************************/
  92 EXPORT_API
  93 int avsys_audio_open(avsys_audio_param_t *param, avsys_handle_t *phandle, int *size)
  94 {
  95         int handle = -1;
  96         avsys_audio_handle_t *p = NULL;
  97         int err = AVSYS_STATE_ERR_UNKNOWN;
  98
  99         avsys_info(AVAUDIO, "%s\n", __func__);
 100
 101         if (param == NULL || phandle == NULL) {
 102                 avsys_error(AVAUDIO, "param or phandle is null\n");
 103                 return AVSYS_STATE_ERR_NULL_POINTER;
 104         }
 105
 106         if (param->channels > 2 || param->channels < 1) {
 107                 return AVSYS_STATE_ERR_INVALID_CHANNEL;
 108         }
 109
 110         if (param->mode < AVSYS_AUDIO_MODE_OUTPUT || param->mode >= AVSYS_AUDIO_MODE_NUM) {
 111                 return AVSYS_STATE_ERR_INVALID_MODE;
 112         }
 113
 114         if (param->format < AVSYS_AUDIO_FORMAT_MIN || param->format > AVSYS_AUDIO_FORMAT_MAX) {
 115                 return AVSYS_STATE_ERR_INVALID_FORMAT;
 116         }
 117
 118         AVSYS_STREAM_LOCK();
 119
 120         err = avsys_audio_handle_rejuvenation();
 121         if (AVSYS_FAIL(err)) {
 122                 avsys_error(AVAUDIO, "Unused handle cleanup before handle allocation failed in %s\n", __func__);
 123                 goto error;
 124         }
 125         err = avsys_audio_handle_alloc(&handle);
 126         if (AVSYS_STATE_ERR_RANGE_OVER == err) {
 127                 avsys_error(AVAUDIO, "audio handle is fully allocated..try cleanup\n");
 128                 err = avsys_audio_handle_rejuvenation();
 129                 if (AVSYS_FAIL(err)) {
 130                         avsys_error(AVAUDIO, "Unused handle cleanup failed in %s\n", __func__);
 131                         goto error;
 132                 }
 133                 avsys_error(AVAUDIO, "one more try...to allocate audio handle\n");
 134                 err = avsys_audio_handle_alloc(&handle);
 135                 if (AVSYS_FAIL(err)) {
 136                         avsys_error(AVAUDIO, "handle alloc failed 1 in %s\n", __func__);
 137                         goto error;
 138                 }
 139         } else if ((AVSYS_FAIL(err)) && (err != AVSYS_STATE_ERR_RANGE_OVER)) {
 140                 avsys_error(AVAUDIO, "handle alloc failed 2 in %s\n", __func__);
 141                 goto error;
 142         }
 143
 144         err = avsys_audio_handle_get_ptr(handle, &p, HANDLE_PTR_MODE_NORMAL);
 145         if (AVSYS_FAIL(err)) {
 146                 goto error;
 147         }
 148
 149         /* set information to handle */
 150         err = __avsys_audio_set_info(p, param);
 151         if (AVSYS_FAIL(err)) {
 152                 goto error;
 153         }
 154
 155         if (p->mode == AVSYS_AUDIO_MODE_OUTPUT || p->mode == AVSYS_AUDIO_MODE_OUTPUT_CLOCK ||
 156                 p->mode == AVSYS_AUDIO_MODE_OUTPUT_LOW_LATENCY || p->mode == AVSYS_AUDIO_MODE_OUTPUT_AP_CALL || p->mode == AVSYS_AUDIO_MODE_OUTPUT_VIDEO) {
 157                 /* set volume table */
 158                 err = avsys_audio_path_set_volume(handle);
 159                 if (AVSYS_FAIL(err)) {
 160                         goto error;
 161                 }
 162
 163                 /* update volume by type */
 164                 err = avsys_audio_handle_update_volume(p, p->gain_setting.vol_type);
 165                 if (AVSYS_FAIL(err)) {
 166                         goto error;
 167                 }
 168                 err = avsys_audio_handle_update_priority(handle, param->priority, param->handle_route, AVSYS_AUDIO_SET_PRIORITY);
 169                 if (AVSYS_FAIL(err)) {
 170                         goto error;
 171                 }
 172         }
 173
 174         /* open device */
 175         err = avsys_audio_pasimple_open_device(p->mode, p->format, p->channels, p->samplerate, p, param->handle_route);
 176         if (AVSYS_FAIL(err)) {
 177                 goto error;
 178         }
 179         switch (p->mode) {
 180         case AVSYS_AUDIO_MODE_OUTPUT:
 181         case AVSYS_AUDIO_MODE_OUTPUT_CLOCK:
 182         case AVSYS_AUDIO_MODE_OUTPUT_LOW_LATENCY:
 183         case AVSYS_AUDIO_MODE_OUTPUT_VIDEO:
 184         case AVSYS_AUDIO_MODE_OUTPUT_AP_CALL:
 185                 if (AVSYS_FAIL(avsys_audio_pasimple_set_volume(p, p->working_vol.level[AVSYS_AUDIO_CHANNEL_LEFT]))) {
 186                         avsys_error(AVAUDIO, "can not set volume in %s\n", __func__);
 187                 }
 188                 break;
 189         default:
 190                 break;
 191         }
 192
 193         *phandle = (avsys_handle_t) handle;
 194         /* set recommended buffer size */
 195         if (size != NULL)
 196                 *size = p->period;
 197         else
 198                 avsys_warning(AVAUDIO, "Size is null\n");
 199
 200         err = avsys_audio_handle_release_ptr(handle, HANDLE_PTR_MODE_NORMAL);
 201         if (AVSYS_FAIL(err)) {
 202                 goto error;
 203         }
 204         AVSYS_STREAM_UNLOCK();
 205         return AVSYS_STATE_SUCCESS;
 206
 207 error:
 208         if (p) {
 209                 avsys_audio_handle_release_ptr(handle, HANDLE_PTR_MODE_NORMAL);
 210         }
 211
 212         if (handle != -1) {
 213                 if (AVSYS_FAIL(avsys_audio_handle_free(handle))) {
 214                         avsys_error(AVAUDIO, "Can not free handle %d\n", handle);
 215                 }
 216         }
 217
 218         avsys_error(AVAUDIO, "failed to open : RESION %x\n", err);
 219
 220         *phandle = (avsys_handle_t)-1;
 221         AVSYS_STREAM_UNLOCK();
 222         return err;
 223 }
 224
 225 EXPORT_API
 226 int avsys_audio_close(avsys_handle_t handle)
 227 {
 228         avsys_audio_handle_t *p = NULL;
 229         int err = AVSYS_STATE_ERR_UNKNOWN;
 230         bool cp_audio = false;
 231         bool bt_path = false;
 232
 233         AVSYS_STREAM_LOCK();
 234         avsys_info(AVAUDIO, "%s, handle=[%d]\n", __func__, (int)handle);
 235
 236         err = avsys_audio_handle_get_ptr((int)handle, &p, HANDLE_PTR_MODE_NORMAL);
 237         if (AVSYS_FAIL(err)) {
 238                 AVSYS_STREAM_UNLOCK();
 239                 return err;
 240         }
 241
 242         if (AVSYS_FAIL(avsys_audio_handle_update_priority((int)handle, p->priority, AVSYS_AUDIO_HANDLE_ROUTE_FOLLOWING_POLICY, AVSYS_AUDIO_UNSET_PRIORITY))) {
 243                 avsys_error(AVAUDIO, "unset priority of handle %d error: %x\n", handle, err);
 244         }
 245
 246         err = avsys_audio_pasimple_close_device(p);
 247         if (AVSYS_FAIL(err)) {
 248                 avsys_error_r(AVAUDIO, "audio device close error : %x\n", err);
 249         }
 250
 251         if (AVSYS_FAIL(avsys_audio_path_check_cp_audio(&cp_audio, &bt_path))) {
 252                 avsys_error(AVAUDIO, "Can not check cp audio status\n");
 253         }
 254
 255         if (p->during_cp_audio && cp_audio && bt_path) {
 256                 /* set cp bt path again */
 257                 avsys_audio_path_set_single_ascn("cp_to_bt");
 258         }
 259
 260         if (AVSYS_FAIL(avsys_audio_handle_release_ptr((int)handle, HANDLE_PTR_MODE_NORMAL))) {
 261                 avsys_error(AVAUDIO, "audio handle release failed\n");
 262                 AVSYS_STREAM_UNLOCK();
 263                 return AVSYS_STATE_ERR_INTERNAL;
 264         }
 265
 266         avsys_audio_handle_free((int)handle);
 267
 268         AVSYS_STREAM_UNLOCK();
 269
 270         return err;
 271 }
 272
 273 EXPORT_API
 274 int avsys_audio_ampon(void)
 275 {
 276         avsys_info(AVAUDIO, "%s\n", __func__);
 277         return avsys_audio_path_ex_set_amp(AVSYS_AUDIO_AMP_ON);
 278 }
 279
 280 EXPORT_API
 281 int avsys_audio_ampoff(void)
 282 {
 283         avsys_info(AVAUDIO, "%s\n", __func__);
 284         return avsys_audio_path_ex_set_amp(AVSYS_AUDIO_AMP_OFF);
 285 }
 286
 287
 288 EXPORT_API
 289 int avsys_audio_ext_device_ampon(avsysaudio_ext_device_t device_type)
 290 {
 291         avsys_info(AVAUDIO, "%s\n", __func__);
 292         return avsys_audio_handle_ext_dev_set_mute(device_type, AVSYS_AUDIO_UNMUTE);
 293 }
 294
 295 EXPORT_API
 296 int avsys_audio_ext_device_ampoff(avsysaudio_ext_device_t device_type)
 297 {
 298         avsys_info(AVAUDIO, "%s\n", __func__);
 299         return avsys_audio_handle_ext_dev_set_mute(device_type, AVSYS_AUDIO_MUTE);
 300 }
 301
 302 EXPORT_API
 303 int avsys_audio_set_ext_device_status(avsysaudio_ext_device_t device_type, int onoff)
 304 {
 305         avsys_info(AVAUDIO, "%s\n", __func__);
 306         return avsys_audio_handle_ext_dev_status_update(device_type, onoff);
 307 }
 308
 309 EXPORT_API
 310 int avsys_audio_get_ext_device_status(avsysaudio_ext_device_t device_type, int *onoff)
 311 {
 312         avsys_info(AVAUDIO, "%s\n", __func__);
 313         return avsys_audio_handle_ext_dev_status(device_type, onoff);
 314 }
 315
 316 EXPORT_API
 317 int avsys_audio_flush(avsys_handle_t handle)
 318 {
 319         int err = AVSYS_STATE_SUCCESS;
 320         avsys_audio_handle_t *p = NULL;
 321         avsys_info(AVAUDIO, "%s\n", __func__);
 322
 323         AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
 324
 325         err = avsys_audio_pasimple_reset(p);
 326
 327         AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
 328
 329         return err;
 330 }
 331
 332 EXPORT_API
 333 int avsys_audio_drain(avsys_handle_t handle)
 334 {
 335         int err = AVSYS_STATE_SUCCESS;
 336         avsys_audio_handle_t *p = NULL;
 337         avsys_info(AVAUDIO, "%s\n", __func__);
 338
 339         AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
 340
 341         err = avsys_audio_pasimple_drain(p);
 342
 343         AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
 344
 345         return err;
 346 }
 347
 348 EXPORT_API
 349 int avsys_audio_read(avsys_handle_t handle, void *buf, int size)
 350 {
 351         int err = AVSYS_STATE_SUCCESS;
 352         avsys_audio_handle_t *p = NULL;
 353
 354         avsys_info(AVAUDIO, "%s\n", __func__);
 355
 356         if (buf == NULL) {
 357                 avsys_error(AVAUDIO, "input buffer pointer is null\n");
 358                 return AVSYS_STATE_ERR_NULL_POINTER;
 359         }
 360
 361         AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_FAST);
 362
 363         if (p->mode != AVSYS_AUDIO_MODE_INPUT && p->mode != AVSYS_AUDIO_MODE_INPUT_LOW_LATENCY &&
 364                 p->mode != AVSYS_AUDIO_MODE_INPUT_HIGH_LATENCY && p->mode != AVSYS_AUDIO_MODE_INPUT_AP_CALL) {
 365                 avsys_error(AVAUDIO, "opened output mode\n");
 366                 return AVSYS_STATE_ERR_INVALID_MODE;
 367         }
 368
 369         err = avsys_audio_pasimple_read(p, buf, size);
 370
 371         AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_FAST);
 372
 373         return err;
 374 }
 375
 376 EXPORT_API
 377 int avsys_audio_write(avsys_handle_t handle, void *buf, int size)
 378 {
 379         int err = AVSYS_STATE_SUCCESS;
 380         avsys_audio_handle_t *p = NULL;
 381
 382         avsys_info(AVAUDIO, "%s\n", __func__);
 383
 384         if (buf == NULL) {
 385                 avsys_error(AVAUDIO, "buf is null\n");
 386                 return AVSYS_STATE_ERR_NULL_POINTER;
 387         }
 388
 389         AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_FAST);
 390
 391         if (p->mode != AVSYS_AUDIO_MODE_OUTPUT && p->mode != AVSYS_AUDIO_MODE_OUTPUT_CLOCK &&
 392                 p->mode != AVSYS_AUDIO_MODE_OUTPUT_LOW_LATENCY && p->mode != AVSYS_AUDIO_MODE_OUTPUT_AP_CALL && p->mode != AVSYS_AUDIO_MODE_OUTPUT_VIDEO) {
 393                 avsys_error(AVAUDIO, "opened input mode\n");
 394                 avsys_audio_handle_release_ptr((int)handle, HANDLE_PTR_MODE_FAST);
 395                 return AVSYS_STATE_ERR_INVALID_MODE;
 396         }
 397
 398         if (p->fadeup_vol > 1) {
 399                 if (p->fadeup_multiplier == 0) {
 400                         avsys_audio_volume_t fade_volume;
 401                         fade_volume.level[AVSYS_AUDIO_CHANNEL_LEFT] = p->setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT] - (p->fadeup_vol - FADEUP_CALC_BIAS);
 402                         fade_volume.level[AVSYS_AUDIO_CHANNEL_RIGHT] = p->setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT] - (p->fadeup_vol - FADEUP_CALC_BIAS);
 403
 404                         if (fade_volume.level[AVSYS_AUDIO_CHANNEL_LEFT] < 0) {
 405                                 fade_volume.level[AVSYS_AUDIO_CHANNEL_LEFT] = 0;
 406                         }
 407                         if (fade_volume.level[AVSYS_AUDIO_CHANNEL_RIGHT] < 0) {
 408                                 fade_volume.level[AVSYS_AUDIO_CHANNEL_RIGHT] = 0;
 409                         }
 410
 411                         avsys_info(AVAUDIO, "fade_volume : %d (%d-(%d)+%d) p->fadeup_m = %d, p->msec_per_period = %d\n",
 412                                                 fade_volume.level[AVSYS_AUDIO_CHANNEL_LEFT],p->setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT],p->fadeup_vol,FADEUP_CALC_BIAS,
 413                                                 p->fadeup_multiplier, p->msec_per_period
 414                                                 );
 415
 416                         avsys_audio_logical_volume_convert(&fade_volume, &p->working_vol, &p->gain_setting);
 417                         avsys_audio_pasimple_set_volume(p, p->working_vol.level[AVSYS_AUDIO_CHANNEL_LEFT]);
 418                         p->fadeup_vol--;
 419                         if (p->msec_per_period > 50)
 420                                 p->fadeup_multiplier = 0;
 421                         else
 422                                 p->fadeup_multiplier = FADE_UP_MULTIPLIER;
 423                 } else {
 424                         p->fadeup_multiplier--;
 425                 }
 426         } else if (p->fadeup_vol <= -1) {
 427                 if (p->fadeup_multiplier == 0) {
 428                         int fadedown_vol = 0;
 429                         avsys_audio_volume_t fade_volume;
 430
 431                         fadedown_vol = (-1) * (p->fadeup_vol) - FADEUP_CALC_BIAS;
 432                         fade_volume.level[AVSYS_AUDIO_CHANNEL_LEFT] = fadedown_vol;
 433                         fade_volume.level[AVSYS_AUDIO_CHANNEL_RIGHT] = fadedown_vol;
 434
 435                         if (fade_volume.level[AVSYS_AUDIO_CHANNEL_LEFT] < 0) {
 436                                 fade_volume.level[AVSYS_AUDIO_CHANNEL_LEFT] = 0;
 437                         }
 438                         if (fade_volume.level[AVSYS_AUDIO_CHANNEL_RIGHT] < 0) {
 439                                 fade_volume.level[AVSYS_AUDIO_CHANNEL_RIGHT] = 0;
 440                         }
 441
 442                         avsys_info(AVAUDIO, "fade_volume : %d (%d-%d) p->fadeup_m = %d, p->msec_per_period = %d\n",
 443                                         fade_volume.level[AVSYS_AUDIO_CHANNEL_LEFT],p->fadeup_vol,FADEUP_CALC_BIAS,
 444                                         p->fadeup_multiplier, p->msec_per_period);
 445
 446                         avsys_audio_logical_volume_convert(&fade_volume, &p->working_vol, &p->gain_setting);
 447                         avsys_audio_pasimple_set_volume(p, p->working_vol.level[AVSYS_AUDIO_CHANNEL_LEFT]);
 448                         if (p->fadeup_vol < -1) {
 449                                 p->fadeup_vol++;
 450                         } else if (p->fadeup_vol == -1) {
 451                                 p->mute = AVSYS_AUDIO_MUTE;
 452                         }
 453                         if (p->msec_per_period > 50)
 454                                 p->fadeup_multiplier = 0;
 455                         else
 456                                 p->fadeup_multiplier = FADE_DOWN_MULTIPLIER;
 457                 } else {
 458                         p->fadeup_multiplier--;
 459                 }
 460         }
 461         err = avsys_audio_pasimple_write(p, buf, size);
 462
 463         AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_FAST);
 464
 465         return err;
 466 }
 467
 468 EXPORT_API
 469 int avsys_audio_set_volume_fadeup(avsys_handle_t handle)
 470 {
 471         int err = AVSYS_STATE_SUCCESS;
 472         avsys_audio_handle_t *p = NULL;
 473
 474         avsys_warning(AVAUDIO, "%s\n", __func__);
 475
 476         AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
 477
 478         if (p->setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT] >= p->setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT]) {
 479                 p->fadeup_vol = p->setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT]; /* + FADEUP_CALC_BIAS */
 480         } else {
 481                 p->fadeup_vol = p->setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT]; /* + FADEUP_CALC_BIAS; */
 482         }
 483         p->fadeup_multiplier = 0;
 484
 485         AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
 486
 487         return err;
 488 }
 489
 490 EXPORT_API
 491 int avsys_audio_set_mute_fadedown(avsys_handle_t handle)
 492 {
 493         int err = AVSYS_STATE_SUCCESS;
 494         avsys_audio_handle_t *p = NULL;
 495
 496         avsys_warning(AVAUDIO, "%s\n", __func__);
 497
 498         AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
 499
 500         if (p->setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT] >= p->setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT]) {
 501                 p->fadeup_vol = (-1) * p->setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT];
 502         } else {
 503                 p->fadeup_vol = (-1) * p->setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT];
 504         }
 505         p->fadeup_multiplier = 0;
 506
 507         AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
 508
 509         return err;
 510 }
 511
 512 /* Tuning part */
 513 EXPORT_API
 514 int avsys_audio_set_volume_table(int gain_type, int dev_type, int step, int lv, int rv)
 515 {
 516         int ret = avsys_audio_logical_volume_set_to_table(gain_type, dev_type, step, lv, rv);
 517         avsys_audio_handle_t *ptr = NULL;
 518         int handle = -1;
 519
 520         if (AVSYS_FAIL(ret)) {
 521                 return ret;
 522         }
 523
 524         while(++handle < AVSYS_AUDIO_HANDLE_MAX) {
 525                 ptr = NULL;
 526
 527                 if (AVSYS_SUCCESS(avsys_audio_handle_get_ptr(handle, &ptr, HANDLE_PTR_MODE_NORMAL))) {
 528                         avsys_audio_logical_volume_convert(&ptr->setting_vol, &ptr->working_vol, &ptr->gain_setting);
 529                         avsys_audio_handle_release_ptr(handle, HANDLE_PTR_MODE_NORMAL);
 530                 }
 531         }
 532         return AVSYS_STATE_SUCCESS;
 533 }
 534
 535 EXPORT_API
 536 int avsys_audio_get_volume_table(int gain_type, int dev_type, int step, int *lv, int *rv)
 537 {
 538         return avsys_audio_logical_volume_get_from_table(gain_type, dev_type, step, lv, rv);
 539 }
 540
 541 EXPORT_API
 542 int avsys_audio_get_volume_max_ex(int volume_type, int *max_step)
 543 {
 544         int volume_table = 0;
 545         if (max_step == NULL) {
 546                 return AVSYS_STATE_ERR_NULL_POINTER;
 547         }
 548
 549         volume_table = volume_type;
 550
 551         return avsys_audio_logical_volume_get_max(volume_table, AVSYS_AUDIO_LVOL_DEV_TYPE_SPK, max_step);
 552 }
 553
 554 EXPORT_API
 555 int avsys_audio_set_mute(avsys_handle_t handle, int mute)
 556 {
 557         avsys_info(AVAUDIO, "%s\n", __func__);
 558
 559         if (mute > AVSYS_AUDIO_MUTE || mute < AVSYS_AUDIO_UNMUTE) {
 560                 return AVSYS_STATE_ERR_INVALID_PARAMETER;
 561         }
 562
 563         if (AVSYS_FAIL(avsys_audio_handle_set_mute((int)handle, mute))) {
 564                 avsys_error(AVAUDIO, "failed to set handle mute\n");
 565         }
 566
 567         return AVSYS_STATE_SUCCESS;
 568 }
 569
 570 EXPORT_API
 571 int avsys_audio_get_mute(avsys_handle_t handle, int *pmute)
 572 {
 573         int err = AVSYS_STATE_SUCCESS;
 574         avsys_audio_handle_t *p = NULL;
 575
 576         avsys_info(AVAUDIO, "%s\n", __func__);
 577
 578         if (pmute == NULL) {
 579                 avsys_error(AVAUDIO, "pvolume is null\n");
 580                 return AVSYS_STATE_ERR_NULL_POINTER;
 581         }
 582
 583         AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
 584
 585         *pmute = p->mute;
 586
 587         AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
 588
 589         return AVSYS_STATE_SUCCESS;
 590 }
 591
 592 /*
 593  * Option : AVSYS_AUDIO_PATH_OPTION_LEGACY_MODE support NowPlus style sound path function
 594  * Option : AVSYS_AUDIO_PATH_OPTION_DUAL_OUT will effect only when out is speaker.
 595  * Option : AVSYS_AUDIO_PATH_OPTION_JACK_AUTO will effect only when out is speaker or receiver.
 596  * Option : AVSYS_AUDIO_PATH_OPTION_FORCED is avail only for shutdown animation
 597  *
 598  * Limitation : Only FORCED option can be used same time with other options (exclude LEGACY_MODE)
 599  */
 600 EXPORT_API
 601 int avsys_audio_set_path_ex(int gain, int out, int in, int option)
 602 {
 603         if (AVSYS_AUDIO_GAIN_EX_KEYTONE > gain || AVSYS_AUDIO_GAIN_EX_MAX <= gain ||
 604                 AVSYS_AUDIO_PATH_EX_NONE > out || AVSYS_AUDIO_PATH_EX_OUTMAX <= out ||
 605                 AVSYS_AUDIO_PATH_EX_NONE > in || AVSYS_AUDIO_PATH_EX_INMAX <= in) {
 606                 avsys_error(AVAUDIO, "Your input parameter is invalid. Please check\n");
 607                 avsys_error(AVAUDIO, " gain %d, out %d, in %d\n", gain, out, in);
 608                 return AVSYS_STATE_ERR_INVALID_PARAMETER;
 609         }
 610
 611         return avsys_audio_path_ex_set_path(gain, out, in, option);
 612 }
 613 EXPORT_API
 614 int avsys_audio_get_path_ex(int *gain, int *out, int *in, int *option)
 615 {
 616         if (!gain || !out || !in || !option) {
 617                 avsys_warning(AVAUDIO, "Your input parameter is NULL pointer. Please check.\n");
 618                 avsys_warning(AVAUDIO, " gain %p, out %p, in %p, option %p\n", gain, out, in, option);
 619                 return AVSYS_STATE_ERR_INVALID_PARAMETER;
 620         }
 621         return avsys_audio_path_ex_get_path(gain, out, in, option);
 622 }
 623
 624 EXPORT_API
 625 int avsys_audio_set_global_mute(int mute)
 626 {
 627         int err = AVSYS_STATE_SUCCESS;
 628
 629         avsys_info(AVAUDIO, "%s : mute=%d\n", __func__, mute);
 630
 631         if (mute < AVSYS_AUDIO_UNMUTE && mute > AVSYS_AUDIO_MUTE_NOLOCK) {
 632                 err = AVSYS_STATE_ERR_INVALID_PARAMETER;
 633         } else {
 634                 err = avsys_audio_path_ex_set_mute(mute);
 635         }
 636         return err;
 637 }
 638
 639 EXPORT_API
 640 int avsys_audio_get_global_mute(int *pmute)
 641 {
 642         int err = AVSYS_STATE_SUCCESS;
 643
 644         avsys_info(AVAUDIO, "%s\n", __func__);
 645         if (pmute == NULL) {
 646                 err = AVSYS_STATE_ERR_NULL_POINTER;
 647         } else {
 648                 err = avsys_audio_path_ex_get_mute(pmute);
 649         }
 650         return err;
 651 }
 652
 653 /**
 654  * Internal functions implementation
 655  */
 656
 657 static int __avsys_audio_set_info(avsys_audio_handle_t *p, avsys_audio_param_t *param)
 658 {
 659         avsys_info(AVAUDIO, "%s\n", __func__);
 660
 661         avsys_info(AVAUDIO, "=============================================\n");
 662         avsys_info(AVAUDIO, "      Input Parameters (Basic Information)\n");
 663         avsys_info(AVAUDIO, "=============================================\n");
 664         avsys_info(AVAUDIO, " Op Mode    = %d (0:out, 1:input)\n", param->mode);
 665         avsys_info(AVAUDIO, " format     = %d (0: 8bits, 1:16bits, 2:32bits)\n", param->format);
 666         avsys_info(AVAUDIO, " channel    = %d\n", param->channels);
 667         avsys_info(AVAUDIO, " samplerate = %d\n", param->samplerate);
 668         avsys_info(AVAUDIO, " route      = %d (0: default, 1: handset)\n", param->handle_route);
 669         avsys_info(AVAUDIO, " Vol type   = %d\n", param->vol_type);
 670         avsys_info(AVAUDIO, "=============================================\n");
 671
 672         p->mode = param->mode;
 673         p->channels = param->channels;
 674         p->samplerate = param->samplerate;
 675         p->format = param->format;
 676         p->priority = param->priority;
 677
 678         if ((param->vol_type < 0) || (param->vol_type >= AVSYS_AUDIO_VOLUME_TYPE_MAX)) {
 679                 avsys_error(AVAUDIO, "[%s] Invalid volume type %d. use default system type\n", __func__, param->vol_type);
 680                 p->gain_setting.vol_type = AVSYS_AUDIO_VOLUME_TYPE_SYSTEM;
 681         } else {
 682                 p->gain_setting.vol_type = param->vol_type;
 683         }
 684
 685         /* trivial volume value */
 686         p->setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT] = 0;
 687         p->setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT] = 0;
 688         p->working_vol.level[AVSYS_AUDIO_CHANNEL_LEFT] = 0;
 689         p->working_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT] = 0;
 690         p->fadeup_vol = 0;
 691
 692         return AVSYS_STATE_SUCCESS;
 693 }
 694
 695 EXPORT_API
 696 int avsys_audio_earjack_manager_init(int *earjack_type, int *waitfd)
 697 {
 698         return avsys_audio_path_earjack_init(earjack_type, waitfd);
 699 }
 700
 701 EXPORT_API
 702 int avsys_audio_earjack_manager_wait(int waitfd, int *current_earjack_type, int *new_earjack_type, int *need_mute)
 703 {
 704         return avsys_audio_path_earjack_wait(waitfd, current_earjack_type, new_earjack_type, need_mute);
 705 }
 706
 707 EXPORT_API
 708 int avsys_audio_earjack_manager_process(int new_earjack_type)
 709 {
 710         return avsys_audio_path_earjack_process(new_earjack_type);
 711 }
 712
 713 EXPORT_API
 714 int avsys_audio_earjack_manager_deinit(int waitfd)
 715 {
 716         return avsys_audio_path_earjack_deinit(waitfd);
 717 }
 718
 719 EXPORT_API
 720 int avsys_audio_earjack_manager_get_type(void)
 721 {
 722         return avsys_audio_path_earjack_get_type();
 723 }
 724
 725 EXPORT_API
 726 int avsys_audio_earjack_manager_unlock(void)
 727 {
 728         return avsys_audio_path_earjack_unlock();
 729 }
 730
 731 EXPORT_API
 732 int avsys_audio_set_route_policy(avsys_audio_route_policy_t route)
 733 {
 734         /* Deprecated */
 735         return 0;
 736 }
 737
 738 EXPORT_API
 739 int avsys_audio_get_route_policy(avsys_audio_route_policy_t *route)
 740 {
 741         /* Deprecated */
 742         return 0;
 743 }
 744
 745 EXPORT_API
 746 int avsys_audio_get_current_playing_volume_type(int *volume_type)
 747 {
 748         if (volume_type == NULL)
 749                 return AVSYS_STATE_ERR_NULL_POINTER;
 750         return avsys_audio_handle_current_playing_volume_type(volume_type);
 751 }
 752
 753 static inline int __avsys_audio_validate_volume(const int type, const int value)
 754 {
 755         if (value < 0)
 756                 return -1;
 757         switch (type) {
 758         case AVSYS_AUDIO_VOLUME_TYPE_CALL:
 759                 if (value >= LVOLUME_MAX_BASIC) {
 760                         return -1;
 761                 }
 762                 break;
 763         case AVSYS_AUDIO_VOLUME_TYPE_ALARM:
 764         case AVSYS_AUDIO_VOLUME_TYPE_RINGTONE:
 765         case AVSYS_AUDIO_VOLUME_TYPE_NOTIFICATION:
 766         case AVSYS_AUDIO_VOLUME_TYPE_SYSTEM:
 767         case AVSYS_AUDIO_VOLUME_TYPE_MEDIA:
 768         case AVSYS_AUDIO_VOLUME_TYPE_MEDIA_HL:
 769         case AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_JAVA:
 770                 if (value >= LVOLUME_MAX_MULTIMEDIA) {
 771                         return -1;
 772                 }
 773                 break;
 774         case AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_ANDROID:
 775                 if (value >= LVOLUME_MAX_SINGLE) {
 776                         return -1;
 777                 }
 778                 break;
 779         default:
 780                 return -1;
 781                 break;
 782         }
 783         return 0;
 784 }
 785
 786 EXPORT_API
 787 int avsys_audio_set_volume_by_type(const int type, const int value)
 788 {
 789         if (type < 0 || type >= AVSYS_AUDIO_VOLUME_TYPE_MAX)
 790                 return AVSYS_STATE_ERR_INVALID_PARAMETER;
 791         if (0 > __avsys_audio_validate_volume(type, value))
 792                 return AVSYS_STATE_ERR_INVALID_PARAMETER;
 793         return avsys_audio_handle_update_volume_by_type(type, value);
 794 }
 795
 796 EXPORT_API
 797 int avsys_audio_set_primary_volume(const int pid, const int type)
 798 {
 799         return avsys_audio_handle_set_primary_volume_type(pid, type, AVSYS_AUDIO_PRIMARY_VOLUME_SET);
 800 }
 801
 802 EXPORT_API
 803 int avsys_audio_clear_primary_volume(const int pid)
 804 {
 805         return avsys_audio_handle_set_primary_volume_type(pid, 0, AVSYS_AUDIO_PRIMARY_VOLUME_CLEAR);
 806 }
 807
 808 EXPORT_API
 809 int avsys_audio_hibernation_reset(int *vol)
 810 {
 811         int err = AVSYS_STATE_SUCCESS;
 812         err = avsys_audio_path_ex_reset(1);
 813         if (AVSYS_FAIL(err)) {
 814                 avsys_error(AVAUDIO, "avsys_audio_path_ex_reset(forced) failed 0x%x\n", err);
 815                 return err;
 816         }
 817
 818         err = avsys_audio_handle_reset(vol);
 819         if (AVSYS_FAIL(err)) {
 820                 avsys_error(AVAUDIO, "avsys_audio_handle_reset() failed 0x%x\n", err);
 821                 return err;
 822         }
 823         return err;
 824 }
 825
 826 EXPORT_API
 827 int avsys_audio_delay(avsys_handle_t handle, int *delay)
 828 {
 829         int err = AVSYS_STATE_SUCCESS;
 830         int frame_delay = 0;
 831         avsys_audio_handle_t *p = NULL;
 832
 833         AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
 834
 835         err = avsys_audio_pasimple_delay(p, &frame_delay);
 836         if (AVSYS_SUCCESS(err)) {
 837                 *delay = frame_delay;
 838         }
 839
 840         AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
 841
 842         return err;
 843 }
 844
 845 EXPORT_API
 846 int avsys_audio_reset(avsys_handle_t handle)
 847 {
 848         int err = AVSYS_STATE_SUCCESS;
 849         avsys_audio_handle_t *p = NULL;
 850
 851         AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
 852
 853         err = avsys_audio_pasimple_reset(p);
 854         if (AVSYS_FAIL(err)) {
 855                 avsys_error(AVAUDIO, "avsys_audio_reset() failed, 0x%X\n", err);
 856         }
 857
 858         AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
 859
 860         return err;
 861
 862 }
 863
 864 EXPORT_API
 865 int avsys_audio_get_period_buffer_time(avsys_handle_t handle, unsigned int *period_time, unsigned int *buffer_time)
 866 {
 867         int err = AVSYS_STATE_SUCCESS;
 868         avsys_audio_handle_t *p = NULL;
 869         unsigned int p_time = 0, b_time=0;
 870
 871         AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
 872
 873         err = avsys_audio_pasimple_get_period_buffer_time(p, &p_time, &b_time);
 874         if(AVSYS_FAIL(err)) {
 875                 avsys_error(AVAUDIO, "avsys_audio_get_period_buffer_time() failed, 0x%X\n",err);
 876         }
 877         else
 878         {
 879                 *period_time = p_time;
 880                 *buffer_time = b_time;
 881                 avsys_info(AVAUDIO,"period time : %u, buffer_time : %u\n", p_time, b_time);
 882         }
 883
 884         AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
 885
 886         return err;
 887 }
 888
 889 EXPORT_API
 890 int avsys_audio_cork (avsys_handle_t handle, int cork)
 891 {
 892         int err = AVSYS_STATE_SUCCESS;
 893         avsys_audio_handle_t *p = NULL;
 894
 895         AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
 896
 897         err = avsys_audio_pasimple_cork(p, cork);
 898         if(AVSYS_FAIL(err)) {
 899                 avsys_error(AVAUDIO, "avsys_audio_pasimple_cork() failed, 0x%X\n",err);
 900         }
 901
 902         AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
 903
 904         return err;
 905 }
 906
 907 EXPORT_API
 908 int avsys_audio_is_corked (avsys_handle_t handle, int *is_corked)
 909 {
 910         int err = AVSYS_STATE_SUCCESS;
 911         avsys_audio_handle_t *p = NULL;
 912
 913         if (is_corked == NULL) {
 914                 return AVSYS_STATE_ERR_NULL_POINTER;
 915         }
 916
 917         AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
 918
 919         err = avsys_audio_pasimple_is_corked(p, is_corked);
 920         if(AVSYS_FAIL(err)) {
 921                 avsys_error(AVAUDIO, "avsys_audio_pasimple_cork() failed, 0x%X\n",err);
 922         }
 923
 924         AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
 925
 926         return err;
 927 }
 928
 929 EXPORT_API
 930 int avsys_audio_get_capture_status(int *on_capture)
 931 {
 932         return avsys_audio_handle_current_capture_status(on_capture);
 933 }
 934
 935 __attribute__ ((constructor))
 936 void __init_module(void)
 937 {
 938 }
 939
 940 __attribute__ ((destructor))
 941 void __fini_module(void)
 942 {
 943 }