4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
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
12 * http://www.apache.org/licenses/LICENSE-2.0
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.
24 #include <sys/types.h>
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"
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
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__); \
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; \
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; \
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 */
81 int avsys_audio_handle_init(void)
84 avsys_audio_handle_info_t *control = NULL;
85 avsys_audio_handle_info_t **temp = NULL;
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;
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;
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;
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;
114 for (i = 0; i < AVSYS_AUDIO_LOCK_SLOT_MAX; i++) {
115 control->handlelock_pid[i] = -1;
117 return AVSYS_STATE_SUCCESS;
121 int avsys_audio_handle_fini(void)
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;
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;
138 return AVSYS_STATE_SUCCESS;
142 int avsys_audio_handle_reset(int *volume_value)
145 long long int flag = 0x01;
146 avsys_audio_handle_info_t *control = NULL;
147 avsys_audio_handle_info_t **temp = NULL;
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;
157 volumes = (volume_value) ? volume_value : (int *)g_default_volume;
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))) {
163 if (AVSYS_FAIL(avsys_audio_handle_free(i))) {
164 avsys_error(AVAUDIO, "Cleanup handle %d failed\n", i);
170 #ifdef USE_HIBERNATION
171 while (control->allocated) {
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);
181 if (volume_value == NULL) {
182 control->allocated = 0;
183 control->handle_amp = 0;
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;
192 /* Clear semaphore condition */
193 for (i = 0; i < AVSYS_AUDIO_LOCK_SLOT_MAX; i++) {
194 control->handlelock_pid[i] = -1;
199 return AVSYS_STATE_SUCCESS;
203 int avsys_audio_handle_rejuvenation(void)
206 long long int flag = 0x01;
207 int dead_handle = 0x00;
209 avsys_audio_handle_info_t *control = NULL;
210 avsys_audio_handle_info_t **temp = NULL;
211 int dead_pids[AVSYS_AUDIO_HANDLE_MAX];
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;
223 /* Clear semaphore condition */
225 for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
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;
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);
252 char high_priority_exist = 0;
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;
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);
269 avsys_warning(AVAUDIO, "set sink input mute for %d success\n", control->handles[i].stream_index);
271 control->handles[i].mute = AVSYS_AUDIO_MUTE;
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);
279 avsys_warning(AVAUDIO, "set sink input unmute for %d success\n", control->handles[i].stream_index);
281 control->handles[i].mute = AVSYS_AUDIO_UNMUTE;
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);
291 avsys_warning(AVAUDIO, "set sink input unmute for %d success\n", control->handles[i].stream_index);
293 control->handles[i].mute = AVSYS_AUDIO_UNMUTE;
301 return AVSYS_STATE_SUCCESS;
305 int avsys_audio_handle_dump(void)
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" };
312 long long int flag = 0x01;
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;
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]);
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]);
348 fprintf(stdout, " Volume Type : %s\n", vol_str[vol_conf_type]);
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]);
355 fprintf(stdout, " ----------------------------------------------------------------------\n");
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]);
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");
403 return AVSYS_STATE_SUCCESS;
406 int avsys_audio_handle_alloc(int *handle)
408 long long int flag = 0x01;
410 avsys_audio_handle_info_t *control = NULL;
411 avsys_audio_handle_info_t **temp = NULL;
414 avsys_info(AVAUDIO, "%s\n", __func__);
415 AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
418 for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
419 if ((control->allocated & flag) == 0) { /* alloc condition */
420 control->allocated |= flag;
429 if (i == AVSYS_AUDIO_HANDLE_MAX) {
431 return AVSYS_STATE_ERR_RANGE_OVER;
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();
438 return AVSYS_STATE_SUCCESS;
442 int avsys_audio_handle_free(int handle)
444 long long int flag = 0x01;
445 avsys_audio_handle_info_t *control = NULL;
446 avsys_audio_handle_info_t **temp = NULL;
449 avsys_info(AVAUDIO, "%s, handle=[%d]\n", __func__, handle);
451 AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
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;
463 return AVSYS_STATE_SUCCESS;
466 return AVSYS_STATE_ERR_INVALID_VALUE;
470 int avsys_audio_handle_get_ptr(int handle, avsys_audio_handle_t **ptr, const int mode)
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;
477 //avsys_info(AVAUDIO, "%s handle %d\n", __func__, handle);
479 if (handle < 0 || handle >= AVSYS_AUDIO_HANDLE_MAX) {
481 return AVSYS_STATE_ERR_INVALID_HANDLE;
484 if (mode < 0 || mode >= HANDLE_PTR_MODE_NUM) {
486 return AVSYS_STATE_ERR_INVALID_PARAMETER;
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__);
493 return AVSYS_STATE_ERR_INTERNAL;
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__);
502 return AVSYS_STATE_ERR_INTERNAL;
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;
512 ret = AVSYS_STATE_ERR_INVALID_VALUE;
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__);
519 return AVSYS_STATE_ERR_INTERNAL;
526 int avsys_audio_handle_release_ptr(int handle, const int mode)
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;
533 //avsys_info(AVAUDIO, "%s handle %d\n", __func__, handle);
535 if (handle < 0 || handle >= AVSYS_AUDIO_HANDLE_MAX) {
536 return AVSYS_STATE_ERR_INVALID_HANDLE;
539 if (mode < 0 || mode >= HANDLE_PTR_MODE_NUM) {
540 return AVSYS_STATE_ERR_INVALID_PARAMETER;
544 AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
548 //avsys_info(AVAUDIO, "input handle %d flag %x allocated %x\n", handle, flag, control->allocated);
549 if (mode == HANDLE_PTR_MODE_NORMAL) {
553 if (control->allocated & flag) {
554 ret = AVSYS_STATE_SUCCESS;
556 ret = AVSYS_STATE_ERR_INVALID_VALUE;
559 if (mode == HANDLE_PTR_MODE_NORMAL) {
566 int avsys_audio_handle_set_mute(int handle, int mute)
568 long long int flag = 0x01;
569 int result = AVSYS_STATE_SUCCESS;
571 avsys_audio_handle_info_t *control = NULL;
572 avsys_audio_handle_info_t **temp = NULL;
573 avsys_audio_handle_t *ptr = NULL;
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;
582 AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
588 if (control->allocated & flag) { /* find condition */
589 /* update mute information for input handle parameter */
590 ptr = &(control->handles[handle]);
592 avsys_audio_pa_ctrl_mute_by_index(ptr->stream_index, mute);
594 /* update handle amp information */
595 if (mute == AVSYS_AUDIO_UNMUTE) {
597 if (control->handle_amp & flag)
598 avsys_warning(AVAUDIO, "handle 0x%x already powered\n");
600 control->handle_amp |= flag;
602 if (!(control->handle_amp & flag))
603 control->handle_amp |= flag;
605 /* reset fadedown mute */
608 } else if (mute == AVSYS_AUDIO_MUTE) {
609 /* clear handle amp field */
610 if (control->handle_amp & flag)
611 control->handle_amp &= ~flag;
614 avsys_warning(AVAUDIO, "handle 0x%x already off\n");
618 result = AVSYS_STATE_SUCCESS;
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;
625 return AVSYS_STATE_ERR_INVALID_VALUE;
628 if (control->handle_amp | control->ext_device_amp)
629 path_mute = AVSYS_AUDIO_UNMUTE;
631 path_mute = AVSYS_AUDIO_MUTE;
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;
642 int avsys_audio_handle_ext_dev_set_mute(avsysaudio_ext_device_t device_type, int mute)
645 int result = AVSYS_STATE_SUCCESS;
647 avsys_audio_handle_info_t *control = NULL;
648 avsys_audio_handle_info_t **temp = NULL;
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;
657 switch (device_type) {
658 case AVSYS_AUDIO_EXT_DEVICE_FMRADIO:
659 bit = AVSYS_AUDIO_HANDLE_EXT_DEV_FMRADIO;
662 avsys_error(AVAUDIO, "Unknown device type %d\n", (int)device_type);
663 return AVSYS_STATE_ERR_INVALID_PARAMETER;
666 AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
670 if (mute == AVSYS_AUDIO_MUTE) {
671 control->ext_device_amp |= bit;
673 control->ext_device_amp &= ~bit;
676 if (control->handle_amp | control->ext_device_amp)
677 path_mute = AVSYS_AUDIO_UNMUTE;
679 path_mute = AVSYS_AUDIO_MUTE;
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;
690 int avsys_audio_handle_ext_dev_status(avsysaudio_ext_device_t device_type, int *onoff)
692 int result = AVSYS_STATE_SUCCESS;
693 int ext_dev_state = 0;
695 avsys_audio_handle_info_t *control = NULL;
696 avsys_audio_handle_info_t **temp = NULL;
699 avsys_info(AVAUDIO, "%s\n", __func__);
702 avsys_error(AVAUDIO, "Null pointer input parameter\n");
703 return AVSYS_STATE_ERR_NULL_POINTER;
706 AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
710 switch (device_type) {
711 case AVSYS_AUDIO_EXT_DEVICE_FMRADIO:
712 if (control->ext_device_status & AVSYS_AUDIO_HANDLE_EXT_DEV_FMRADIO) {
717 *onoff = ext_dev_state;
720 avsys_error(AVAUDIO, "Invalid device type %d\n", device_type);
721 result = AVSYS_STATE_ERR_INTERNAL;
729 int avsys_audio_handle_ext_dev_status_update(avsysaudio_ext_device_t device_type, int onoff)
732 int result = AVSYS_STATE_SUCCESS;
733 avsys_audio_handle_info_t *control = NULL;
734 avsys_audio_handle_info_t **temp = NULL;
737 avsys_info(AVAUDIO, "%s_%d_%d\n", __func__, (int)device_type, onoff);
739 switch (device_type) {
740 case AVSYS_AUDIO_EXT_DEVICE_FMRADIO:
741 bit = AVSYS_AUDIO_HANDLE_EXT_DEV_FMRADIO;
744 avsys_error(AVAUDIO, "Unknown device type %d\n", (int)device_type);
745 return AVSYS_STATE_ERR_INVALID_PARAMETER;
748 AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
753 control->ext_device_status |= bit;
754 } else if (onoff == 0) {
755 control->ext_device_status &= ~bit;
757 avsys_error(AVAUDIO, "[%s] Unknown parameter %d. To nothing\n", __func__, onoff);
764 int avsys_audio_handle_current_playing_volume_type(int *type)
766 int result = AVSYS_STATE_SUCCESS;
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;
774 AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
778 for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
779 long long int flag = 0x01;
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;
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) {
796 if (control->ext_device_status & AVSYS_AUDIO_HANDLE_EXT_DEV_FMRADIO) {
797 used_table[AVSYS_AUDIO_VOLUME_TYPE_MEDIA] = 1;
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],
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;
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");
843 result = AVSYS_STATE_ERR_ALLOCATION;
844 avsys_error(AVAUDIO, "There is no running handles...\n");
853 int avsys_audio_handle_update_volume(avsys_audio_handle_t *p, const int volume_config)
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);
862 AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
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));
876 int avsys_audio_handle_update_volume_by_type(const int volume_type, const int volume_value)
879 int result = AVSYS_STATE_SUCCESS;
880 avsys_audio_handle_info_t *control = NULL;
881 avsys_audio_handle_info_t **temp = NULL;
884 avsys_info(AVAUDIO, "%s\n", __func__);
885 AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
889 control->volume_value[volume_type] = volume_value;
891 for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
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);
898 if ((control->allocated & flag) == 0) {
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) {
908 if (vol_conf_type != volume_type) {
912 if (control->handles[i].dirty_volume) {
913 /* This is volatile volume per handle */
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);
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");
936 int avsys_audio_handle_set_primary_volume_type(const int pid, const int type, const int command)
938 int result = AVSYS_STATE_SUCCESS;
939 avsys_audio_handle_info_t *control = NULL;
940 avsys_audio_handle_info_t **temp = NULL;
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;
949 AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
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
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);
967 avsys_warning(AVAUDIO, "Primary Volume Type Clear [%d]\n", pid);
968 control->primary_volume_pid = 0;
969 control->primary_volume_type = -1;
972 avsys_error(AVAUDIO, "Unknown Parameter : %d\n", command);
973 result = AVSYS_STATE_ERR_INVALID_PARAMETER;
981 int avsys_audio_handle_update_priority(int handle, int priority, int handle_route, int cmd)
983 long long int flag = 0x01;
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;
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;
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;
1002 lpriority = priority;
1005 AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
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;
1022 avsys_warning(AVAUDIO, "[%s] handle %d does not allocated\n", __func__, handle);
1023 AVSYS_UNLOCK_SYNC();
1024 return AVSYS_STATE_ERR_INVALID_VALUE;
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;
1036 for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
1039 if (!(control->allocated & flag))
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);
1047 if (control->handle_priority[i] == AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0) {
1049 if (high_priority_exist) { /* mute */
1050 if (transition_effect) {
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];
1055 control->handles[i].fadeup_vol = (-1) * control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT];
1057 control->handles[i].fadeup_multiplier = 0;
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);
1063 avsys_warning(AVAUDIO, "set sink input mute for %d success\n", control->handles[i].stream_index);
1065 control->handles[i].mute = AVSYS_AUDIO_MUTE;
1067 } else { /* unmute */
1068 if (transition_effect) {
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];
1073 control->handles[i].fadeup_vol = control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT];
1075 control->handles[i].fadeup_multiplier = 0;
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);
1082 avsys_warning(AVAUDIO, "set sink input unmute for %d success\n", control->handles[i].stream_index);
1084 control->handles[i].mute = AVSYS_AUDIO_UNMUTE;
1091 AVSYS_UNLOCK_SYNC();
1093 if (transition_effect)
1095 else if (!transition_effect && high_priority_exist)
1098 return AVSYS_STATE_SUCCESS;
1101 int avsys_audio_handle_current_capture_status(int *on_capture)
1104 char capture_used = 0;
1105 avsys_audio_handle_info_t *control = NULL;
1106 avsys_audio_handle_info_t **temp = NULL;
1109 return AVSYS_STATE_ERR_INVALID_PARAMETER;
1113 AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
1117 for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
1118 long long int flag = 0x01;
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) {
1131 avsys_info(AVAUDIO, "Audio capture is running\n");
1137 AVSYS_UNLOCK_SYNC();
1139 return AVSYS_STATE_SUCCESS;