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