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_free(int handle)
 443 {
 444         long long int flag = 0x01;
 445         avsys_audio_handle_info_t *control = NULL;
 446         avsys_audio_handle_info_t **temp = NULL;
 447         temp = &control;
 448
 449         avsys_info(AVAUDIO, "%s, handle=[%d]\n", __func__, handle);
 450
 451         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
 452
 453         flag <<= handle;
 454
 455         AVSYS_LOCK_SYNC();
 456         if (control->allocated & flag) {        /* find condition */
 457                 control->allocated &= ~flag;
 458                 /* clear handle mute field */
 459                 if (control->handle_amp & flag) {
 460                         control->handle_amp &= ~flag;
 461                 }
 462                 AVSYS_UNLOCK_SYNC();
 463                 return AVSYS_STATE_SUCCESS;
 464         } else {
 465                 AVSYS_UNLOCK_SYNC();
 466                 return AVSYS_STATE_ERR_INVALID_VALUE;
 467         }
 468 }
 469
 470 int avsys_audio_handle_get_ptr(int handle, avsys_audio_handle_t **ptr, const int mode)
 471 {
 472         long long int flag = 0x01;
 473         avsys_audio_handle_info_t *control = NULL;
 474         avsys_audio_handle_info_t **temp = NULL;
 475         int ret = AVSYS_STATE_SUCCESS;
 476
 477         //avsys_info(AVAUDIO, "%s handle %d\n", __func__, handle);
 478
 479         if (handle < 0 || handle >= AVSYS_AUDIO_HANDLE_MAX) {
 480                 *ptr = NULL;
 481                 return AVSYS_STATE_ERR_INVALID_HANDLE;
 482         }
 483
 484         if (mode < 0 || mode >= HANDLE_PTR_MODE_NUM) {
 485                 *ptr = NULL;
 486                 return AVSYS_STATE_ERR_INVALID_PARAMETER;
 487         }
 488
 489         temp = &control;
 490         if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_HANDLE, (void **)temp))) {
 491                 avsys_error(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
 492                 *ptr = NULL;
 493                 return AVSYS_STATE_ERR_INTERNAL;
 494         }
 495
 496         flag <<= handle;
 497
 498         if (mode == HANDLE_PTR_MODE_NORMAL) {
 499                 if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_HANDLE))) {
 500                         avsys_error(AVAUDIO, "avsys_audio_lock_sync() failed in %s\n", __func__);
 501                         *ptr = NULL;
 502                         return AVSYS_STATE_ERR_INTERNAL;
 503                 }
 504         }
 505
 506         if (control->allocated & flag) {
 507                 //avsys_info(AVAUDIO, "input handle %d flag %x allocated %x\n", handle, flag, control->allocated);
 508                 *ptr = &(control->handles[handle]);
 509                 ret = AVSYS_STATE_SUCCESS;
 510         } else {
 511                 *ptr = NULL;
 512                 ret = AVSYS_STATE_ERR_INVALID_VALUE;
 513         }
 514
 515         if (mode == HANDLE_PTR_MODE_NORMAL) {
 516                 if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_HANDLE))) {
 517                         avsys_error(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
 518                         *ptr = NULL;
 519                         return AVSYS_STATE_ERR_INTERNAL;
 520                 }
 521         }
 522
 523         return ret;
 524 }
 525
 526 int avsys_audio_handle_release_ptr(int handle, const int mode)
 527 {
 528         long long int flag = 0x01;
 529         avsys_audio_handle_info_t *control = NULL;
 530         avsys_audio_handle_info_t **temp = NULL;
 531         int ret = AVSYS_STATE_SUCCESS;
 532
 533         //avsys_info(AVAUDIO, "%s handle %d\n", __func__, handle);
 534
 535         if (handle < 0 || handle >= AVSYS_AUDIO_HANDLE_MAX) {
 536                 return AVSYS_STATE_ERR_INVALID_HANDLE;
 537         }
 538
 539         if (mode < 0 || mode >= HANDLE_PTR_MODE_NUM) {
 540                 return AVSYS_STATE_ERR_INVALID_PARAMETER;
 541         }
 542
 543         temp = &control;
 544         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
 545
 546         flag <<= handle;
 547
 548         //avsys_info(AVAUDIO, "input handle %d flag %x allocated %x\n", handle, flag, control->allocated);
 549         if (mode == HANDLE_PTR_MODE_NORMAL) {
 550                 AVSYS_LOCK_SYNC();
 551         }
 552
 553         if (control->allocated & flag) {
 554                 ret = AVSYS_STATE_SUCCESS;
 555         } else {
 556                 ret = AVSYS_STATE_ERR_INVALID_VALUE;
 557         }
 558
 559         if (mode == HANDLE_PTR_MODE_NORMAL) {
 560                 AVSYS_UNLOCK_SYNC();
 561         }
 562
 563         return ret;
 564 }
 565
 566 int avsys_audio_handle_set_mute(int handle, int mute)
 567 {
 568         long long int flag = 0x01;
 569         int result = AVSYS_STATE_SUCCESS;
 570         int path_mute = 0;
 571         avsys_audio_handle_info_t *control = NULL;
 572         avsys_audio_handle_info_t **temp = NULL;
 573         avsys_audio_handle_t *ptr = NULL;
 574         temp = &control;
 575
 576         avsys_info(AVAUDIO, "%s_%d_%d\n", __func__, handle, mute);
 577         if (mute > AVSYS_AUDIO_MUTE || mute < AVSYS_AUDIO_UNMUTE) {
 578                 avsys_error_r(AVAUDIO, "input parameter range error : mute %d\n", mute);
 579                 return AVSYS_STATE_ERR_INVALID_PARAMETER;
 580         }
 581
 582         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
 583
 584         flag <<= handle;
 585
 586         AVSYS_LOCK_SYNC();
 587
 588         if (control->allocated & flag) {        /* find condition */
 589                 /* update mute information for input handle parameter */
 590                 ptr = &(control->handles[handle]);
 591                 ptr->mute = mute;
 592                 avsys_audio_pa_ctrl_mute_by_index(ptr->stream_index, mute);
 593
 594                 /* update handle amp information */
 595                 if (mute == AVSYS_AUDIO_UNMUTE) {
 596 #ifdef _VERBOSE_
 597                         if (control->handle_amp & flag)
 598                                 avsys_warning(AVAUDIO, "handle 0x%x already powered\n");
 599                         else
 600                                 control->handle_amp |= flag;
 601 #else
 602                         if (!(control->handle_amp & flag))
 603                                 control->handle_amp |= flag;
 604
 605                         /* reset fadedown mute */
 606                         ptr->fadeup_vol = 0;
 607 #endif
 608                 } else if (mute == AVSYS_AUDIO_MUTE) {
 609                         /* clear handle amp field */
 610                         if (control->handle_amp & flag)
 611                                 control->handle_amp &= ~flag;
 612 #ifdef _VERBOSE_
 613                         else
 614                                 avsys_warning(AVAUDIO, "handle 0x%x already off\n");
 615 #endif
 616                 }
 617
 618                 result = AVSYS_STATE_SUCCESS;
 619         } else {
 620                 avsys_warning(AVAUDIO, "[%s] handle %d does not allocated\n", __func__, handle);
 621                 if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_HANDLE))) {
 622                         avsys_error(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
 623                         return AVSYS_STATE_ERR_INTERNAL;
 624                 }
 625                 return AVSYS_STATE_ERR_INVALID_VALUE;
 626         }
 627
 628         if (control->handle_amp | control->ext_device_amp)
 629                 path_mute = AVSYS_AUDIO_UNMUTE;
 630         else
 631                 path_mute = AVSYS_AUDIO_MUTE;
 632
 633         AVSYS_UNLOCK_SYNC();
 634
 635         if (AVSYS_FAIL(avsys_audio_path_ex_set_mute(path_mute))) {
 636                 avsys_error_r(AVAUDIO, "Path mute control failed. %s_%d\n", __func__, path_mute);
 637                 result = AVSYS_STATE_ERR_IO_CONTROL;
 638         }
 639         return result;
 640 }
 641
 642 int avsys_audio_handle_ext_dev_set_mute(avsysaudio_ext_device_t device_type, int mute)
 643 {
 644         int bit = 0;
 645         int result = AVSYS_STATE_SUCCESS;
 646         int path_mute = 0;
 647         avsys_audio_handle_info_t *control = NULL;
 648         avsys_audio_handle_info_t **temp = NULL;
 649         temp = &control;
 650
 651         avsys_info(AVAUDIO, "%s_%d_%d\n", __func__, (int)device_type, mute);
 652         if (mute > AVSYS_AUDIO_MUTE || mute < AVSYS_AUDIO_UNMUTE) {
 653                 avsys_error_r(AVAUDIO, "input parameter range error : mute %d\n", mute);
 654                 return AVSYS_STATE_ERR_INVALID_PARAMETER;
 655         }
 656
 657         switch (device_type) {
 658         case AVSYS_AUDIO_EXT_DEVICE_FMRADIO:
 659                 bit = AVSYS_AUDIO_HANDLE_EXT_DEV_FMRADIO;
 660                 break;
 661         default:
 662                 avsys_error(AVAUDIO, "Unknown device type %d\n", (int)device_type);
 663                 return AVSYS_STATE_ERR_INVALID_PARAMETER;
 664         }
 665
 666         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
 667
 668         AVSYS_LOCK_SYNC();
 669
 670         if (mute == AVSYS_AUDIO_MUTE) {
 671                 control->ext_device_amp |= bit;
 672         } else {
 673                 control->ext_device_amp &= ~bit;
 674         }
 675
 676         if (control->handle_amp | control->ext_device_amp)
 677                 path_mute = AVSYS_AUDIO_UNMUTE;
 678         else
 679                 path_mute = AVSYS_AUDIO_MUTE;
 680
 681         AVSYS_UNLOCK_SYNC();
 682
 683         if (AVSYS_FAIL(avsys_audio_path_ex_set_mute(path_mute))) {
 684                 avsys_error_r(AVAUDIO, "Path mute control failed. %s_%d\n", __func__, path_mute);
 685                 result = AVSYS_STATE_ERR_IO_CONTROL;
 686         }
 687         return result;
 688 }
 689
 690 int avsys_audio_handle_ext_dev_status(avsysaudio_ext_device_t device_type, int *onoff)
 691 {
 692         int result = AVSYS_STATE_SUCCESS;
 693         int ext_dev_state = 0;
 694
 695         avsys_audio_handle_info_t *control = NULL;
 696         avsys_audio_handle_info_t **temp = NULL;
 697         temp = &control;
 698
 699         avsys_info(AVAUDIO, "%s\n", __func__);
 700
 701         if (onoff == NULL) {
 702                 avsys_error(AVAUDIO, "Null pointer input parameter\n");
 703                 return AVSYS_STATE_ERR_NULL_POINTER;
 704         }
 705
 706         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
 707
 708         AVSYS_LOCK_SYNC();
 709
 710         switch (device_type) {
 711         case AVSYS_AUDIO_EXT_DEVICE_FMRADIO:
 712                 if (control->ext_device_status & AVSYS_AUDIO_HANDLE_EXT_DEV_FMRADIO) {
 713                         ext_dev_state = 1;
 714                 } else {
 715                         ext_dev_state = 0;
 716                 }
 717                 *onoff = ext_dev_state;
 718                 break;
 719         default:
 720                 avsys_error(AVAUDIO, "Invalid device type %d\n", device_type);
 721                 result = AVSYS_STATE_ERR_INTERNAL;
 722                 break;
 723         }
 724
 725         AVSYS_UNLOCK_SYNC();
 726         return result;
 727 }
 728
 729 int avsys_audio_handle_ext_dev_status_update(avsysaudio_ext_device_t device_type, int onoff)
 730 {
 731         int bit = 0;
 732         int result = AVSYS_STATE_SUCCESS;
 733         avsys_audio_handle_info_t *control = NULL;
 734         avsys_audio_handle_info_t **temp = NULL;
 735         temp = &control;
 736
 737         avsys_info(AVAUDIO, "%s_%d_%d\n", __func__, (int)device_type, onoff);
 738
 739         switch (device_type) {
 740         case AVSYS_AUDIO_EXT_DEVICE_FMRADIO:
 741                 bit = AVSYS_AUDIO_HANDLE_EXT_DEV_FMRADIO;
 742                 break;
 743         default:
 744                 avsys_error(AVAUDIO, "Unknown device type %d\n", (int)device_type);
 745                 return AVSYS_STATE_ERR_INVALID_PARAMETER;
 746         }
 747
 748         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
 749
 750         AVSYS_LOCK_SYNC();
 751
 752         if (onoff > 0) {
 753                 control->ext_device_status |= bit;
 754         } else if (onoff == 0) {
 755                 control->ext_device_status &= ~bit;
 756         } else {
 757                 avsys_error(AVAUDIO, "[%s] Unknown parameter %d. To nothing\n", __func__, onoff);
 758         }
 759
 760         AVSYS_UNLOCK_SYNC();
 761         return result;
 762 }
 763
 764 int avsys_audio_handle_current_playing_volume_type(int *type)
 765 {
 766         int result = AVSYS_STATE_SUCCESS;
 767         int i = 0;
 768         char used_table[AVSYS_AUDIO_VOLUME_TYPE_MAX] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 769         char capture_used = 0;
 770         avsys_audio_handle_info_t *control = NULL;
 771         avsys_audio_handle_info_t **temp = NULL;
 772         temp = &control;
 773
 774         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
 775
 776         AVSYS_LOCK_SYNC();
 777
 778         for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
 779                 long long int flag = 0x01;
 780                 flag <<= i;
 781                 if (control->allocated & flag) {
 782                         int vol_conf_type = AVSYS_AUDIO_VOLUME_CONFIG_TYPE(control->handles[i].gain_setting.volume_config);
 783                         if(control->handles[i].mode == AVSYS_AUDIO_MODE_OUTPUT ||
 784                                         control->handles[i].mode == AVSYS_AUDIO_MODE_OUTPUT_CLOCK ||
 785                                         control->handles[i].mode == AVSYS_AUDIO_MODE_OUTPUT_VIDEO ||
 786                                         control->handles[i].mode == AVSYS_AUDIO_MODE_OUTPUT_LOW_LATENCY ) {
 787                                 used_table[vol_conf_type] = 1;
 788                         }
 789                         else if(control->handles[i].mode == AVSYS_AUDIO_MODE_INPUT ||
 790                                         control->handles[i].mode == AVSYS_AUDIO_MODE_INPUT_HIGH_LATENCY ||
 791                                         control->handles[i].mode == AVSYS_AUDIO_MODE_INPUT_LOW_LATENCY) {
 792                                 capture_used = 1;
 793                         }
 794                 }
 795         }
 796         if (control->ext_device_status & AVSYS_AUDIO_HANDLE_EXT_DEV_FMRADIO) {
 797                 used_table[AVSYS_AUDIO_VOLUME_TYPE_MEDIA] = 1;
 798         }
 799
 800         avsys_warning(AVAUDIO,"Call[%d] VOIP[%d] Ringtone[%d] Media[%d] Alarm[%d] Notification[%d] System[%d] Android[%d] Java[%d] Capture[%d]\n",
 801                         used_table[AVSYS_AUDIO_VOLUME_TYPE_CALL],
 802                         used_table[AVSYS_AUDIO_VOLUME_TYPE_VOIP],
 803                         used_table[AVSYS_AUDIO_VOLUME_TYPE_RINGTONE],
 804                         used_table[AVSYS_AUDIO_VOLUME_TYPE_MEDIA],
 805                         used_table[AVSYS_AUDIO_VOLUME_TYPE_ALARM],
 806                         used_table[AVSYS_AUDIO_VOLUME_TYPE_NOTIFICATION],
 807                         used_table[AVSYS_AUDIO_VOLUME_TYPE_SYSTEM],
 808                         used_table[AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_ANDROID],
 809                         used_table[AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_JAVA],
 810                         capture_used);
 811
 812         if (control->primary_volume_pid > 2 && AVSYS_FAIL(avsys_check_process(control->primary_volume_pid))) {
 813                 avsys_warning(AVAUDIO, "Primary volume set pid does not exist anymore. clean primary volume\n");
 814                 control->primary_volume_type = -1;
 815                 control->primary_volume_pid = 0;
 816         }
 817
 818         if (control->primary_volume_type != -1) {
 819                 *type = control->primary_volume_type;
 820                 avsys_warning(AVAUDIO, "Primary volume is %d\n", control->primary_volume_type);
 821         } else if (used_table[AVSYS_AUDIO_VOLUME_TYPE_CALL]) {
 822                 *type = AVSYS_AUDIO_VOLUME_TYPE_CALL;
 823         } else if (used_table[AVSYS_AUDIO_VOLUME_TYPE_VOIP]) {
 824                 *type = AVSYS_AUDIO_VOLUME_TYPE_VOIP;
 825         } else if (used_table[AVSYS_AUDIO_VOLUME_TYPE_RINGTONE]) {
 826                 *type = AVSYS_AUDIO_VOLUME_TYPE_RINGTONE;
 827         } else if (used_table[AVSYS_AUDIO_VOLUME_TYPE_MEDIA]) {
 828                 *type = AVSYS_AUDIO_VOLUME_TYPE_MEDIA;
 829         } else if (used_table[AVSYS_AUDIO_VOLUME_TYPE_ALARM]) {
 830                 *type = AVSYS_AUDIO_VOLUME_TYPE_ALARM;
 831         } else if (used_table[AVSYS_AUDIO_VOLUME_TYPE_NOTIFICATION]) {
 832                 *type = AVSYS_AUDIO_VOLUME_TYPE_NOTIFICATION;
 833         } else if (used_table[AVSYS_AUDIO_VOLUME_TYPE_SYSTEM]) {
 834                 *type = AVSYS_AUDIO_VOLUME_TYPE_SYSTEM;
 835         } else if (used_table[AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_JAVA]) {
 836                 *type = AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_JAVA;
 837         } else if (capture_used) {
 838                 /* No Playing instance just capture only. */
 839                 result = AVSYS_STATE_ERR_INVALID_MODE;
 840                 avsys_error(AVAUDIO, "Capture handle only...\n");
 841         } else {
 842                 /* not playing */
 843                 result = AVSYS_STATE_ERR_ALLOCATION;
 844                 avsys_error(AVAUDIO, "There is no running handles...\n");
 845         }
 846
 847         AVSYS_UNLOCK_SYNC();
 848
 849         return result;
 850 }
 851
 852
 853 int avsys_audio_handle_update_volume(avsys_audio_handle_t *p, const int volume_config)
 854 {
 855         int result = AVSYS_STATE_SUCCESS;
 856         avsys_audio_handle_info_t *control = NULL;
 857         avsys_audio_handle_info_t **temp = NULL;
 858         avsys_audio_volume_t *set_volume = NULL;
 859         int vol_conf_type = AVSYS_AUDIO_VOLUME_CONFIG_TYPE(volume_config);
 860
 861         temp = &control;
 862         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
 863
 864         AVSYS_LOCK_SYNC();
 865
 866         set_volume = &(p->setting_vol);
 867         set_volume->level[AVSYS_AUDIO_CHANNEL_LEFT] = control->volume_value[vol_conf_type];
 868         set_volume->level[AVSYS_AUDIO_CHANNEL_RIGHT] = control->volume_value[vol_conf_type];
 869         result = avsys_audio_logical_volume_convert(set_volume, &(p->working_vol), &(p->gain_setting));
 870
 871         AVSYS_UNLOCK_SYNC();
 872
 873         return result;
 874 }
 875
 876 int avsys_audio_handle_update_volume_by_type(const int volume_type, const int volume_value)
 877 {
 878         int i;
 879         int result = AVSYS_STATE_SUCCESS;
 880         avsys_audio_handle_info_t *control = NULL;
 881         avsys_audio_handle_info_t **temp = NULL;
 882         temp = &control;
 883
 884         avsys_info(AVAUDIO, "%s\n", __func__);
 885         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
 886
 887         AVSYS_LOCK_SYNC();
 888
 889         control->volume_value[volume_type] = volume_value;
 890
 891         for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
 892                 int mode;
 893                 avsys_audio_volume_t *set_volume = NULL;
 894                 long long int flag = 0x01;
 895                 int vol_conf_type = AVSYS_AUDIO_VOLUME_CONFIG_TYPE(control->handles[i].gain_setting.volume_config);
 896
 897                 flag <<= i;
 898                 if ((control->allocated & flag) == 0) {
 899                         continue;
 900                 }
 901                 mode = control->handles[i].mode;
 902                 if (mode != AVSYS_AUDIO_MODE_OUTPUT && mode != AVSYS_AUDIO_MODE_OUTPUT_CLOCK
 903                                 && mode != AVSYS_AUDIO_MODE_OUTPUT_VIDEO && mode != AVSYS_AUDIO_MODE_OUTPUT_LOW_LATENCY
 904                                 && mode != AVSYS_AUDIO_MODE_OUTPUT_AP_CALL) {
 905                         continue;
 906                 }
 907
 908                 if (vol_conf_type != volume_type) {
 909                         continue;
 910                 }
 911
 912                 if (control->handles[i].dirty_volume) {
 913                         /* This is volatile volume per handle */
 914                         continue;
 915                 }
 916
 917                 set_volume = &(control->handles[i].setting_vol);
 918                 set_volume->level[AVSYS_AUDIO_CHANNEL_LEFT] = control->volume_value[volume_type];
 919                 set_volume->level[AVSYS_AUDIO_CHANNEL_RIGHT] = control->volume_value[volume_type];
 920                 result = avsys_audio_logical_volume_convert(set_volume, &(control->handles[i].working_vol), &(control->handles[i].gain_setting));
 921                 if (AVSYS_FAIL(result)) {
 922                         avsys_error(AVAUDIO, "Can not set volume for handle %d. Error 0x%x\n", i, result);
 923                         break;
 924                 }
 925                 avsys_warning(AVAUDIO, "stream index %d\n", control->handles[i].stream_index);
 926                 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))) {
 927                         avsys_error(AVAUDIO, "avsys_audio_pa_ctrl_volume_by_index() failed\n");
 928                 }
 929         }
 930
 931         AVSYS_UNLOCK_SYNC();
 932
 933         return result;
 934 }
 935
 936 int avsys_audio_handle_set_primary_volume_type(const int pid, const int type, const int command)
 937 {
 938         int result = AVSYS_STATE_SUCCESS;
 939         avsys_audio_handle_info_t *control = NULL;
 940         avsys_audio_handle_info_t **temp = NULL;
 941         temp = &control;
 942
 943         avsys_info(AVAUDIO, "%s\n", __func__);
 944         if (type < AVSYS_AUDIO_VOLUME_TYPE_SYSTEM || type >= AVSYS_AUDIO_VOLUME_TYPE_MAX || type == AVSYS_AUDIO_VOLUME_TYPE_FIXED) {
 945                 avsys_error(AVAUDIO, "Invalid primary type primary type\n");
 946                 return AVSYS_STATE_ERR_INTERNAL;
 947         }
 948
 949         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
 950
 951         AVSYS_LOCK_SYNC();
 952
 953         if (command == AVSYS_AUDIO_PRIMARY_VOLUME_SET) {
 954                 if (control->primary_volume_type != -1) {
 955                         avsys_warning(AVAUDIO,"Previous primary volume set by %d to %d\n",
 956                                                                                                                 control->primary_volume_pid,
 957                                                                                                                 control->primary_volume_type
 958                                                                                                                 );
 959                 }
 960                 avsys_warning(AVAUDIO, "Primary Volume Type Set to %d [%d]\n", type, pid);
 961                 control->primary_volume_pid = pid;
 962                 control->primary_volume_type = type;
 963         } else if (command == AVSYS_AUDIO_PRIMARY_VOLUME_CLEAR) {
 964                 if (pid != control->primary_volume_pid) {
 965                         avsys_error(AVAUDIO, "Primary volume set api pair is not matched [%d] [%d]\n", control->primary_volume_pid, pid);
 966                 } else {
 967                         avsys_warning(AVAUDIO, "Primary Volume Type Clear [%d]\n", pid);
 968                         control->primary_volume_pid = 0;
 969                         control->primary_volume_type = -1;
 970                 }
 971         } else {
 972                 avsys_error(AVAUDIO, "Unknown Parameter : %d\n", command);
 973                 result = AVSYS_STATE_ERR_INVALID_PARAMETER;
 974         }
 975
 976         AVSYS_UNLOCK_SYNC();
 977
 978         return result;
 979 }
 980
 981 int avsys_audio_handle_update_priority(int handle, int priority, int handle_route, int cmd)
 982 {
 983         long long int flag = 0x01;
 984         int i = 0;
 985         char high_priority_exist = 0;
 986         char transition_effect = 0;
 987         int lpriority = AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0;
 988         avsys_audio_handle_info_t *control = NULL;
 989         avsys_audio_handle_info_t **temp = NULL;
 990
 991         temp = &control;
 992
 993         if (cmd < AVSYS_AUDIO_SET_PRIORITY || cmd > AVSYS_AUDIO_UNSET_PRIORITY) {
 994                 avsys_error_r(AVAUDIO, "Invalid command %s\n", __func__);
 995                 return AVSYS_STATE_ERR_INTERNAL;
 996         }
 997
 998         if (priority >= AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_MAX || priority < AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0) {
 999                 avsys_error(AVAUDIO, "input parameter range error : priority %d. set lowest\n", priority);
1000                 lpriority = AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0;
1001         } else {
1002                 lpriority = priority;
1003         }
1004
1005         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
1006
1007         flag <<= handle;
1008
1009         AVSYS_LOCK_SYNC();
1010
1011         if (control->allocated & flag) {        /* find condition */
1012                 /* update for allocated handle */
1013                 if (cmd == AVSYS_AUDIO_SET_PRIORITY) {
1014                         control->handle_priority[handle] = lpriority;
1015                 } else if (cmd == AVSYS_AUDIO_UNSET_PRIORITY) {
1016                         control->handle_priority[handle] = AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0;
1017                         if (lpriority == AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_2) {  /* unset with priority 2 */
1018                                 transition_effect = 1;
1019                         }
1020                 }
1021         } else {
1022                 avsys_warning(AVAUDIO, "[%s] handle %d does not allocated\n", __func__, handle);
1023                 AVSYS_UNLOCK_SYNC();
1024                 return AVSYS_STATE_ERR_INVALID_VALUE;
1025         }
1026
1027         for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
1028                 if (control->handle_priority[i] == AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_1) {
1029                         high_priority_exist = 1;
1030                 } else if (control->handle_priority[i] == AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_2) {
1031                         high_priority_exist = 1;
1032                         transition_effect = 1;
1033                 }
1034         }
1035
1036         for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
1037                 flag = 0x01;
1038                 flag <<= i;
1039                 if (!(control->allocated & flag))
1040                         continue;
1041
1042                 if (control->handles[i].stream_index == 0) {
1043                         avsys_warning(AVAUDIO, "handle[%d] has stream index 0, skip....(only mono sink-input use 0)\n", i);
1044                         continue;
1045                 }
1046
1047                 if (control->handle_priority[i] == AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0) {
1048
1049                         if (high_priority_exist) {      /* mute */
1050                                 if (transition_effect) {
1051                                         /* set fade out */
1052                                         if (control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT] >= control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT]) {
1053                                                 control->handles[i].fadeup_vol = (-1) * control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT];
1054                                         } else {
1055                                                 control->handles[i].fadeup_vol = (-1) * control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT];
1056                                         }
1057                                         control->handles[i].fadeup_multiplier = 0;
1058                                 } else {
1059                                         /* mute immediately */
1060                                         if (AVSYS_FAIL(avsys_audio_pa_ctrl_mute_by_index(control->handles[i].stream_index, AVSYS_AUDIO_MUTE))) {
1061                                                 avsys_error(AVAUDIO, "set sink input mute for %d failed\n", control->handles[i].stream_index);
1062                                         } else {
1063                                                 avsys_warning(AVAUDIO, "set sink input mute for %d success\n", control->handles[i].stream_index);
1064                                         }
1065                                         control->handles[i].mute = AVSYS_AUDIO_MUTE;
1066                                 }
1067                         } else {        /* unmute */
1068                                 if (transition_effect) {
1069                                         /* set fade in */
1070                                         if (control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT] >= control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT]) {
1071                                                 control->handles[i].fadeup_vol = control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT];
1072                                         } else {
1073                                                 control->handles[i].fadeup_vol = control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT];
1074                                         }
1075                                         control->handles[i].fadeup_multiplier = 0;
1076                                 } else {
1077                                         /* unmute immediately */
1078                                         if (control->handles[i].mute != AVSYS_AUDIO_UNMUTE) {
1079                                                 if (AVSYS_FAIL(avsys_audio_pa_ctrl_mute_by_index(control->handles[i].stream_index, AVSYS_AUDIO_UNMUTE))) {
1080                                                         avsys_error(AVAUDIO, "set sink input unmute for %d failed\n", control->handles[i].stream_index);
1081                                                 } else {
1082                                                         avsys_warning(AVAUDIO, "set sink input unmute for %d success\n", control->handles[i].stream_index);
1083                                                 }
1084                                                 control->handles[i].mute = AVSYS_AUDIO_UNMUTE;
1085                                         }
1086                                 }
1087                         }
1088                 }
1089         }
1090
1091         AVSYS_UNLOCK_SYNC();
1092
1093         if (transition_effect)
1094                 sleep(1);
1095         else if (!transition_effect && high_priority_exist)
1096                 usleep(20);
1097
1098         return AVSYS_STATE_SUCCESS;
1099 }
1100
1101 int avsys_audio_handle_current_capture_status(int *on_capture)
1102 {
1103         int i = 0;
1104         char capture_used = 0;
1105         avsys_audio_handle_info_t *control = NULL;
1106         avsys_audio_handle_info_t **temp = NULL;
1107
1108         if (!on_capture)
1109                 return AVSYS_STATE_ERR_INVALID_PARAMETER;
1110
1111         temp = &control;
1112
1113         AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
1114
1115         AVSYS_LOCK_SYNC();
1116
1117         for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
1118                 long long int flag = 0x01;
1119                 flag <<= i;
1120                 if (control->allocated & flag) {
1121                         if(control->handles[i].mode == AVSYS_AUDIO_MODE_INPUT ||
1122                                         control->handles[i].mode == AVSYS_AUDIO_MODE_INPUT_HIGH_LATENCY ||
1123                                         control->handles[i].mode == AVSYS_AUDIO_MODE_INPUT_LOW_LATENCY ||
1124                                         control->handles[i].mode == AVSYS_AUDIO_MODE_INPUT_AP_CALL) {
1125                                 capture_used = 1;
1126                                 break;
1127                         }
1128                 }
1129         }
1130         if (capture_used) {
1131                 avsys_info(AVAUDIO, "Audio capture is running\n");
1132                 *on_capture = 1;
1133         } else {
1134                 *on_capture = 0;
1135         }
1136
1137         AVSYS_UNLOCK_SYNC();
1138
1139         return AVSYS_STATE_SUCCESS;
1140 }