avsys-audio-handle.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 <stdio.h>
  23 #include <string.h>
  24 #include <sys/types.h>
  25 #include <unistd.h>
  26
  27 #include "avsys-common.h"
  28 #include "avsys-audio-shm.h"
  29 #include "avsys-audio-sync.h"
  30 #include "avsys-debug.h"
  31 #include "avsys-audio-handle.h"
  32 #include "avsys-audio-shm.h"
  33 #include "avsys-audio-path.h"
  34 #include "avsys-audio-logical-volume.h"
  35 #include "avsys-audio-pactrl.h"
  36
  37 #define DEFAULT_VOLUME_SYSTEM 5
  38 #define DEFAULT_VOLUME_NOTIFICATION 7
  39 #define DEFAULT_VOLUME_ALARM 7
  40 #define DEFAULT_VOLUME_RINGTONE 13
  41 #define DEFAULT_VOLUME_MEDIA 7
  42 #define DEFAULT_VOLUME_CALL 7
  43 #define DEFAULT_VOLUME_VOIP 7
  44 #define DEFAULT_VOLUME_FIXED 0
  45 #define DEFAULT_VOLUME_JAVA 11
  46
  47 #define AVSYS_GET_SHM(SHM,ERROR) do { \
  48         if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_HANDLE, (void **)SHM))) { \
  49                 avsys_error(AVAUDIO,"avsys_audio_get_shm() failed in %s\n", __func__); \
  50                 return ERROR; \
  51         } \
  52 } while (0)
  53
  54 #define AVSYS_LOCK_SYNC() do { \
  55         if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_HANDLE))) { \
  56                 avsys_error(AVAUDIO,"avsys_audio_lock_sync() failed in %s\n", __func__); \
  57                 return AVSYS_STATE_ERR_INTERNAL; \
  58         } \
  59 } while (0)
  60
  61 #define AVSYS_UNLOCK_SYNC() do { \
  62         if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_HANDLE))) { \
  63                 avsys_error(AVAUDIO,"avsys_audio_unlock_sync() failed in %s\n", __func__); \
  64                 return AVSYS_STATE_ERR_INTERNAL; \
  65         } \
  66 } while (0)
  67
  68 static int g_default_volume[AVSYS_AUDIO_VOLUME_TYPE_MAX] = {
  69         DEFAULT_VOLUME_SYSTEM,                  /* AVSYS_AUDIO_VOLUME_TYPE_SYSTEM */
  70         DEFAULT_VOLUME_NOTIFICATION,    /* AVSYS_AUDIO_VOLUME_TYPE_NOTIFICATION */
  71         DEFAULT_VOLUME_ALARM,                   /* AVSYS_AUDIO_VOLUME_TYPE_ALARM */
  72         DEFAULT_VOLUME_RINGTONE,                /* AVSYS_AUDIO_VOLUME_TYPE_RINGTONE */
  73         DEFAULT_VOLUME_MEDIA,                   /* AVSYS_AUDIO_VOLUME_TYPE_MEDIA */
  74         DEFAULT_VOLUME_CALL,                    /* AVSYS_AUDIO_VOLUME_TYPE_CALL */
  75         DEFAULT_VOLUME_VOIP,                    /* AVSYS_AUDIO_VOLUME_TYPE_VOIP */
  76         DEFAULT_VOLUME_FIXED,                   /* AVSYS_AUDIO_VOLUME_TYPE_FIXED */
  77         DEFAULT_VOLUME_JAVA,                    /* AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_JAVA */
  78 };
  79
  80 EXPORT_API
  81 int avsys_audio_handle_init(void)
  82 {
  83         int i, err = 0;
  84         avsys_audio_handle_info_t *control = NULL;
  85         avsys_audio_handle_info_t **temp = NULL;
  86
  87         /* Check root user */
  88         err = avsys_check_root_privilege();
  89         if (AVSYS_FAIL(err)) {
  90                 return err;
  91         }
  92
  93         if (AVSYS_FAIL(avsys_audio_create_sync(AVSYS_AUDIO_SYNC_IDEN_HANDLE))) {
  94                 avsys_error(AVAUDIO, "avsys_audio_create_sync() failed in %s\n", __func__);
  95                 return AVSYS_STATE_ERR_INTERNAL;
  96         }
  97         if (AVSYS_FAIL(avsys_audio_create_shm(AVSYS_AUDIO_SHM_IDEN_HANDLE))) {
  98                 avsys_error(AVAUDIO, "avsys_audio_create_shm() failed in %s\n", __func__);
  99                 return AVSYS_STATE_ERR_INTERNAL;
 100         }
 101
 102         temp = &control;
 103         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
 104         if (control == NULL) {
 105                 avsys_error(AVAUDIO, "control is null in %s\n", __func__);
 106                 return AVSYS_STATE_ERR_NULL_POINTER;
 107         }
 108
 109         /* init allocted bits */
 110         control->allocated = 0;
 111         control->handle_amp = 0;
 112         memcpy(control->volume_value, (int *)g_default_volume, sizeof(int) * AVSYS_AUDIO_VOLUME_TYPE_MAX);
 113         control->ext_device_amp = AVSYS_AUDIO_HANDLE_EXT_DEV_NONE;
 114         control->primary_volume_pid = 0;
 115         control->primary_volume_type = -1;
 116         for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
 117                 control->handle_priority[i] = AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0;
 118         }
 119
 120         for (i = 0; i < AVSYS_AUDIO_LOCK_SLOT_MAX; i++) {
 121                 control->handlelock_pid[i] = -1;
 122         }
 123         return AVSYS_STATE_SUCCESS;
 124 }
 125
 126 EXPORT_API
 127 int avsys_audio_handle_fini(void)
 128 {
 129
 130         AVSYS_LOCK_SYNC();
 131
 132         if (AVSYS_FAIL(avsys_audio_remove_shm(AVSYS_AUDIO_SHM_IDEN_HANDLE))) {
 133                 avsys_error(AVAUDIO, "avsys_audio_remove_shm() failed in %s\n", __func__);
 134                 return AVSYS_STATE_ERR_INTERNAL;
 135         }
 136
 137         AVSYS_UNLOCK_SYNC();
 138
 139         if (AVSYS_FAIL(avsys_audio_remove_sync(AVSYS_AUDIO_SYNC_IDEN_HANDLE))) {
 140                 avsys_error(AVAUDIO, "avsys_audio_remove_sync() failed in %s\n", __func__);
 141                 return AVSYS_STATE_ERR_INTERNAL;
 142         }
 143
 144         return AVSYS_STATE_SUCCESS;
 145 }
 146
 147 EXPORT_API
 148 int avsys_audio_handle_reset(int *volume_value)
 149 {
 150         int i = 0, err = 0;
 151         long long int flag = 0x01;
 152         avsys_audio_handle_info_t *control = NULL;
 153         avsys_audio_handle_info_t **temp = NULL;
 154         int * volumes;
 155         temp = &control;
 156
 157         /* Check root user */
 158         err = avsys_check_root_privilege();
 159         if (AVSYS_FAIL(err)) {
 160                 return err;
 161         }
 162
 163         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
 164         if (control == NULL) {
 165                 avsys_error(AVAUDIO, "control is null in %s\n", __func__);
 166                 return AVSYS_STATE_ERR_NULL_POINTER;
 167         }
 168
 169         volumes = (volume_value) ? volume_value : (int *)g_default_volume;
 170
 171         for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
 172                 if (control->allocated & (flag << i)) { /* allocated condition */
 173                         if (AVSYS_FAIL(avsys_check_process(control->handles[i].pid))) {
 174                                 /* process dead */
 175                                 if (AVSYS_FAIL(avsys_audio_handle_free(i))) {
 176                                         avsys_error(AVAUDIO, "Cleanup handle %d failed\n", i);
 177                                 }
 178                         }
 179                 }
 180         }
 181
 182 #ifdef USE_HIBERNATION
 183         while (control->allocated) {
 184                 if (++i > 5)
 185                         break;
 186                 avsys_warning(AVAUDIO, "(%d)Waiting...0.5 sec for resume from hibernation\n", i);
 187                 printf("(%d)Waiting...0.5 sec for resume from hibernation\n", i);
 188                 usleep(500);
 189         }
 190 #endif
 191
 192         AVSYS_LOCK_SYNC();
 193         if (volume_value == NULL) {
 194                 control->allocated = 0;
 195                 control->handle_amp = 0;
 196         }
 197         memcpy(control->volume_value, volumes, sizeof(int) * AVSYS_AUDIO_VOLUME_TYPE_MAX);
 198         control->ext_device_amp = AVSYS_AUDIO_HANDLE_EXT_DEV_NONE;
 199         control->primary_volume_pid = 0;
 200         control->primary_volume_type = -1;
 201         for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
 202                 control->handle_priority[i] = AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0;
 203         }
 204         /* Clear semaphore condition */
 205         for (i = 0; i < AVSYS_AUDIO_LOCK_SLOT_MAX; i++) {
 206                 control->handlelock_pid[i] = -1;
 207         }
 208
 209         AVSYS_UNLOCK_SYNC();
 210
 211         return AVSYS_STATE_SUCCESS;
 212 }
 213
 214 EXPORT_API
 215 int avsys_audio_handle_rejuvenation(void)
 216 {
 217         int i = 0;
 218         long long int flag = 0x01;
 219         int dead_handle = 0x00;
 220
 221         avsys_audio_handle_info_t *control = NULL;
 222         avsys_audio_handle_info_t **temp = NULL;
 223         int dead_pids[AVSYS_AUDIO_HANDLE_MAX];
 224
 225         temp = &control;
 226
 227         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
 228         if (control == NULL) {
 229                 avsys_error(AVAUDIO, "control is null in %s\n", __func__);
 230                 return AVSYS_STATE_ERR_NULL_POINTER;
 231         }
 232
 233         AVSYS_LOCK_SYNC();
 234
 235         /* Clear semaphore condition */
 236
 237         for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
 238                 dead_pids[i] = -1;
 239                 if (control->allocated & (flag << i)) { /* allocated condition */
 240                         /* check pid of handle... still alive? */
 241                         if (AVSYS_FAIL(avsys_check_process(control->handles[i].pid))) {
 242                                 avsys_error(AVAUDIO, "handle %d is dead\n", i);
 243                                 dead_handle |= (flag << i);
 244                                 dead_pids[i] = control->handles[i].pid;
 245                         }
 246                 }
 247         }
 248
 249         AVSYS_UNLOCK_SYNC();
 250
 251         avsys_warning(AVAUDIO, "dead_handle : 0x%0X\n", dead_handle);
 252         /* Cleanup dead handle... */
 253         for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
 254                 if (dead_handle & (flag << i)) {
 255                         /* set priority of dead handle as lowest */
 256                         control->handle_priority[i] = AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0;
 257                         /* free this handle */
 258                         avsys_error(AVAUDIO, "Cleanup handle %d...\n", i);
 259                         if (AVSYS_FAIL(avsys_audio_handle_free(i)))
 260                                 avsys_error(AVAUDIO, "Cleanup handle %d failed\n", i);
 261                 }
 262         }
 263         if (dead_handle) {
 264                 char high_priority_exist = 0;
 265                 AVSYS_LOCK_SYNC();
 266                 for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
 267                         if (control->handle_priority[i] > AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0) {
 268                                 high_priority_exist = 1;
 269                                 break;
 270                         }
 271                 }
 272
 273                 for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
 274                         if (control->handle_priority[i] == AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0) {
 275                                 if (high_priority_exist) {
 276                                         /* sink input mute immediately */
 277                                         if (control->handles[i].mute == AVSYS_AUDIO_UNMUTE) {
 278                                                 if (AVSYS_FAIL(avsys_audio_pa_ctrl_mute_by_index(control->handles[i].stream_index, AVSYS_AUDIO_MUTE))) {
 279                                                         avsys_error(AVAUDIO, "set sink input mute for %d failed\n", control->handles[i].stream_index);
 280                                                 } else {
 281                                                         avsys_warning(AVAUDIO, "set sink input mute for %d success\n", control->handles[i].stream_index);
 282                                                 }
 283                                                 control->handles[i].mute = AVSYS_AUDIO_MUTE;
 284                                         }
 285                                 } else {
 286                                         /* sink input unmute immediately */
 287                                         if (control->handles[i].mute == AVSYS_AUDIO_MUTE) {
 288                                                 if (AVSYS_FAIL(avsys_audio_pa_ctrl_mute_by_index(control->handles[i].stream_index, AVSYS_AUDIO_UNMUTE))) {
 289                                                         avsys_error(AVAUDIO, "set sink input unmute for %d failed\n", control->handles[i].stream_index);
 290                                                 } else {
 291                                                         avsys_warning(AVAUDIO, "set sink input unmute for %d success\n", control->handles[i].stream_index);
 292                                                 }
 293                                                 control->handles[i].mute = AVSYS_AUDIO_UNMUTE;
 294                                         }
 295                                 }
 296
 297                         } else  { /* this is high priority case */
 298                                 /* sink input unmute immediately */
 299                                 if (control->handles[i].mute == AVSYS_AUDIO_MUTE) {
 300                                         if (AVSYS_FAIL(avsys_audio_pa_ctrl_mute_by_index(control->handles[i].stream_index, AVSYS_AUDIO_UNMUTE))) {
 301                                                 avsys_error(AVAUDIO, "set sink input unmute for %d failed\n", control->handles[i].stream_index);
 302                                         } else {
 303                                                 avsys_warning(AVAUDIO, "set sink input unmute for %d success\n", control->handles[i].stream_index);
 304                                         }
 305                                         control->handles[i].mute = AVSYS_AUDIO_UNMUTE;
 306                                 }
 307                         }
 308                 }
 309
 310                 AVSYS_UNLOCK_SYNC();
 311         }
 312
 313         return AVSYS_STATE_SUCCESS;
 314 }
 315
 316 EXPORT_API
 317 int avsys_audio_handle_dump(void)
 318 {
 319         avsys_audio_handle_info_t *control = NULL;
 320         avsys_audio_handle_info_t **temp = NULL;
 321         char *vol_str[] = { "System", "Notification", "Alarm", "Ringtone", "Media", "Call", "Fixed", "Java", "Media-HL" };
 322         char *dev_str[] = { "Speaker", "Headset", "BTHeadset" };
 323         int i = 0;
 324         long long int flag = 0x01;
 325
 326         temp = &control;
 327         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
 328         if (control == NULL) {
 329                 avsys_error(AVAUDIO, "control is null in %s\n", __func__);
 330                 return AVSYS_STATE_ERR_NULL_POINTER;
 331         }
 332
 333         fprintf(stdout, "======================================================================\n");
 334         fprintf(stdout, "                      Opened Handles Information                      \n");
 335         fprintf(stdout, "======================================================================\n");
 336         fprintf(stdout, " Avsystem Handle alloc  : %016x\n", control->allocated);
 337         for (i = 0; i < AVSYS_AUDIO_LOCK_SLOT_MAX; i++) {
 338                 if (control->handlelock_pid[i] > 0) {
 339                         fprintf(stdout, " Handle Lock PIDs       : %d\n", control->handlelock_pid[i]);
 340                 }
 341         }
 342         fprintf(stdout, "----------------------------------------------------------------------\n");
 343         for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
 344                 if (control->allocated & (flag << i)) { /* allocated condition */
 345                         fprintf(stdout, " Avsystem Handle ID    : %2d\n", i);
 346                         fprintf(stdout, " Run Process ID        : 0x%08X (%d)\n", control->handles[i].pid, control->handles[i].pid);
 347                         fprintf(stdout, " Run Thread ID         : 0x%08X (%d)\n", control->handles[i].tid, control->handles[i].tid);
 348                         fprintf(stdout, " Open Mode             : %2d\n", control->handles[i].mode);
 349                         fprintf(stdout, " Format                : %2d\n", control->handles[i].format);
 350                         fprintf(stdout, " Channels              : %2d\n", control->handles[i].channels);
 351                         fprintf(stdout, " Samplerate            : %2d\n", control->handles[i].samplerate);
 352                         fprintf(stdout, " Priority              : %2d\n", control->handle_priority[i]);
 353                         if(control->handles[i].mode == AVSYS_AUDIO_MODE_OUTPUT || control->handles[i].mode == AVSYS_AUDIO_MODE_OUTPUT_CLOCK ||
 354                                         control->handles[i].mode == AVSYS_AUDIO_MODE_OUTPUT_VIDEO || control->handles[i].mode == AVSYS_AUDIO_MODE_OUTPUT_LOW_LATENCY
 355                                         || control->handles[i].mode == AVSYS_AUDIO_MODE_OUTPUT_AP_CALL) {
 356                                 int vol_conf_type = AVSYS_AUDIO_VOLUME_CONFIG_TYPE(control->handles[i].gain_setting.volume_config);
 357                                 if (control->handles[i].dirty_volume) {
 358                                         fprintf(stdout, " Dirty volume          : %s\n", vol_str[vol_conf_type]);
 359                                 } else {
 360                                         fprintf(stdout, " Volume Type           : %s\n", vol_str[vol_conf_type]);
 361                                 }
 362                                 fprintf(stdout, " Target device         : %s\n", dev_str[control->handles[i].gain_setting.dev_type]);
 363                                 fprintf(stdout, " Maximum Level         : %2d\n", control->handles[i].gain_setting.max_level);
 364                                 fprintf(stdout, " UI setted volume      : L:%3d R:%3d\n", control->handles[i].setting_vol.level[0], control->handles[i].setting_vol.level[1]);
 365                                 fprintf(stdout, " Real working volume   : L:%3d R:%3d\n", control->handles[i].working_vol.level[0], control->handles[i].working_vol.level[1]);
 366                         }
 367                         fprintf(stdout, " ----------------------------------------------------------------------\n");
 368                 }
 369         }
 370
 371         fprintf(stdout, " ----------------------------------------------------------------------\n");
 372         fprintf(stdout, " External dev amp      : 0x%08X\n", control->ext_device_amp);
 373         fprintf(stdout, " External dev status   : 0x%08X\n", control->ext_device_status);
 374         if (control->primary_volume_type >= 0) {
 375                 fprintf(stdout, " Primary Volume type   : %s\n", vol_str[control->primary_volume_type]);
 376         }
 377         fprintf(stdout, " Volume [System]       : %2d ", control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_SYSTEM]);
 378         for (i = 0; i < control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_SYSTEM]; i++)
 379                 fprintf(stdout, "+");
 380         fprintf(stdout, "\n");
 381         fprintf(stdout, " Volume [Notification] : %2d ", control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_NOTIFICATION]);
 382         for (i = 0; i < control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_NOTIFICATION]; i++)
 383                 fprintf(stdout, "+");
 384         fprintf(stdout, "\n");
 385         fprintf(stdout, " Volume [Alarm]        : %2d ", control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_ALARM]);
 386         for (i = 0; i < control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_ALARM]; i++)
 387                 fprintf(stdout, "+");
 388         fprintf(stdout, "\n");
 389         fprintf(stdout, " Volume [Ringtone]     : %2d ", control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_RINGTONE]);
 390         for (i = 0; i < control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_RINGTONE]; i++)
 391                 fprintf(stdout, "+");
 392         fprintf(stdout, "\n");
 393         fprintf(stdout, " Volume [Media]        : %2d ", control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_MEDIA]);
 394         for (i = 0; i < control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_MEDIA]; i++)
 395                 fprintf(stdout, "+");
 396         fprintf(stdout, "\n");
 397         fprintf(stdout, " Volume [Call]         : %2d ", control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_CALL]);
 398         for (i = 0; i < control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_CALL]; i++)
 399                 fprintf(stdout, "+");
 400         fprintf(stdout, "\n");
 401         fprintf(stdout, " Volume [VOIP]         : %2d ", control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_VOIP]);
 402         for (i = 0; i < control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_VOIP]; i++)
 403                 fprintf(stdout, "+");
 404         fprintf(stdout, "\n");
 405         fprintf(stdout, " Volume [Android]      : %2d ", control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_ANDROID]);
 406         for (i = 0; i < control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_ANDROID]; i++)
 407                 fprintf(stdout, "+");
 408         fprintf(stdout, "\n");
 409         fprintf(stdout, " Volume [Java]         : %2d ", control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_JAVA]);
 410         for (i = 0; i < control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_JAVA]; i++)
 411                 fprintf(stdout, "+");
 412         fprintf(stdout, "\n");
 413         fprintf(stdout, "======================================================================\n");
 414
 415         return AVSYS_STATE_SUCCESS;
 416 }
 417
 418 int avsys_audio_handle_alloc(int *handle)
 419 {
 420         long long int flag = 0x01;
 421         int i;
 422         avsys_audio_handle_info_t *control = NULL;
 423         avsys_audio_handle_info_t **temp = NULL;
 424         temp = &control;
 425
 426         avsys_info(AVAUDIO, "%s\n", __func__);
 427         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
 428
 429         AVSYS_LOCK_SYNC();
 430         for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
 431                 if ((control->allocated & flag) == 0) { /* alloc condition */
 432                         control->allocated |= flag;
 433                         break;
 434                 } else {
 435                         flag <<= 1;
 436                 }
 437         }
 438
 439         AVSYS_UNLOCK_SYNC();
 440
 441         if (i == AVSYS_AUDIO_HANDLE_MAX) {
 442                 *handle = -1;
 443                 return AVSYS_STATE_ERR_RANGE_OVER;
 444         } else {
 445                 avsys_info(AVAUDIO, "handle allocated %d\n", i);
 446                 memset(&control->handles[i], 0, sizeof(avsys_audio_handle_t));
 447                 control->handles[i].pid = getpid();
 448                 control->handles[i].tid = avsys_gettid();
 449                 *handle = i;
 450                 return AVSYS_STATE_SUCCESS;
 451         }
 452 }
 453
 454 int avsys_audio_handle_free(int handle)
 455 {
 456         long long int flag = 0x01;
 457         avsys_audio_handle_info_t *control = NULL;
 458         avsys_audio_handle_info_t **temp = NULL;
 459         temp = &control;
 460
 461         avsys_info(AVAUDIO, "%s, handle=[%d]\n", __func__, handle);
 462
 463         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
 464
 465         flag <<= handle;
 466
 467         AVSYS_LOCK_SYNC();
 468         if (control->allocated & flag) {        /* find condition */
 469                 control->allocated &= ~flag;
 470                 /* clear handle mute field */
 471                 if (control->handle_amp & flag) {
 472                         control->handle_amp &= ~flag;
 473                 }
 474                 AVSYS_UNLOCK_SYNC();
 475                 return AVSYS_STATE_SUCCESS;
 476         } else {
 477                 AVSYS_UNLOCK_SYNC();
 478                 return AVSYS_STATE_ERR_INVALID_VALUE;
 479         }
 480 }
 481
 482 int avsys_audio_handle_get_ptr(int handle, avsys_audio_handle_t **ptr, const int mode)
 483 {
 484         long long int flag = 0x01;
 485         avsys_audio_handle_info_t *control = NULL;
 486         avsys_audio_handle_info_t **temp = NULL;
 487         int ret = AVSYS_STATE_SUCCESS;
 488
 489         //avsys_info(AVAUDIO, "%s handle %d\n", __func__, handle);
 490
 491         if (handle < 0 || handle >= AVSYS_AUDIO_HANDLE_MAX) {
 492                 *ptr = NULL;
 493                 return AVSYS_STATE_ERR_INVALID_HANDLE;
 494         }
 495
 496         if (mode < 0 || mode >= HANDLE_PTR_MODE_NUM) {
 497                 *ptr = NULL;
 498                 return AVSYS_STATE_ERR_INVALID_PARAMETER;
 499         }
 500
 501         temp = &control;
 502         if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_HANDLE, (void **)temp))) {
 503                 avsys_error(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
 504                 *ptr = NULL;
 505                 return AVSYS_STATE_ERR_INTERNAL;
 506         }
 507
 508         flag <<= handle;
 509
 510         if (mode == HANDLE_PTR_MODE_NORMAL) {
 511                 if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_HANDLE))) {
 512                         avsys_error(AVAUDIO, "avsys_audio_lock_sync() failed in %s\n", __func__);
 513                         *ptr = NULL;
 514                         return AVSYS_STATE_ERR_INTERNAL;
 515                 }
 516         }
 517
 518         if (control->allocated & flag) {
 519                 //avsys_info(AVAUDIO, "input handle %d flag %x allocated %x\n", handle, flag, control->allocated);
 520                 *ptr = &(control->handles[handle]);
 521                 ret = AVSYS_STATE_SUCCESS;
 522         } else {
 523                 *ptr = NULL;
 524                 ret = AVSYS_STATE_ERR_INVALID_VALUE;
 525         }
 526
 527         if (mode == HANDLE_PTR_MODE_NORMAL) {
 528                 if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_HANDLE))) {
 529                         avsys_error(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
 530                         *ptr = NULL;
 531                         return AVSYS_STATE_ERR_INTERNAL;
 532                 }
 533         }
 534
 535         return ret;
 536 }
 537
 538 int avsys_audio_handle_release_ptr(int handle, const int mode)
 539 {
 540         long long int flag = 0x01;
 541         avsys_audio_handle_info_t *control = NULL;
 542         avsys_audio_handle_info_t **temp = NULL;
 543         int ret = AVSYS_STATE_SUCCESS;
 544
 545         //avsys_info(AVAUDIO, "%s handle %d\n", __func__, handle);
 546
 547         if (handle < 0 || handle >= AVSYS_AUDIO_HANDLE_MAX) {
 548                 return AVSYS_STATE_ERR_INVALID_HANDLE;
 549         }
 550
 551         if (mode < 0 || mode >= HANDLE_PTR_MODE_NUM) {
 552                 return AVSYS_STATE_ERR_INVALID_PARAMETER;
 553         }
 554
 555         temp = &control;
 556         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
 557
 558         flag <<= handle;
 559
 560         //avsys_info(AVAUDIO, "input handle %d flag %x allocated %x\n", handle, flag, control->allocated);
 561         if (mode == HANDLE_PTR_MODE_NORMAL) {
 562                 AVSYS_LOCK_SYNC();
 563         }
 564
 565         if (control->allocated & flag) {
 566                 ret = AVSYS_STATE_SUCCESS;
 567         } else {
 568                 ret = AVSYS_STATE_ERR_INVALID_VALUE;
 569         }
 570
 571         if (mode == HANDLE_PTR_MODE_NORMAL) {
 572                 AVSYS_UNLOCK_SYNC();
 573         }
 574
 575         return ret;
 576 }
 577
 578 int avsys_audio_handle_set_mute(int handle, int mute)
 579 {
 580         long long int flag = 0x01;
 581         int result = AVSYS_STATE_SUCCESS;
 582         int path_mute = 0;
 583         avsys_audio_handle_info_t *control = NULL;
 584         avsys_audio_handle_info_t **temp = NULL;
 585         avsys_audio_handle_t *ptr = NULL;
 586         temp = &control;
 587
 588         avsys_info(AVAUDIO, "%s_%d_%d\n", __func__, handle, mute);
 589         if (mute > AVSYS_AUDIO_MUTE || mute < AVSYS_AUDIO_UNMUTE) {
 590                 avsys_error_r(AVAUDIO, "input parameter range error : mute %d\n", mute);
 591                 return AVSYS_STATE_ERR_INVALID_PARAMETER;
 592         }
 593
 594         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
 595
 596         flag <<= handle;
 597
 598         AVSYS_LOCK_SYNC();
 599
 600         if (control->allocated & flag) {        /* find condition */
 601                 /* update mute information for input handle parameter */
 602                 ptr = &(control->handles[handle]);
 603                 ptr->mute = mute;
 604                 avsys_audio_pa_ctrl_mute_by_index(ptr->stream_index, mute);
 605
 606                 /* update handle amp information */
 607                 if (mute == AVSYS_AUDIO_UNMUTE) {
 608 #ifdef _VERBOSE_
 609                         if (control->handle_amp & flag)
 610                                 avsys_warning(AVAUDIO, "handle 0x%x already powered\n");
 611                         else
 612                                 control->handle_amp |= flag;
 613 #else
 614                         if (!(control->handle_amp & flag))
 615                                 control->handle_amp |= flag;
 616
 617                         /* reset fadedown mute */
 618                         ptr->fadeup_vol = 0;
 619 #endif
 620                 } else if (mute == AVSYS_AUDIO_MUTE) {
 621                         /* clear handle amp field */
 622                         if (control->handle_amp & flag)
 623                                 control->handle_amp &= ~flag;
 624 #ifdef _VERBOSE_
 625                         else
 626                                 avsys_warning(AVAUDIO, "handle 0x%x already off\n");
 627 #endif
 628                 }
 629
 630                 result = AVSYS_STATE_SUCCESS;
 631         } else {
 632                 avsys_warning(AVAUDIO, "[%s] handle %d does not allocated\n", __func__, handle);
 633                 if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_HANDLE))) {
 634                         avsys_error(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
 635                         return AVSYS_STATE_ERR_INTERNAL;
 636                 }
 637                 return AVSYS_STATE_ERR_INVALID_VALUE;
 638         }
 639
 640         if (control->handle_amp | control->ext_device_amp)
 641                 path_mute = AVSYS_AUDIO_UNMUTE;
 642         else
 643                 path_mute = AVSYS_AUDIO_MUTE;
 644
 645         AVSYS_UNLOCK_SYNC();
 646
 647         if (AVSYS_FAIL(avsys_audio_path_ex_set_mute(path_mute))) {
 648                 avsys_error_r(AVAUDIO, "Path mute control failed. %s_%d\n", __func__, path_mute);
 649                 result = AVSYS_STATE_ERR_IO_CONTROL;
 650         }
 651         return result;
 652 }
 653
 654 int avsys_audio_handle_ext_dev_set_mute(avsysaudio_ext_device_t device_type, int mute)
 655 {
 656         int bit = 0;
 657         int result = AVSYS_STATE_SUCCESS;
 658         int path_mute = 0;
 659         avsys_audio_handle_info_t *control = NULL;
 660         avsys_audio_handle_info_t **temp = NULL;
 661         temp = &control;
 662
 663         avsys_info(AVAUDIO, "%s_%d_%d\n", __func__, (int)device_type, mute);
 664         if (mute > AVSYS_AUDIO_MUTE || mute < AVSYS_AUDIO_UNMUTE) {
 665                 avsys_error_r(AVAUDIO, "input parameter range error : mute %d\n", mute);
 666                 return AVSYS_STATE_ERR_INVALID_PARAMETER;
 667         }
 668
 669         switch (device_type) {
 670         case AVSYS_AUDIO_EXT_DEVICE_FMRADIO:
 671                 bit = AVSYS_AUDIO_HANDLE_EXT_DEV_FMRADIO;
 672                 break;
 673         default:
 674                 avsys_error(AVAUDIO, "Unknown device type %d\n", (int)device_type);
 675                 return AVSYS_STATE_ERR_INVALID_PARAMETER;
 676         }
 677
 678         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
 679
 680         AVSYS_LOCK_SYNC();
 681
 682         if (mute == AVSYS_AUDIO_MUTE) {
 683                 control->ext_device_amp |= bit;
 684         } else {
 685                 control->ext_device_amp &= ~bit;
 686         }
 687
 688         if (control->handle_amp | control->ext_device_amp)
 689                 path_mute = AVSYS_AUDIO_UNMUTE;
 690         else
 691                 path_mute = AVSYS_AUDIO_MUTE;
 692
 693         AVSYS_UNLOCK_SYNC();
 694
 695         if (AVSYS_FAIL(avsys_audio_path_ex_set_mute(path_mute))) {
 696                 avsys_error_r(AVAUDIO, "Path mute control failed. %s_%d\n", __func__, path_mute);
 697                 result = AVSYS_STATE_ERR_IO_CONTROL;
 698         }
 699         return result;
 700 }
 701
 702 int avsys_audio_handle_ext_dev_status(avsysaudio_ext_device_t device_type, int *onoff)
 703 {
 704         int result = AVSYS_STATE_SUCCESS;
 705         int ext_dev_state = 0;
 706
 707         avsys_audio_handle_info_t *control = NULL;
 708         avsys_audio_handle_info_t **temp = NULL;
 709         temp = &control;
 710
 711         avsys_info(AVAUDIO, "%s\n", __func__);
 712
 713         if (onoff == NULL) {
 714                 avsys_error(AVAUDIO, "Null pointer input parameter\n");
 715                 return AVSYS_STATE_ERR_NULL_POINTER;
 716         }
 717
 718         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
 719
 720         AVSYS_LOCK_SYNC();
 721
 722         switch (device_type) {
 723         case AVSYS_AUDIO_EXT_DEVICE_FMRADIO:
 724                 if (control->ext_device_status & AVSYS_AUDIO_HANDLE_EXT_DEV_FMRADIO) {
 725                         ext_dev_state = 1;
 726                 } else {
 727                         ext_dev_state = 0;
 728                 }
 729                 *onoff = ext_dev_state;
 730                 break;
 731         default:
 732                 avsys_error(AVAUDIO, "Invalid device type %d\n", device_type);
 733                 result = AVSYS_STATE_ERR_INTERNAL;
 734                 break;
 735         }
 736
 737         AVSYS_UNLOCK_SYNC();
 738         return result;
 739 }
 740
 741 int avsys_audio_handle_ext_dev_status_update(avsysaudio_ext_device_t device_type, int onoff)
 742 {
 743         int bit = 0;
 744         int result = AVSYS_STATE_SUCCESS;
 745         avsys_audio_handle_info_t *control = NULL;
 746         avsys_audio_handle_info_t **temp = NULL;
 747         temp = &control;
 748
 749         avsys_info(AVAUDIO, "%s_%d_%d\n", __func__, (int)device_type, onoff);
 750
 751         switch (device_type) {
 752         case AVSYS_AUDIO_EXT_DEVICE_FMRADIO:
 753                 bit = AVSYS_AUDIO_HANDLE_EXT_DEV_FMRADIO;
 754                 break;
 755         default:
 756                 avsys_error(AVAUDIO, "Unknown device type %d\n", (int)device_type);
 757                 return AVSYS_STATE_ERR_INVALID_PARAMETER;
 758         }
 759
 760         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
 761
 762         AVSYS_LOCK_SYNC();
 763
 764         if (onoff > 0) {
 765                 control->ext_device_status |= bit;
 766         } else if (onoff == 0) {
 767                 control->ext_device_status &= ~bit;
 768         } else {
 769                 avsys_error(AVAUDIO, "[%s] Unknown parameter %d. To nothing\n", __func__, onoff);
 770         }
 771
 772         AVSYS_UNLOCK_SYNC();
 773         return result;
 774 }
 775
 776 int avsys_audio_handle_current_playing_volume_type(int *type)
 777 {
 778         int result = AVSYS_STATE_SUCCESS;
 779         int i = 0;
 780         char used_table[AVSYS_AUDIO_VOLUME_TYPE_MAX] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 781         char capture_used = 0;
 782         avsys_audio_handle_info_t *control = NULL;
 783         avsys_audio_handle_info_t **temp = NULL;
 784         temp = &control;
 785
 786         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
 787
 788         AVSYS_LOCK_SYNC();
 789
 790         for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
 791                 long long int flag = 0x01;
 792                 flag <<= i;
 793                 if (control->allocated & flag) {
 794                         int vol_conf_type = AVSYS_AUDIO_VOLUME_CONFIG_TYPE(control->handles[i].gain_setting.volume_config);
 795                         if(control->handles[i].mode == AVSYS_AUDIO_MODE_OUTPUT ||
 796                                         control->handles[i].mode == AVSYS_AUDIO_MODE_OUTPUT_CLOCK ||
 797                                         control->handles[i].mode == AVSYS_AUDIO_MODE_OUTPUT_VIDEO ||
 798                                         control->handles[i].mode == AVSYS_AUDIO_MODE_OUTPUT_LOW_LATENCY ) {
 799                                 used_table[vol_conf_type] = 1;
 800                         }
 801                         else if(control->handles[i].mode == AVSYS_AUDIO_MODE_INPUT ||
 802                                         control->handles[i].mode == AVSYS_AUDIO_MODE_INPUT_HIGH_LATENCY ||
 803                                         control->handles[i].mode == AVSYS_AUDIO_MODE_INPUT_LOW_LATENCY) {
 804                                 capture_used = 1;
 805                         }
 806                 }
 807         }
 808         if (control->ext_device_status & AVSYS_AUDIO_HANDLE_EXT_DEV_FMRADIO) {
 809                 used_table[AVSYS_AUDIO_VOLUME_TYPE_MEDIA] = 1;
 810         }
 811
 812         avsys_warning(AVAUDIO,"Call[%d] VOIP[%d] Ringtone[%d] Media[%d] Alarm[%d] Notification[%d] System[%d] Android[%d] Java[%d] Capture[%d]\n",
 813                         used_table[AVSYS_AUDIO_VOLUME_TYPE_CALL],
 814                         used_table[AVSYS_AUDIO_VOLUME_TYPE_VOIP],
 815                         used_table[AVSYS_AUDIO_VOLUME_TYPE_RINGTONE],
 816                         used_table[AVSYS_AUDIO_VOLUME_TYPE_MEDIA],
 817                         used_table[AVSYS_AUDIO_VOLUME_TYPE_ALARM],
 818                         used_table[AVSYS_AUDIO_VOLUME_TYPE_NOTIFICATION],
 819                         used_table[AVSYS_AUDIO_VOLUME_TYPE_SYSTEM],
 820                         used_table[AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_ANDROID],
 821                         used_table[AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_JAVA],
 822                         capture_used);
 823
 824         if (control->primary_volume_pid > 2 && AVSYS_FAIL(avsys_check_process(control->primary_volume_pid))) {
 825                 avsys_warning(AVAUDIO, "Primary volume set pid does not exist anymore. clean primary volume\n");
 826                 control->primary_volume_type = -1;
 827                 control->primary_volume_pid = 0;
 828         }
 829
 830         if (control->primary_volume_type != -1) {
 831                 *type = control->primary_volume_type;
 832                 avsys_warning(AVAUDIO, "Primary volume is %d\n", control->primary_volume_type);
 833         } else if (used_table[AVSYS_AUDIO_VOLUME_TYPE_CALL]) {
 834                 *type = AVSYS_AUDIO_VOLUME_TYPE_CALL;
 835         } else if (used_table[AVSYS_AUDIO_VOLUME_TYPE_VOIP]) {
 836                 *type = AVSYS_AUDIO_VOLUME_TYPE_VOIP;
 837         } else if (used_table[AVSYS_AUDIO_VOLUME_TYPE_RINGTONE]) {
 838                 *type = AVSYS_AUDIO_VOLUME_TYPE_RINGTONE;
 839         } else if (used_table[AVSYS_AUDIO_VOLUME_TYPE_MEDIA]) {
 840                 *type = AVSYS_AUDIO_VOLUME_TYPE_MEDIA;
 841         } else if (used_table[AVSYS_AUDIO_VOLUME_TYPE_ALARM]) {
 842                 *type = AVSYS_AUDIO_VOLUME_TYPE_ALARM;
 843         } else if (used_table[AVSYS_AUDIO_VOLUME_TYPE_NOTIFICATION]) {
 844                 *type = AVSYS_AUDIO_VOLUME_TYPE_NOTIFICATION;
 845         } else if (used_table[AVSYS_AUDIO_VOLUME_TYPE_SYSTEM]) {
 846                 *type = AVSYS_AUDIO_VOLUME_TYPE_SYSTEM;
 847         } else if (used_table[AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_JAVA]) {
 848                 *type = AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_JAVA;
 849         } else if (capture_used) {
 850                 /* No Playing instance just capture only. */
 851                 result = AVSYS_STATE_ERR_INVALID_MODE;
 852                 avsys_error(AVAUDIO, "Capture handle only...\n");
 853         } else {
 854                 /* not playing */
 855                 result = AVSYS_STATE_ERR_ALLOCATION;
 856                 avsys_error(AVAUDIO, "There is no running handles...\n");
 857         }
 858
 859         AVSYS_UNLOCK_SYNC();
 860
 861         return result;
 862 }
 863
 864
 865 int avsys_audio_handle_update_volume(avsys_audio_handle_t *p, const int volume_config)
 866 {
 867         int result = AVSYS_STATE_SUCCESS;
 868         avsys_audio_handle_info_t *control = NULL;
 869         avsys_audio_handle_info_t **temp = NULL;
 870         avsys_audio_volume_t *set_volume = NULL;
 871         int vol_conf_type = AVSYS_AUDIO_VOLUME_CONFIG_TYPE(volume_config);
 872
 873         temp = &control;
 874         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
 875
 876         AVSYS_LOCK_SYNC();
 877
 878         set_volume = &(p->setting_vol);
 879         set_volume->level[AVSYS_AUDIO_CHANNEL_LEFT] = control->volume_value[vol_conf_type];
 880         set_volume->level[AVSYS_AUDIO_CHANNEL_RIGHT] = control->volume_value[vol_conf_type];
 881         result = avsys_audio_logical_volume_convert(set_volume, &(p->working_vol), &(p->gain_setting));
 882
 883         AVSYS_UNLOCK_SYNC();
 884
 885         return result;
 886 }
 887
 888 int avsys_audio_handle_update_volume_by_type(const int volume_type, const int volume_value)
 889 {
 890         int i;
 891         int result = AVSYS_STATE_SUCCESS;
 892         avsys_audio_handle_info_t *control = NULL;
 893         avsys_audio_handle_info_t **temp = NULL;
 894         temp = &control;
 895
 896         avsys_info(AVAUDIO, "%s\n", __func__);
 897         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
 898
 899         AVSYS_LOCK_SYNC();
 900
 901         control->volume_value[volume_type] = volume_value;
 902
 903         for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
 904                 int mode;
 905                 avsys_audio_volume_t *set_volume = NULL;
 906                 long long int flag = 0x01;
 907                 int vol_conf_type = AVSYS_AUDIO_VOLUME_CONFIG_TYPE(control->handles[i].gain_setting.volume_config);
 908
 909                 flag <<= i;
 910                 if ((control->allocated & flag) == 0) {
 911                         continue;
 912                 }
 913                 mode = control->handles[i].mode;
 914                 if (mode != AVSYS_AUDIO_MODE_OUTPUT && mode != AVSYS_AUDIO_MODE_OUTPUT_CLOCK
 915                                 && mode != AVSYS_AUDIO_MODE_OUTPUT_VIDEO && mode != AVSYS_AUDIO_MODE_OUTPUT_LOW_LATENCY
 916                                 && mode != AVSYS_AUDIO_MODE_OUTPUT_AP_CALL) {
 917                         continue;
 918                 }
 919
 920                 if (vol_conf_type != volume_type) {
 921                         continue;
 922                 }
 923
 924                 if (control->handles[i].dirty_volume) {
 925                         /* This is volatile volume per handle */
 926                         continue;
 927                 }
 928
 929                 set_volume = &(control->handles[i].setting_vol);
 930                 set_volume->level[AVSYS_AUDIO_CHANNEL_LEFT] = control->volume_value[volume_type];
 931                 set_volume->level[AVSYS_AUDIO_CHANNEL_RIGHT] = control->volume_value[volume_type];
 932                 result = avsys_audio_logical_volume_convert(set_volume, &(control->handles[i].working_vol), &(control->handles[i].gain_setting));
 933                 if (AVSYS_FAIL(result)) {
 934                         avsys_error(AVAUDIO, "Can not set volume for handle %d. Error 0x%x\n", i, result);
 935                         break;
 936                 }
 937                 avsys_warning(AVAUDIO, "stream index %d\n", control->handles[i].stream_index);
 938                 if (AVSYS_FAIL(avsys_audio_pa_ctrl_volume_by_index(control->handles[i].stream_index, control->handles[i].working_vol.level[AVSYS_AUDIO_CHANNEL_LEFT], control->handles[i].channels))) {
 939                         avsys_error(AVAUDIO, "avsys_audio_pa_ctrl_volume_by_index() failed\n");
 940                 }
 941         }
 942
 943         AVSYS_UNLOCK_SYNC();
 944
 945         return result;
 946 }
 947
 948 int avsys_audio_handle_set_primary_volume_type(const int pid, const int type, const int command)
 949 {
 950         int result = AVSYS_STATE_SUCCESS;
 951         avsys_audio_handle_info_t *control = NULL;
 952         avsys_audio_handle_info_t **temp = NULL;
 953         temp = &control;
 954
 955         avsys_info(AVAUDIO, "%s\n", __func__);
 956         if (type < AVSYS_AUDIO_VOLUME_TYPE_SYSTEM || type >= AVSYS_AUDIO_VOLUME_TYPE_MAX || type == AVSYS_AUDIO_VOLUME_TYPE_FIXED) {
 957                 avsys_error(AVAUDIO, "Invalid primary type primary type\n");
 958                 return AVSYS_STATE_ERR_INTERNAL;
 959         }
 960
 961         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
 962
 963         AVSYS_LOCK_SYNC();
 964
 965         if (command == AVSYS_AUDIO_PRIMARY_VOLUME_SET) {
 966                 if (control->primary_volume_type != -1) {
 967                         avsys_warning(AVAUDIO,"Previous primary volume set by %d to %d\n",
 968                                                                                                                 control->primary_volume_pid,
 969                                                                                                                 control->primary_volume_type
 970                                                                                                                 );
 971                 }
 972                 avsys_warning(AVAUDIO, "Primary Volume Type Set to %d [%d]\n", type, pid);
 973                 control->primary_volume_pid = pid;
 974                 control->primary_volume_type = type;
 975         } else if (command == AVSYS_AUDIO_PRIMARY_VOLUME_CLEAR) {
 976                 if (pid != control->primary_volume_pid) {
 977                         avsys_error(AVAUDIO, "Primary volume set api pair is not matched [%d] [%d]\n", control->primary_volume_pid, pid);
 978                 } else {
 979                         avsys_warning(AVAUDIO, "Primary Volume Type Clear [%d]\n", pid);
 980                         control->primary_volume_pid = 0;
 981                         control->primary_volume_type = -1;
 982                 }
 983         } else {
 984                 avsys_error(AVAUDIO, "Unknown Parameter : %d\n", command);
 985                 result = AVSYS_STATE_ERR_INVALID_PARAMETER;
 986         }
 987
 988         AVSYS_UNLOCK_SYNC();
 989
 990         return result;
 991 }
 992
 993 int avsys_audio_handle_update_priority(int handle, int priority, int handle_route, int cmd)
 994 {
 995         long long int flag = 0x01;
 996         int i = 0;
 997         char high_priority_exist = 0;
 998         char transition_effect = 0;
 999         int lpriority = AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0;
1000         avsys_audio_handle_info_t *control = NULL;
1001         avsys_audio_handle_info_t **temp = NULL;
1002
1003         temp = &control;
1004
1005         if (cmd < AVSYS_AUDIO_SET_PRIORITY || cmd > AVSYS_AUDIO_UNSET_PRIORITY) {
1006                 avsys_error_r(AVAUDIO, "Invalid command %s\n", __func__);
1007                 return AVSYS_STATE_ERR_INTERNAL;
1008         }
1009
1010         if (priority >= AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_MAX || priority < AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0) {
1011                 avsys_error(AVAUDIO, "input parameter range error : priority %d. set lowest\n", priority);
1012                 lpriority = AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0;
1013         } else {
1014                 lpriority = priority;
1015         }
1016
1017         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
1018
1019         flag <<= handle;
1020
1021         AVSYS_LOCK_SYNC();
1022
1023         if (control->allocated & flag) {        /* find condition */
1024                 /* update for allocated handle */
1025                 if (cmd == AVSYS_AUDIO_SET_PRIORITY) {
1026                         control->handle_priority[handle] = lpriority;
1027                 } else if (cmd == AVSYS_AUDIO_UNSET_PRIORITY) {
1028                         control->handle_priority[handle] = AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0;
1029                         if (lpriority == AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_2) {  /* unset with priority 2 */
1030                                 transition_effect = 1;
1031                         }
1032                 }
1033         } else {
1034                 avsys_warning(AVAUDIO, "[%s] handle %d does not allocated\n", __func__, handle);
1035                 AVSYS_UNLOCK_SYNC();
1036                 return AVSYS_STATE_ERR_INVALID_VALUE;
1037         }
1038
1039         for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
1040                 if (control->handle_priority[i] == AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_1) {
1041                         high_priority_exist = 1;
1042                 } else if (control->handle_priority[i] == AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_2) {
1043                         high_priority_exist = 1;
1044                         transition_effect = 1;
1045                 }
1046         }
1047
1048         for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
1049                 flag = 0x01;
1050                 flag <<= i;
1051                 if (!(control->allocated & flag))
1052                         continue;
1053
1054                 if (control->handles[i].stream_index == 0) {
1055                         avsys_warning(AVAUDIO, "handle[%d] has stream index 0, skip....(only mono sink-input use 0)\n", i);
1056                         continue;
1057                 }
1058
1059                 if (control->handle_priority[i] == AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0) {
1060
1061                         if (high_priority_exist) {      /* mute */
1062                                 if (transition_effect) {
1063                                         /* set fade out */
1064                                         if (control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT] >= control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT]) {
1065                                                 control->handles[i].fadeup_vol = (-1) * control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT];
1066                                         } else {
1067                                                 control->handles[i].fadeup_vol = (-1) * control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT];
1068                                         }
1069                                         control->handles[i].fadeup_multiplier = 0;
1070                                 } else {
1071                                         /* mute immediately */
1072                                         if (AVSYS_FAIL(avsys_audio_pa_ctrl_mute_by_index(control->handles[i].stream_index, AVSYS_AUDIO_MUTE))) {
1073                                                 avsys_error(AVAUDIO, "set sink input mute for %d failed\n", control->handles[i].stream_index);
1074                                         } else {
1075                                                 avsys_warning(AVAUDIO, "set sink input mute for %d success\n", control->handles[i].stream_index);
1076                                         }
1077                                         control->handles[i].mute = AVSYS_AUDIO_MUTE;
1078                                 }
1079                         } else {        /* unmute */
1080                                 if (transition_effect) {
1081                                         /* set fade in */
1082                                         if (control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT] >= control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT]) {
1083                                                 control->handles[i].fadeup_vol = control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT];
1084                                         } else {
1085                                                 control->handles[i].fadeup_vol = control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT];
1086                                         }
1087                                         control->handles[i].fadeup_multiplier = 0;
1088                                 } else {
1089                                         /* unmute immediately */
1090                                         if (control->handles[i].mute != AVSYS_AUDIO_UNMUTE) {
1091                                                 if (AVSYS_FAIL(avsys_audio_pa_ctrl_mute_by_index(control->handles[i].stream_index, AVSYS_AUDIO_UNMUTE))) {
1092                                                         avsys_error(AVAUDIO, "set sink input unmute for %d failed\n", control->handles[i].stream_index);
1093                                                 } else {
1094                                                         avsys_warning(AVAUDIO, "set sink input unmute for %d success\n", control->handles[i].stream_index);
1095                                                 }
1096                                                 control->handles[i].mute = AVSYS_AUDIO_UNMUTE;
1097                                         }
1098                                 }
1099                         }
1100                 }
1101         }
1102
1103         AVSYS_UNLOCK_SYNC();
1104
1105         if (transition_effect)
1106                 sleep(1);
1107         else if (!transition_effect && high_priority_exist)
1108                 usleep(20);
1109
1110         return AVSYS_STATE_SUCCESS;
1111 }
1112
1113 int avsys_audio_handle_current_capture_status(int *on_capture)
1114 {
1115         int i = 0;
1116         char capture_used = 0;
1117         avsys_audio_handle_info_t *control = NULL;
1118         avsys_audio_handle_info_t **temp = NULL;
1119
1120         if (!on_capture)
1121                 return AVSYS_STATE_ERR_INVALID_PARAMETER;
1122
1123         temp = &control;
1124
1125         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
1126
1127         AVSYS_LOCK_SYNC();
1128
1129         for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
1130                 long long int flag = 0x01;
1131                 flag <<= i;
1132                 if (control->allocated & flag) {
1133                         if(control->handles[i].mode == AVSYS_AUDIO_MODE_INPUT ||
1134                                         control->handles[i].mode == AVSYS_AUDIO_MODE_INPUT_HIGH_LATENCY ||
1135                                         control->handles[i].mode == AVSYS_AUDIO_MODE_INPUT_LOW_LATENCY ||
1136                                         control->handles[i].mode == AVSYS_AUDIO_MODE_INPUT_AP_CALL) {
1137                                 capture_used = 1;
1138                                 break;
1139                         }
1140                 }
1141         }
1142         if (capture_used) {
1143                 avsys_info(AVAUDIO, "Audio capture is running\n");
1144                 *on_capture = 1;
1145         } else {
1146                 *on_capture = 0;
1147         }
1148
1149         AVSYS_UNLOCK_SYNC();
1150
1151         return AVSYS_STATE_SUCCESS;
1152 }