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