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_alloc_unlocked(int *handle)
444 long long int flag = 0x01;
446 avsys_audio_handle_info_t *control = NULL;
447 avsys_audio_handle_info_t **temp = NULL;
450 avsys_info(AVAUDIO, "%s\n", __func__);
451 AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
453 for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
454 if ((control->allocated & flag) == 0) { /* alloc condition */
455 control->allocated |= flag;
462 if (i == AVSYS_AUDIO_HANDLE_MAX) {
464 return AVSYS_STATE_ERR_RANGE_OVER;
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();
471 return AVSYS_STATE_SUCCESS;
475 int avsys_audio_handle_free(int handle)
477 long long int flag = 0x01;
478 avsys_audio_handle_info_t *control = NULL;
479 avsys_audio_handle_info_t **temp = NULL;
482 avsys_info(AVAUDIO, "%s, handle=[%d]\n", __func__, handle);
484 AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
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;
496 return AVSYS_STATE_SUCCESS;
499 return AVSYS_STATE_ERR_INVALID_VALUE;
503 int avsys_audio_handle_get_ptr(int handle, avsys_audio_handle_t **ptr, const int mode)
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;
510 //avsys_info(AVAUDIO, "%s handle %d\n", __func__, handle);
512 if (handle < 0 || handle >= AVSYS_AUDIO_HANDLE_MAX) {
514 return AVSYS_STATE_ERR_INVALID_HANDLE;
517 if (mode < 0 || mode >= HANDLE_PTR_MODE_NUM) {
519 return AVSYS_STATE_ERR_INVALID_PARAMETER;
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__);
526 return AVSYS_STATE_ERR_INTERNAL;
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__);
535 return AVSYS_STATE_ERR_INTERNAL;
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;
545 ret = AVSYS_STATE_ERR_INVALID_VALUE;
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__);
552 return AVSYS_STATE_ERR_INTERNAL;
559 int avsys_audio_handle_get_ptr_unlocked(int handle, avsys_audio_handle_t **ptr, const int mode)
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;
566 if (handle < 0 || handle >= AVSYS_AUDIO_HANDLE_MAX) {
568 return AVSYS_STATE_ERR_INVALID_HANDLE;
571 if (mode < 0 || mode >= HANDLE_PTR_MODE_NUM) {
573 return AVSYS_STATE_ERR_INVALID_PARAMETER;
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__);
580 return AVSYS_STATE_ERR_INTERNAL;
585 if (control->allocated & flag) {
586 *ptr = &(control->handles[handle]);
587 ret = AVSYS_STATE_SUCCESS;
590 ret = AVSYS_STATE_ERR_INVALID_VALUE;
596 int avsys_audio_handle_release_ptr(int handle, const int mode)
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;
603 //avsys_info(AVAUDIO, "%s handle %d\n", __func__, handle);
605 if (handle < 0 || handle >= AVSYS_AUDIO_HANDLE_MAX) {
606 return AVSYS_STATE_ERR_INVALID_HANDLE;
609 if (mode < 0 || mode >= HANDLE_PTR_MODE_NUM) {
610 return AVSYS_STATE_ERR_INVALID_PARAMETER;
614 AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
618 //avsys_info(AVAUDIO, "input handle %d flag %x allocated %x\n", handle, flag, control->allocated);
619 if (mode == HANDLE_PTR_MODE_NORMAL) {
623 if (control->allocated & flag) {
624 ret = AVSYS_STATE_SUCCESS;
626 ret = AVSYS_STATE_ERR_INVALID_VALUE;
629 if (mode == HANDLE_PTR_MODE_NORMAL) {
636 int avsys_audio_handle_set_mute(int handle, int mute)
638 long long int flag = 0x01;
639 int result = AVSYS_STATE_SUCCESS;
641 avsys_audio_handle_info_t *control = NULL;
642 avsys_audio_handle_info_t **temp = NULL;
643 avsys_audio_handle_t *ptr = NULL;
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;
652 AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
658 if (control->allocated & flag) { /* find condition */
659 /* update mute information for input handle parameter */
660 ptr = &(control->handles[handle]);
662 avsys_audio_pa_ctrl_mute_by_index(ptr->stream_index, mute);
664 /* update handle amp information */
665 if (mute == AVSYS_AUDIO_UNMUTE) {
667 if (control->handle_amp & flag)
668 avsys_warning(AVAUDIO, "handle 0x%x already powered\n");
670 control->handle_amp |= flag;
672 if (!(control->handle_amp & flag))
673 control->handle_amp |= flag;
675 /* reset fadedown mute */
678 } else if (mute == AVSYS_AUDIO_MUTE) {
679 /* clear handle amp field */
680 if (control->handle_amp & flag)
681 control->handle_amp &= ~flag;
684 avsys_warning(AVAUDIO, "handle 0x%x already off\n");
688 result = AVSYS_STATE_SUCCESS;
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;
695 return AVSYS_STATE_ERR_INVALID_VALUE;
698 if (control->handle_amp | control->ext_device_amp)
699 path_mute = AVSYS_AUDIO_UNMUTE;
701 path_mute = AVSYS_AUDIO_MUTE;
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;
712 int avsys_audio_handle_ext_dev_set_mute(avsysaudio_ext_device_t device_type, int mute)
715 int result = AVSYS_STATE_SUCCESS;
717 avsys_audio_handle_info_t *control = NULL;
718 avsys_audio_handle_info_t **temp = NULL;
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;
727 switch (device_type) {
728 case AVSYS_AUDIO_EXT_DEVICE_FMRADIO:
729 bit = AVSYS_AUDIO_HANDLE_EXT_DEV_FMRADIO;
732 avsys_error(AVAUDIO, "Unknown device type %d\n", (int)device_type);
733 return AVSYS_STATE_ERR_INVALID_PARAMETER;
736 AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
740 if (mute == AVSYS_AUDIO_MUTE) {
741 control->ext_device_amp |= bit;
743 control->ext_device_amp &= ~bit;
746 if (control->handle_amp | control->ext_device_amp)
747 path_mute = AVSYS_AUDIO_UNMUTE;
749 path_mute = AVSYS_AUDIO_MUTE;
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;
760 int avsys_audio_handle_ext_dev_status(avsysaudio_ext_device_t device_type, int *onoff)
762 int result = AVSYS_STATE_SUCCESS;
763 int ext_dev_state = 0;
765 avsys_audio_handle_info_t *control = NULL;
766 avsys_audio_handle_info_t **temp = NULL;
769 avsys_info(AVAUDIO, "%s\n", __func__);
772 avsys_error(AVAUDIO, "Null pointer input parameter\n");
773 return AVSYS_STATE_ERR_NULL_POINTER;
776 AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
780 switch (device_type) {
781 case AVSYS_AUDIO_EXT_DEVICE_FMRADIO:
782 if (control->ext_device_status & AVSYS_AUDIO_HANDLE_EXT_DEV_FMRADIO) {
787 *onoff = ext_dev_state;
790 avsys_error(AVAUDIO, "Invalid device type %d\n", device_type);
791 result = AVSYS_STATE_ERR_INTERNAL;
799 int avsys_audio_handle_ext_dev_status_update(avsysaudio_ext_device_t device_type, int onoff)
802 int result = AVSYS_STATE_SUCCESS;
803 avsys_audio_handle_info_t *control = NULL;
804 avsys_audio_handle_info_t **temp = NULL;
807 avsys_info(AVAUDIO, "%s_%d_%d\n", __func__, (int)device_type, onoff);
809 switch (device_type) {
810 case AVSYS_AUDIO_EXT_DEVICE_FMRADIO:
811 bit = AVSYS_AUDIO_HANDLE_EXT_DEV_FMRADIO;
814 avsys_error(AVAUDIO, "Unknown device type %d\n", (int)device_type);
815 return AVSYS_STATE_ERR_INVALID_PARAMETER;
818 AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
823 control->ext_device_status |= bit;
824 } else if (onoff == 0) {
825 control->ext_device_status &= ~bit;
827 avsys_error(AVAUDIO, "[%s] Unknown parameter %d. To nothing\n", __func__, onoff);
834 int avsys_audio_handle_current_playing_volume_type(int *type)
836 int result = AVSYS_STATE_SUCCESS;
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;
844 AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
848 for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
849 long long int flag = 0x01;
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;
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) {
866 if (control->ext_device_status & AVSYS_AUDIO_HANDLE_EXT_DEV_FMRADIO) {
867 used_table[AVSYS_AUDIO_VOLUME_TYPE_MEDIA] = 1;
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],
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;
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");
913 result = AVSYS_STATE_ERR_ALLOCATION;
914 avsys_error(AVAUDIO, "There is no running handles...\n");
923 int avsys_audio_handle_update_volume(avsys_audio_handle_t *p, const int volume_config)
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);
932 AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
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));
946 int avsys_audio_handle_update_volume_by_type(const int volume_type, const int volume_value)
949 int result = AVSYS_STATE_SUCCESS;
950 avsys_audio_handle_info_t *control = NULL;
951 avsys_audio_handle_info_t **temp = NULL;
954 avsys_info(AVAUDIO, "%s\n", __func__);
955 AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
959 control->volume_value[volume_type] = volume_value;
961 for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
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);
968 if ((control->allocated & flag) == 0) {
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) {
978 if (vol_conf_type != volume_type) {
982 if (control->handles[i].dirty_volume) {
983 /* This is volatile volume per handle */
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);
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");
1001 AVSYS_UNLOCK_SYNC();
1006 int avsys_audio_handle_set_primary_volume_type(const int pid, const int type, const int command)
1008 int result = AVSYS_STATE_SUCCESS;
1009 avsys_audio_handle_info_t *control = NULL;
1010 avsys_audio_handle_info_t **temp = NULL;
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;
1019 AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
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
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);
1037 avsys_warning(AVAUDIO, "Primary Volume Type Clear [%d]\n", pid);
1038 control->primary_volume_pid = 0;
1039 control->primary_volume_type = -1;
1042 avsys_error(AVAUDIO, "Unknown Parameter : %d\n", command);
1043 result = AVSYS_STATE_ERR_INVALID_PARAMETER;
1046 AVSYS_UNLOCK_SYNC();
1051 int avsys_audio_handle_update_priority(int handle, int priority, int handle_route, int cmd)
1053 long long int flag = 0x01;
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;
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;
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;
1072 lpriority = priority;
1075 AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
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;
1092 avsys_warning(AVAUDIO, "[%s] handle %d does not allocated\n", __func__, handle);
1093 AVSYS_UNLOCK_SYNC();
1094 return AVSYS_STATE_ERR_INVALID_VALUE;
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;
1106 for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
1109 if (!(control->allocated & flag))
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);
1117 if (control->handle_priority[i] == AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0) {
1119 if (high_priority_exist) { /* mute */
1120 if (transition_effect) {
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];
1125 control->handles[i].fadeup_vol = (-1) * control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT];
1127 control->handles[i].fadeup_multiplier = 0;
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);
1133 avsys_warning(AVAUDIO, "set sink input mute for %d success\n", control->handles[i].stream_index);
1135 control->handles[i].mute = AVSYS_AUDIO_MUTE;
1137 } else { /* unmute */
1138 if (transition_effect) {
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];
1143 control->handles[i].fadeup_vol = control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT];
1145 control->handles[i].fadeup_multiplier = 0;
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);
1152 avsys_warning(AVAUDIO, "set sink input unmute for %d success\n", control->handles[i].stream_index);
1154 control->handles[i].mute = AVSYS_AUDIO_UNMUTE;
1161 AVSYS_UNLOCK_SYNC();
1163 if (transition_effect)
1165 else if (!transition_effect && high_priority_exist)
1168 return AVSYS_STATE_SUCCESS;
1171 int avsys_audio_handle_current_capture_status(int *on_capture)
1174 char capture_used = 0;
1175 avsys_audio_handle_info_t *control = NULL;
1176 avsys_audio_handle_info_t **temp = NULL;
1179 return AVSYS_STATE_ERR_INVALID_PARAMETER;
1183 AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
1187 for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
1188 long long int flag = 0x01;
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) {
1201 avsys_info(AVAUDIO, "Audio capture is running\n");
1207 AVSYS_UNLOCK_SYNC();
1209 return AVSYS_STATE_SUCCESS;