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.
26 #include <sys/types.h>
29 #include <sys/syscall.h>
34 #include "avsys-types.h"
35 #include "avsys-error.h"
36 #include "avsys-debug.h"
37 #include "avsys-audio.h"
38 #include "avsys-audio-logical-volume.h"
39 #include "avsys-common.h"
40 #include "avsys-audio-sync.h"
42 #include "avsys-audio-path.h"
43 #include "avsys-audio-alsa.h"
45 #include "avsys-audio-pasimple.h"
46 #include "avsys-audio-pactrl.h"
49 * Internal functions definition
51 #define FADEUP_CALC_BIAS (1)
53 static int __avsys_audio_set_info(avsys_audio_handle_t *p, avsys_audio_param_t *param);
54 static int __avsys_audio_handle_init(int *handle,
55 avsys_audio_handle_t **ptr,
56 avsys_audio_param_t *param);
59 void __init_module(void);
60 void __fini_module(void);
62 #define AVSYS_GET_HANDLE_PTR(MODE) do { \
63 err = avsys_audio_handle_get_ptr((int)handle, &p, MODE); \
64 if (AVSYS_FAIL(err)) { \
69 #define AVSYS_RELEASE_HANDLE_PTR(MODE) do { \
70 if (AVSYS_FAIL(avsys_audio_handle_release_ptr((int)handle, MODE))) { \
71 avsys_error(AVAUDIO, "audio handle release failed\n"); \
72 return AVSYS_STATE_ERR_INTERNAL; \
76 #define AVSYS_STREAM_LOCK() do { \
77 pthread_mutex_lock(&gmutex);\
78 avsys_info(AVAUDIO, "(+) LOCKED\n"); \
81 #define AVSYS_STREAM_UNLOCK() do { \
82 pthread_mutex_unlock(&gmutex);\
83 avsys_info(AVAUDIO, "(-) UNLOCKED\n"); \
87 * Internal global variable
89 static pthread_mutex_t gmutex = PTHREAD_MUTEX_INITIALIZER;
92 /****************************************************************************
96 ***************************************************************************/
98 int avsys_audio_open(avsys_audio_param_t *param, avsys_handle_t *phandle, int *size)
101 avsys_audio_handle_t *p = NULL;
102 int err = AVSYS_STATE_ERR_UNKNOWN;
104 avsys_info(AVAUDIO, "%s\n", __func__);
106 if (param == NULL || phandle == NULL) {
107 avsys_error(AVAUDIO, "param or phandle is null\n");
108 return AVSYS_STATE_ERR_NULL_POINTER;
111 if (param->channels > AVSYS_CHANNEL_MAX || param->channels < AVSYS_CHANNEL_MIN) {
112 return AVSYS_STATE_ERR_INVALID_CHANNEL;
115 if (param->mode < AVSYS_AUDIO_MODE_OUTPUT || param->mode >= AVSYS_AUDIO_MODE_NUM) {
116 return AVSYS_STATE_ERR_INVALID_MODE;
119 if (param->format < AVSYS_AUDIO_FORMAT_MIN || param->format > AVSYS_AUDIO_FORMAT_MAX) {
120 return AVSYS_STATE_ERR_INVALID_FORMAT;
125 err = avsys_audio_handle_rejuvenation();
126 if (AVSYS_FAIL(err)) {
127 avsys_error(AVAUDIO, "Unused handle cleanup before handle allocation failed in %s\n", __func__);
131 err = __avsys_audio_handle_init(&handle,&p,param);
133 if (AVSYS_STATE_ERR_RANGE_OVER == err) {
134 avsys_error(AVAUDIO, "audio handle is fully allocated..try cleanup\n");
135 err = avsys_audio_handle_rejuvenation();
136 if (AVSYS_FAIL(err)) {
137 avsys_error(AVAUDIO, "Unused handle cleanup failed in %s\n", __func__);
140 avsys_error(AVAUDIO, "one more try...to allocate audio handle\n");
141 err = __avsys_audio_handle_init(&handle,&p,param);
142 if (AVSYS_FAIL(err)) {
143 avsys_error(AVAUDIO, "handle alloc failed 1 in %s\n", __func__);
146 } else if ((AVSYS_FAIL(err)) && (err != AVSYS_STATE_ERR_RANGE_OVER)) {
147 avsys_error(AVAUDIO, "handle alloc failed 2 in %s\n", __func__);
151 if (p->mode == AVSYS_AUDIO_MODE_OUTPUT || p->mode == AVSYS_AUDIO_MODE_OUTPUT_CLOCK ||
152 p->mode == AVSYS_AUDIO_MODE_OUTPUT_LOW_LATENCY || p->mode == AVSYS_AUDIO_MODE_OUTPUT_AP_CALL || p->mode == AVSYS_AUDIO_MODE_OUTPUT_VIDEO) {
153 /* set volume table */
154 err = avsys_audio_path_set_volume(handle);
155 if (AVSYS_FAIL(err)) {
159 /* update volume by type */
160 err = avsys_audio_handle_update_volume(p, p->gain_setting.volume_config);
161 if (AVSYS_FAIL(err)) {
164 err = avsys_audio_handle_update_priority(handle, param->priority, param->handle_route, AVSYS_AUDIO_SET_PRIORITY);
165 if (AVSYS_FAIL(err)) {
171 err = avsys_audio_pasimple_open_device(p->mode, p->format, p->channels, p->samplerate, p, param->handle_route);
172 if (AVSYS_FAIL(err)) {
176 case AVSYS_AUDIO_MODE_OUTPUT:
177 case AVSYS_AUDIO_MODE_OUTPUT_CLOCK:
178 case AVSYS_AUDIO_MODE_OUTPUT_LOW_LATENCY:
179 case AVSYS_AUDIO_MODE_OUTPUT_VIDEO:
180 case AVSYS_AUDIO_MODE_OUTPUT_AP_CALL:
181 if (AVSYS_FAIL(avsys_audio_pasimple_set_volume(p, p->working_vol.level[AVSYS_AUDIO_CHANNEL_LEFT]))) {
182 avsys_error(AVAUDIO, "can not set volume in %s\n", __func__);
189 *phandle = (avsys_handle_t) handle;
190 /* set recommended buffer size */
194 avsys_warning(AVAUDIO, "Size is null\n");
196 err = avsys_audio_handle_release_ptr(handle, HANDLE_PTR_MODE_NORMAL);
197 if (AVSYS_FAIL(err)) {
200 AVSYS_STREAM_UNLOCK();
201 return AVSYS_STATE_SUCCESS;
205 avsys_audio_handle_release_ptr(handle, HANDLE_PTR_MODE_NORMAL);
209 if (AVSYS_FAIL(avsys_audio_handle_free(handle))) {
210 avsys_error(AVAUDIO, "Can not free handle %d\n", handle);
214 avsys_error(AVAUDIO, "failed to open : REASON %x\n", err);
216 *phandle = (avsys_handle_t)-1;
217 AVSYS_STREAM_UNLOCK();
222 int avsys_audio_close(avsys_handle_t handle)
224 avsys_audio_handle_t *p = NULL;
225 int err = AVSYS_STATE_ERR_UNKNOWN;
226 bool cp_audio = false;
227 bool bt_path = false;
230 avsys_info(AVAUDIO, "%s, handle=[%d]\n", __func__, (int)handle);
232 err = avsys_audio_handle_get_ptr((int)handle, &p, HANDLE_PTR_MODE_NORMAL);
233 if (AVSYS_FAIL(err)) {
234 AVSYS_STREAM_UNLOCK();
238 if (AVSYS_FAIL(avsys_audio_handle_update_priority((int)handle, p->priority, AVSYS_AUDIO_HANDLE_ROUTE_FOLLOWING_POLICY, AVSYS_AUDIO_UNSET_PRIORITY))) {
239 avsys_error(AVAUDIO, "unset priority of handle %d error: %x\n", handle, err);
242 err = avsys_audio_pasimple_close_device(p);
243 if (AVSYS_FAIL(err)) {
244 avsys_error_r(AVAUDIO, "audio device close error : %x\n", err);
247 if (AVSYS_FAIL(avsys_audio_path_check_cp_audio(&cp_audio, &bt_path))) {
248 avsys_error(AVAUDIO, "Can not check cp audio status\n");
251 if (p->during_cp_audio && cp_audio && bt_path) {
252 /* set cp bt path again */
253 avsys_audio_path_set_single_ascn("cp_to_bt");
256 if (AVSYS_FAIL(avsys_audio_handle_release_ptr((int)handle, HANDLE_PTR_MODE_NORMAL))) {
257 avsys_error(AVAUDIO, "audio handle release failed\n");
258 AVSYS_STREAM_UNLOCK();
259 return AVSYS_STATE_ERR_INTERNAL;
262 avsys_audio_handle_free((int)handle);
264 AVSYS_STREAM_UNLOCK();
270 int avsys_audio_update_volume_config(avsys_handle_t handle, int volume_config)
272 avsys_audio_handle_t *p = NULL;
273 int err = AVSYS_STATE_ERR_UNKNOWN;
276 avsys_info(AVAUDIO, "%s, handle=[%d]\n", __func__, (int)handle);
278 err = avsys_audio_handle_get_ptr((int)handle, &p, HANDLE_PTR_MODE_NORMAL);
279 if (AVSYS_FAIL(err)) {
280 AVSYS_STREAM_UNLOCK();
284 if (p->mode == AVSYS_AUDIO_MODE_OUTPUT || p->mode == AVSYS_AUDIO_MODE_OUTPUT_CLOCK
285 || p->mode == AVSYS_AUDIO_MODE_OUTPUT_LOW_LATENCY || p->mode == AVSYS_AUDIO_MODE_OUTPUT_AP_CALL
286 || p->mode == AVSYS_AUDIO_MODE_OUTPUT_VIDEO) {
287 p->gain_setting.volume_config = volume_config;
288 /* update volume by type */
289 err = avsys_audio_handle_update_volume(p, p->gain_setting.volume_config);
290 if (AVSYS_FAIL(err)) {
291 AVSYS_STREAM_UNLOCK();
294 err = avsys_audio_pasimple_set_volume(p, p->working_vol.level[AVSYS_AUDIO_CHANNEL_LEFT]);
295 if (AVSYS_FAIL(err)) {
296 avsys_error(AVAUDIO, "can not set volume in %s\n", __func__);
300 AVSYS_STREAM_UNLOCK();
305 int avsys_audio_ampon(void)
307 avsys_info(AVAUDIO, "%s\n", __func__);
308 return avsys_audio_path_ex_set_amp(AVSYS_AUDIO_AMP_ON);
312 int avsys_audio_ampoff(void)
314 avsys_info(AVAUDIO, "%s\n", __func__);
315 return avsys_audio_path_ex_set_amp(AVSYS_AUDIO_AMP_OFF);
320 int avsys_audio_ext_device_ampon(avsysaudio_ext_device_t device_type)
322 avsys_info(AVAUDIO, "%s\n", __func__);
323 return avsys_audio_handle_ext_dev_set_mute(device_type, AVSYS_AUDIO_UNMUTE);
327 int avsys_audio_ext_device_ampoff(avsysaudio_ext_device_t device_type)
329 avsys_info(AVAUDIO, "%s\n", __func__);
330 return avsys_audio_handle_ext_dev_set_mute(device_type, AVSYS_AUDIO_MUTE);
334 int avsys_audio_set_ext_device_status(avsysaudio_ext_device_t device_type, int onoff)
336 avsys_info(AVAUDIO, "%s\n", __func__);
337 return avsys_audio_handle_ext_dev_status_update(device_type, onoff);
341 int avsys_audio_get_ext_device_status(avsysaudio_ext_device_t device_type, int *onoff)
343 avsys_info(AVAUDIO, "%s\n", __func__);
344 return avsys_audio_handle_ext_dev_status(device_type, onoff);
348 int avsys_audio_flush(avsys_handle_t handle)
350 int err = AVSYS_STATE_SUCCESS;
351 avsys_audio_handle_t *p = NULL;
352 avsys_info(AVAUDIO, "%s\n", __func__);
354 AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
356 err = avsys_audio_pasimple_reset(p);
358 AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
364 int avsys_audio_drain(avsys_handle_t handle)
366 int err = AVSYS_STATE_SUCCESS;
367 avsys_audio_handle_t *p = NULL;
368 avsys_info(AVAUDIO, "%s\n", __func__);
370 AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
372 err = avsys_audio_pasimple_drain(p);
374 AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
380 int avsys_audio_read(avsys_handle_t handle, void *buf, int size)
382 int err = AVSYS_STATE_SUCCESS;
383 avsys_audio_handle_t *p = NULL;
385 avsys_info(AVAUDIO, "%s\n", __func__);
388 avsys_error(AVAUDIO, "input buffer pointer is null\n");
389 return AVSYS_STATE_ERR_NULL_POINTER;
392 AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_FAST);
394 if (p->mode != AVSYS_AUDIO_MODE_INPUT && p->mode != AVSYS_AUDIO_MODE_INPUT_LOW_LATENCY &&
395 p->mode != AVSYS_AUDIO_MODE_INPUT_HIGH_LATENCY && p->mode != AVSYS_AUDIO_MODE_INPUT_AP_CALL) {
396 avsys_error(AVAUDIO, "opened output mode\n");
397 return AVSYS_STATE_ERR_INVALID_MODE;
400 err = avsys_audio_pasimple_read(p, buf, size);
402 AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_FAST);
408 int avsys_audio_write(avsys_handle_t handle, void *buf, int size)
410 int err = AVSYS_STATE_SUCCESS;
411 avsys_audio_handle_t *p = NULL;
413 avsys_info(AVAUDIO, "%s\n", __func__);
416 avsys_error(AVAUDIO, "buf is null\n");
417 return AVSYS_STATE_ERR_NULL_POINTER;
420 AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_FAST);
422 if (p->mode != AVSYS_AUDIO_MODE_OUTPUT && p->mode != AVSYS_AUDIO_MODE_OUTPUT_CLOCK &&
423 p->mode != AVSYS_AUDIO_MODE_OUTPUT_LOW_LATENCY && p->mode != AVSYS_AUDIO_MODE_OUTPUT_AP_CALL && p->mode != AVSYS_AUDIO_MODE_OUTPUT_VIDEO) {
424 avsys_error(AVAUDIO, "opened input mode\n");
425 avsys_audio_handle_release_ptr((int)handle, HANDLE_PTR_MODE_FAST);
426 return AVSYS_STATE_ERR_INVALID_MODE;
429 if (p->fadeup_vol > 1) {
430 if (p->fadeup_multiplier == 0) {
431 avsys_audio_volume_t fade_volume;
432 fade_volume.level[AVSYS_AUDIO_CHANNEL_LEFT] = p->setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT] - (p->fadeup_vol - FADEUP_CALC_BIAS);
433 fade_volume.level[AVSYS_AUDIO_CHANNEL_RIGHT] = p->setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT] - (p->fadeup_vol - FADEUP_CALC_BIAS);
435 if (fade_volume.level[AVSYS_AUDIO_CHANNEL_LEFT] < 0) {
436 fade_volume.level[AVSYS_AUDIO_CHANNEL_LEFT] = 0;
438 if (fade_volume.level[AVSYS_AUDIO_CHANNEL_RIGHT] < 0) {
439 fade_volume.level[AVSYS_AUDIO_CHANNEL_RIGHT] = 0;
442 avsys_info(AVAUDIO, "fade_volume : %d (%d-(%d)+%d) p->fadeup_m = %d, p->msec_per_period = %d\n",
443 fade_volume.level[AVSYS_AUDIO_CHANNEL_LEFT],p->setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT],p->fadeup_vol,FADEUP_CALC_BIAS,
444 p->fadeup_multiplier, p->msec_per_period
447 avsys_audio_logical_volume_convert(&fade_volume, &p->working_vol, &p->gain_setting);
448 avsys_audio_pasimple_set_volume(p, p->working_vol.level[AVSYS_AUDIO_CHANNEL_LEFT]);
450 if (p->msec_per_period > 50)
451 p->fadeup_multiplier = 0;
453 p->fadeup_multiplier = FADE_UP_MULTIPLIER;
455 p->fadeup_multiplier--;
457 } else if (p->fadeup_vol <= -1) {
458 if (p->fadeup_multiplier == 0) {
459 int fadedown_vol = 0;
460 avsys_audio_volume_t fade_volume;
462 fadedown_vol = (-1) * (p->fadeup_vol) - FADEUP_CALC_BIAS;
463 fade_volume.level[AVSYS_AUDIO_CHANNEL_LEFT] = fadedown_vol;
464 fade_volume.level[AVSYS_AUDIO_CHANNEL_RIGHT] = fadedown_vol;
466 if (fade_volume.level[AVSYS_AUDIO_CHANNEL_LEFT] < 0) {
467 fade_volume.level[AVSYS_AUDIO_CHANNEL_LEFT] = 0;
469 if (fade_volume.level[AVSYS_AUDIO_CHANNEL_RIGHT] < 0) {
470 fade_volume.level[AVSYS_AUDIO_CHANNEL_RIGHT] = 0;
473 avsys_info(AVAUDIO, "fade_volume : %d (%d-%d) p->fadeup_m = %d, p->msec_per_period = %d\n",
474 fade_volume.level[AVSYS_AUDIO_CHANNEL_LEFT],p->fadeup_vol,FADEUP_CALC_BIAS,
475 p->fadeup_multiplier, p->msec_per_period);
477 avsys_audio_logical_volume_convert(&fade_volume, &p->working_vol, &p->gain_setting);
478 avsys_audio_pasimple_set_volume(p, p->working_vol.level[AVSYS_AUDIO_CHANNEL_LEFT]);
479 if (p->fadeup_vol < -1) {
481 } else if (p->fadeup_vol == -1) {
482 p->mute = AVSYS_AUDIO_MUTE;
484 if (p->msec_per_period > 50)
485 p->fadeup_multiplier = 0;
487 p->fadeup_multiplier = FADE_DOWN_MULTIPLIER;
489 p->fadeup_multiplier--;
492 err = avsys_audio_pasimple_write(p, buf, size);
494 AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_FAST);
500 int avsys_audio_set_volume_fadeup(avsys_handle_t handle)
502 int err = AVSYS_STATE_SUCCESS;
503 avsys_audio_handle_t *p = NULL;
505 avsys_warning(AVAUDIO, "%s\n", __func__);
507 AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
509 if (p->setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT] >= p->setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT]) {
510 p->fadeup_vol = p->setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT]; /* + FADEUP_CALC_BIAS */
512 p->fadeup_vol = p->setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT]; /* + FADEUP_CALC_BIAS; */
514 p->fadeup_multiplier = 0;
516 AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
522 int avsys_audio_set_mute_fadedown(avsys_handle_t handle)
524 int err = AVSYS_STATE_SUCCESS;
525 avsys_audio_handle_t *p = NULL;
527 avsys_warning(AVAUDIO, "%s\n", __func__);
529 AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
531 if (p->setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT] >= p->setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT]) {
532 p->fadeup_vol = (-1) * p->setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT];
534 p->fadeup_vol = (-1) * p->setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT];
536 p->fadeup_multiplier = 0;
538 AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
545 int avsys_audio_set_volume_table(int volume_type, int dev_type, int step, int lv, int rv)
547 int ret = avsys_audio_logical_volume_set_to_table(volume_type, dev_type, step, lv, rv);
548 avsys_audio_handle_t *ptr = NULL;
551 if (AVSYS_FAIL(ret)) {
555 while(++handle < AVSYS_AUDIO_HANDLE_MAX) {
558 if (AVSYS_SUCCESS(avsys_audio_handle_get_ptr(handle, &ptr, HANDLE_PTR_MODE_NORMAL))) {
559 avsys_audio_logical_volume_convert(&ptr->setting_vol, &ptr->working_vol, &ptr->gain_setting);
560 avsys_audio_handle_release_ptr(handle, HANDLE_PTR_MODE_NORMAL);
563 return AVSYS_STATE_SUCCESS;
567 int avsys_audio_get_volume_table(int volume_type, int dev_type, int step, int *lv, int *rv)
569 return avsys_audio_logical_volume_get_from_table(volume_type, dev_type, step, lv, rv);
573 int avsys_audio_get_volume_max_ex(int volume_type, int *max_step)
575 if (max_step == NULL) {
576 return AVSYS_STATE_ERR_NULL_POINTER;
579 return avsys_audio_logical_volume_get_max(volume_type, AVSYS_AUDIO_LVOL_DEV_TYPE_SPK, max_step);
583 int avsys_audio_set_volume_gain_table(int volume_gain_idx, int dev_type, float lv, float rv)
585 int ret = avsys_audio_logical_volume_set_gain_to_table(volume_gain_idx, dev_type, lv, rv);
586 avsys_audio_handle_t *ptr = NULL;
589 if (AVSYS_FAIL(ret)) {
593 while(++handle < AVSYS_AUDIO_HANDLE_MAX) {
596 if (AVSYS_SUCCESS(avsys_audio_handle_get_ptr(handle, &ptr, HANDLE_PTR_MODE_NORMAL))) {
597 avsys_audio_logical_volume_convert(&ptr->setting_vol, &ptr->working_vol, &ptr->gain_setting);
598 avsys_audio_handle_release_ptr(handle, HANDLE_PTR_MODE_NORMAL);
601 return AVSYS_STATE_SUCCESS;
605 int avsys_audio_get_volume_gain_table(int volume_gain_idx, int dev_type, float *lv, float *rv)
607 return avsys_audio_logical_volume_get_gain_from_table(volume_gain_idx, dev_type, lv, rv);
611 int avsys_audio_set_mute(avsys_handle_t handle, int mute)
613 avsys_info(AVAUDIO, "%s\n", __func__);
615 if (mute > AVSYS_AUDIO_MUTE || mute < AVSYS_AUDIO_UNMUTE) {
616 return AVSYS_STATE_ERR_INVALID_PARAMETER;
619 if (AVSYS_FAIL(avsys_audio_handle_set_mute((int)handle, mute))) {
620 avsys_error(AVAUDIO, "failed to set handle mute\n");
623 return AVSYS_STATE_SUCCESS;
627 int avsys_audio_get_mute(avsys_handle_t handle, int *pmute)
629 int err = AVSYS_STATE_SUCCESS;
630 avsys_audio_handle_t *p = NULL;
632 avsys_info(AVAUDIO, "%s\n", __func__);
635 avsys_error(AVAUDIO, "pvolume is null\n");
636 return AVSYS_STATE_ERR_NULL_POINTER;
639 AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
643 AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
645 return AVSYS_STATE_SUCCESS;
649 * Option : AVSYS_AUDIO_PATH_OPTION_LEGACY_MODE support NowPlus style sound path function
650 * Option : AVSYS_AUDIO_PATH_OPTION_DUAL_OUT will effect only when out is speaker.
651 * Option : AVSYS_AUDIO_PATH_OPTION_JACK_AUTO will effect only when out is speaker or receiver.
652 * Option : AVSYS_AUDIO_PATH_OPTION_FORCED is avail only for shutdown animation
654 * Limitation : Only FORCED option can be used same time with other options (exclude LEGACY_MODE)
657 int avsys_audio_set_path_ex(int gain, int out, int in, int option)
659 if (AVSYS_AUDIO_GAIN_EX_KEYTONE > gain || AVSYS_AUDIO_GAIN_EX_MAX <= gain ||
660 AVSYS_AUDIO_PATH_EX_NONE > out || AVSYS_AUDIO_PATH_EX_OUTMAX <= out ||
661 AVSYS_AUDIO_PATH_EX_NONE > in || AVSYS_AUDIO_PATH_EX_INMAX <= in) {
662 avsys_error(AVAUDIO, "Your input parameter is invalid. Please check\n");
663 avsys_error(AVAUDIO, " gain %d, out %d, in %d\n", gain, out, in);
664 return AVSYS_STATE_ERR_INVALID_PARAMETER;
667 return avsys_audio_path_ex_set_path(gain, out, in, option);
670 int avsys_audio_get_path_ex(int *gain, int *out, int *in, int *option)
672 if (!gain || !out || !in || !option) {
673 avsys_warning(AVAUDIO, "Your input parameter is NULL pointer. Please check.\n");
674 avsys_warning(AVAUDIO, " gain %p, out %p, in %p, option %p\n", gain, out, in, option);
675 return AVSYS_STATE_ERR_INVALID_PARAMETER;
677 return avsys_audio_path_ex_get_path(gain, out, in, option);
681 int avsys_audio_set_global_mute(int mute)
683 int err = AVSYS_STATE_SUCCESS;
685 avsys_info(AVAUDIO, "%s : mute=%d\n", __func__, mute);
687 if (mute < AVSYS_AUDIO_UNMUTE && mute > AVSYS_AUDIO_MUTE_NOLOCK) {
688 err = AVSYS_STATE_ERR_INVALID_PARAMETER;
690 err = avsys_audio_path_ex_set_mute(mute);
696 int avsys_audio_get_global_mute(int *pmute)
698 int err = AVSYS_STATE_SUCCESS;
700 avsys_info(AVAUDIO, "%s\n", __func__);
702 err = AVSYS_STATE_ERR_NULL_POINTER;
704 err = avsys_audio_path_ex_get_mute(pmute);
710 * Internal functions implementation
713 static int __avsys_audio_set_info(avsys_audio_handle_t *p, avsys_audio_param_t *param)
715 int vol_conf_type = AVSYS_AUDIO_VOLUME_CONFIG_TYPE(param->vol_type);
716 int vol_conf_gain = AVSYS_AUDIO_VOLUME_CONFIG_GAIN(param->vol_type);
718 avsys_info(AVAUDIO, "%s\n", __func__);
720 avsys_info(AVAUDIO, "=============================================\n");
721 avsys_info(AVAUDIO, " Input Parameters (Basic Information)\n");
722 avsys_info(AVAUDIO, "=============================================\n");
723 avsys_info(AVAUDIO, " Op Mode = %d (0:out, 1:input)\n", param->mode);
724 avsys_info(AVAUDIO, " format = %d (0: 8bits, 1:16bits, 2:32bits)\n", param->format);
725 avsys_info(AVAUDIO, " channel = %d\n", param->channels);
726 avsys_info(AVAUDIO, " samplerate = %d\n", param->samplerate);
727 avsys_info(AVAUDIO, " route = %d (0: default, 1: handset)\n", param->handle_route);
728 avsys_info(AVAUDIO, " volume type= %d\n", vol_conf_type);
729 avsys_info(AVAUDIO, " volume gain= %d\n", vol_conf_gain);
730 avsys_info(AVAUDIO, "=============================================\n");
732 p->mode = param->mode;
733 p->channels = param->channels;
734 p->samplerate = param->samplerate;
735 p->format = param->format;
736 p->priority = param->priority;
738 if ((vol_conf_type < 0) || (vol_conf_type >= AVSYS_AUDIO_VOLUME_TYPE_MAX)) {
739 avsys_error(AVAUDIO, "[%s] Invalid volume type %d. use default system type\n", __func__, vol_conf_type);
740 p->gain_setting.volume_config = AVSYS_AUDIO_VOLUME_TYPE_SYSTEM;
742 p->gain_setting.volume_config = param->vol_type;
745 /* trivial volume value */
746 p->setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT] = 0;
747 p->setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT] = 0;
748 p->working_vol.level[AVSYS_AUDIO_CHANNEL_LEFT] = 0;
749 p->working_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT] = 0;
752 return AVSYS_STATE_SUCCESS;
755 static int __avsys_audio_handle_init(int *handle,
756 avsys_audio_handle_t **ptr,
757 avsys_audio_param_t *param)
759 int err = AVSYS_STATE_ERR_UNKNOWN;
761 if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_HANDLE))) {
762 avsys_error(AVAUDIO,"avsys_audio_lock_sync() failed in %s\n", __func__);
763 return AVSYS_STATE_ERR_INTERNAL;
766 err = avsys_audio_handle_alloc_unlocked(handle);
768 if (AVSYS_STATE_SUCCESS == err) {
770 err = avsys_audio_handle_get_ptr_unlocked(*handle, ptr, HANDLE_PTR_MODE_NORMAL);
771 if(AVSYS_STATE_SUCCESS == err) {
773 /* set information to handle */
774 err = __avsys_audio_set_info(*ptr, param);
778 if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_HANDLE))) {
779 avsys_error(AVAUDIO,"avsys_audio_unlock_sync() failed in %s\n", __func__);
780 return AVSYS_STATE_ERR_INTERNAL;
787 int avsys_audio_earjack_manager_init(int *earjack_type, int *waitfd)
789 return avsys_audio_path_earjack_init(earjack_type, waitfd);
793 int avsys_audio_earjack_manager_wait(int waitfd, int *current_earjack_type, int *new_earjack_type, int *need_mute)
795 return avsys_audio_path_earjack_wait(waitfd, current_earjack_type, new_earjack_type, need_mute);
799 int avsys_audio_earjack_manager_process(int new_earjack_type)
801 return avsys_audio_path_earjack_process(new_earjack_type);
805 int avsys_audio_earjack_manager_deinit(int waitfd)
807 return avsys_audio_path_earjack_deinit(waitfd);
811 int avsys_audio_earjack_manager_get_type(void)
813 return avsys_audio_path_earjack_get_type();
817 int avsys_audio_earjack_manager_unlock(void)
819 return avsys_audio_path_earjack_unlock();
823 int avsys_audio_set_route_policy(avsys_audio_route_policy_t route)
830 int avsys_audio_get_route_policy(avsys_audio_route_policy_t *route)
837 int avsys_audio_get_current_playing_volume_type(int *volume_type)
839 if (volume_type == NULL)
840 return AVSYS_STATE_ERR_NULL_POINTER;
841 return avsys_audio_handle_current_playing_volume_type(volume_type);
844 static inline int __avsys_audio_validate_volume(const int type, const int value)
849 case AVSYS_AUDIO_VOLUME_TYPE_CALL:
850 case AVSYS_AUDIO_VOLUME_TYPE_VOIP:
851 if (value >= LVOLUME_MAX_BASIC) {
855 case AVSYS_AUDIO_VOLUME_TYPE_ALARM:
856 case AVSYS_AUDIO_VOLUME_TYPE_RINGTONE:
857 case AVSYS_AUDIO_VOLUME_TYPE_NOTIFICATION:
858 case AVSYS_AUDIO_VOLUME_TYPE_SYSTEM:
859 case AVSYS_AUDIO_VOLUME_TYPE_MEDIA:
860 case AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_JAVA:
861 if (value >= LVOLUME_MAX_MULTIMEDIA) {
865 case AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_ANDROID:
866 if (value >= LVOLUME_MAX_SINGLE) {
878 int avsys_audio_set_volume_by_type(const int type, const int value)
880 if (type < 0 || type >= AVSYS_AUDIO_VOLUME_TYPE_MAX)
881 return AVSYS_STATE_ERR_INVALID_PARAMETER;
882 if (0 > __avsys_audio_validate_volume(type, value))
883 return AVSYS_STATE_ERR_INVALID_PARAMETER;
884 return avsys_audio_handle_update_volume_by_type(type, value);
888 int avsys_audio_set_primary_volume(const int pid, const int type)
890 return avsys_audio_handle_set_primary_volume_type(pid, type, AVSYS_AUDIO_PRIMARY_VOLUME_SET);
894 int avsys_audio_clear_primary_volume(const int pid)
896 return avsys_audio_handle_set_primary_volume_type(pid, 0, AVSYS_AUDIO_PRIMARY_VOLUME_CLEAR);
900 int avsys_audio_hibernation_reset(int *vol)
902 int err = AVSYS_STATE_SUCCESS;
904 err = avsys_audio_path_ex_reset(1);
905 if (AVSYS_FAIL(err)) {
906 avsys_error(AVAUDIO, "avsys_audio_path_ex_reset(forced) failed 0x%x\n", err);
910 err = avsys_audio_handle_reset(vol);
911 if (AVSYS_FAIL(err)) {
912 avsys_error(AVAUDIO, "avsys_audio_handle_reset() failed 0x%x\n", err);
920 int avsys_audio_delay(avsys_handle_t handle, int *delay)
922 int err = AVSYS_STATE_SUCCESS;
924 avsys_audio_handle_t *p = NULL;
926 AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
928 err = avsys_audio_pasimple_delay(p, &frame_delay);
929 if (AVSYS_SUCCESS(err)) {
930 *delay = frame_delay;
933 AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
939 int avsys_audio_reset(avsys_handle_t handle)
941 int err = AVSYS_STATE_SUCCESS;
942 avsys_audio_handle_t *p = NULL;
944 AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
946 err = avsys_audio_pasimple_reset(p);
947 if (AVSYS_FAIL(err)) {
948 avsys_error(AVAUDIO, "avsys_audio_reset() failed, 0x%X\n", err);
951 AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
958 int avsys_audio_get_period_buffer_time(avsys_handle_t handle, unsigned int *period_time, unsigned int *buffer_time)
960 int err = AVSYS_STATE_SUCCESS;
961 avsys_audio_handle_t *p = NULL;
962 unsigned int p_time = 0, b_time=0;
964 AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
966 err = avsys_audio_pasimple_get_period_buffer_time(p, &p_time, &b_time);
967 if(AVSYS_FAIL(err)) {
968 avsys_error(AVAUDIO, "avsys_audio_get_period_buffer_time() failed, 0x%X\n",err);
972 *period_time = p_time;
973 *buffer_time = b_time;
974 avsys_info(AVAUDIO,"period time : %u, buffer_time : %u\n", p_time, b_time);
977 AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
983 int avsys_audio_cork (avsys_handle_t handle, int cork)
985 int err = AVSYS_STATE_SUCCESS;
986 avsys_audio_handle_t *p = NULL;
988 AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
990 err = avsys_audio_pasimple_cork(p, cork);
991 if(AVSYS_FAIL(err)) {
992 avsys_error(AVAUDIO, "avsys_audio_pasimple_cork() failed, 0x%X\n",err);
995 AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
1001 int avsys_audio_is_corked (avsys_handle_t handle, int *is_corked)
1003 int err = AVSYS_STATE_SUCCESS;
1004 avsys_audio_handle_t *p = NULL;
1006 if (is_corked == NULL) {
1007 return AVSYS_STATE_ERR_NULL_POINTER;
1010 AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
1012 err = avsys_audio_pasimple_is_corked(p, is_corked);
1013 if(AVSYS_FAIL(err)) {
1014 avsys_error(AVAUDIO, "avsys_audio_pasimple_cork() failed, 0x%X\n",err);
1017 AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
1023 int avsys_audio_get_capture_status(int *on_capture)
1025 return avsys_audio_handle_current_capture_status(on_capture);
1028 __attribute__ ((constructor))
1029 void __init_module(void)
1033 __attribute__ ((destructor))
1034 void __fini_module(void)