--- /dev/null
+Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.\r
+\r
+ Apache License\r
+ Version 2.0, January 2004\r
+ http://www.apache.org/licenses/\r
+\r
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\r
+\r
+ 1. Definitions.\r
+\r
+ "License" shall mean the terms and conditions for use, reproduction,\r
+ and distribution as defined by Sections 1 through 9 of this document.\r
+\r
+ "Licensor" shall mean the copyright owner or entity authorized by\r
+ the copyright owner that is granting the License.\r
+\r
+ "Legal Entity" shall mean the union of the acting entity and all\r
+ other entities that control, are controlled by, or are under common\r
+ control with that entity. For the purposes of this definition,\r
+ "control" means (i) the power, direct or indirect, to cause the\r
+ direction or management of such entity, whether by contract or\r
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the\r
+ outstanding shares, or (iii) beneficial ownership of such entity.\r
+\r
+ "You" (or "Your") shall mean an individual or Legal Entity\r
+ exercising permissions granted by this License.\r
+\r
+ "Source" form shall mean the preferred form for making modifications,\r
+ including but not limited to software source code, documentation\r
+ source, and configuration files.\r
+\r
+ "Object" form shall mean any form resulting from mechanical\r
+ transformation or translation of a Source form, including but\r
+ not limited to compiled object code, generated documentation,\r
+ and conversions to other media types.\r
+\r
+ "Work" shall mean the work of authorship, whether in Source or\r
+ Object form, made available under the License, as indicated by a\r
+ copyright notice that is included in or attached to the work\r
+ (an example is provided in the Appendix below).\r
+\r
+ "Derivative Works" shall mean any work, whether in Source or Object\r
+ form, that is based on (or derived from) the Work and for which the\r
+ editorial revisions, annotations, elaborations, or other modifications\r
+ represent, as a whole, an original work of authorship. For the purposes\r
+ of this License, Derivative Works shall not include works that remain\r
+ separable from, or merely link (or bind by name) to the interfaces of,\r
+ the Work and Derivative Works thereof.\r
+\r
+ "Contribution" shall mean any work of authorship, including\r
+ the original version of the Work and any modifications or additions\r
+ to that Work or Derivative Works thereof, that is intentionally\r
+ submitted to Licensor for inclusion in the Work by the copyright owner\r
+ or by an individual or Legal Entity authorized to submit on behalf of\r
+ the copyright owner. For the purposes of this definition, "submitted"\r
+ means any form of electronic, verbal, or written communication sent\r
+ to the Licensor or its representatives, including but not limited to\r
+ communication on electronic mailing lists, source code control systems,\r
+ and issue tracking systems that are managed by, or on behalf of, the\r
+ Licensor for the purpose of discussing and improving the Work, but\r
+ excluding communication that is conspicuously marked or otherwise\r
+ designated in writing by the copyright owner as "Not a Contribution."\r
+\r
+ "Contributor" shall mean Licensor and any individual or Legal Entity\r
+ on behalf of whom a Contribution has been received by Licensor and\r
+ subsequently incorporated within the Work.\r
+\r
+ 2. Grant of Copyright License. Subject to the terms and conditions of\r
+ this License, each Contributor hereby grants to You a perpetual,\r
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable\r
+ copyright license to reproduce, prepare Derivative Works of,\r
+ publicly display, publicly perform, sublicense, and distribute the\r
+ Work and such Derivative Works in Source or Object form.\r
+\r
+ 3. Grant of Patent License. Subject to the terms and conditions of\r
+ this License, each Contributor hereby grants to You a perpetual,\r
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable\r
+ (except as stated in this section) patent license to make, have made,\r
+ use, offer to sell, sell, import, and otherwise transfer the Work,\r
+ where such license applies only to those patent claims licensable\r
+ by such Contributor that are necessarily infringed by their\r
+ Contribution(s) alone or by combination of their Contribution(s)\r
+ with the Work to which such Contribution(s) was submitted. If You\r
+ institute patent litigation against any entity (including a\r
+ cross-claim or counterclaim in a lawsuit) alleging that the Work\r
+ or a Contribution incorporated within the Work constitutes direct\r
+ or contributory patent infringement, then any patent licenses\r
+ granted to You under this License for that Work shall terminate\r
+ as of the date such litigation is filed.\r
+\r
+ 4. Redistribution. You may reproduce and distribute copies of the\r
+ Work or Derivative Works thereof in any medium, with or without\r
+ modifications, and in Source or Object form, provided that You\r
+ meet the following conditions:\r
+\r
+ (a) You must give any other recipients of the Work or\r
+ Derivative Works a copy of this License; and\r
+\r
+ (b) You must cause any modified files to carry prominent notices\r
+ stating that You changed the files; and\r
+\r
+ (c) You must retain, in the Source form of any Derivative Works\r
+ that You distribute, all copyright, patent, trademark, and\r
+ attribution notices from the Source form of the Work,\r
+ excluding those notices that do not pertain to any part of\r
+ the Derivative Works; and\r
+\r
+ (d) If the Work includes a "NOTICE" text file as part of its\r
+ distribution, then any Derivative Works that You distribute must\r
+ include a readable copy of the attribution notices contained\r
+ within such NOTICE file, excluding those notices that do not\r
+ pertain to any part of the Derivative Works, in at least one\r
+ of the following places: within a NOTICE text file distributed\r
+ as part of the Derivative Works; within the Source form or\r
+ documentation, if provided along with the Derivative Works; or,\r
+ within a display generated by the Derivative Works, if and\r
+ wherever such third-party notices normally appear. The contents\r
+ of the NOTICE file are for informational purposes only and\r
+ do not modify the License. You may add Your own attribution\r
+ notices within Derivative Works that You distribute, alongside\r
+ or as an addendum to the NOTICE text from the Work, provided\r
+ that such additional attribution notices cannot be construed\r
+ as modifying the License.\r
+\r
+ You may add Your own copyright statement to Your modifications and\r
+ may provide additional or different license terms and conditions\r
+ for use, reproduction, or distribution of Your modifications, or\r
+ for any such Derivative Works as a whole, provided Your use,\r
+ reproduction, and distribution of the Work otherwise complies with\r
+ the conditions stated in this License.\r
+\r
+ 5. Submission of Contributions. Unless You explicitly state otherwise,\r
+ any Contribution intentionally submitted for inclusion in the Work\r
+ by You to the Licensor shall be under the terms and conditions of\r
+ this License, without any additional terms or conditions.\r
+ Notwithstanding the above, nothing herein shall supersede or modify\r
+ the terms of any separate license agreement you may have executed\r
+ with Licensor regarding such Contributions.\r
+\r
+ 6. Trademarks. This License does not grant permission to use the trade\r
+ names, trademarks, service marks, or product names of the Licensor,\r
+ except as required for reasonable and customary use in describing the\r
+ origin of the Work and reproducing the content of the NOTICE file.\r
+\r
+ 7. Disclaimer of Warranty. Unless required by applicable law or\r
+ agreed to in writing, Licensor provides the Work (and each\r
+ Contributor provides its Contributions) on an "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\r
+ implied, including, without limitation, any warranties or conditions\r
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\r
+ PARTICULAR PURPOSE. You are solely responsible for determining the\r
+ appropriateness of using or redistributing the Work and assume any\r
+ risks associated with Your exercise of permissions under this License.\r
+\r
+ 8. Limitation of Liability. In no event and under no legal theory,\r
+ whether in tort (including negligence), contract, or otherwise,\r
+ unless required by applicable law (such as deliberate and grossly\r
+ negligent acts) or agreed to in writing, shall any Contributor be\r
+ liable to You for damages, including any direct, indirect, special,\r
+ incidental, or consequential damages of any character arising as a\r
+ result of this License or out of the use or inability to use the\r
+ Work (including but not limited to damages for loss of goodwill,\r
+ work stoppage, computer failure or malfunction, or any and all\r
+ other commercial damages or losses), even if such Contributor\r
+ has been advised of the possibility of such damages.\r
+\r
+ 9. Accepting Warranty or Additional Liability. While redistributing\r
+ the Work or Derivative Works thereof, You may choose to offer,\r
+ and charge a fee for, acceptance of support, warranty, indemnity,\r
+ or other liability obligations and/or rights consistent with this\r
+ License. However, in accepting such obligations, You may act only\r
+ on Your own behalf and on Your sole responsibility, not on behalf\r
+ of any other Contributor, and only if You agree to indemnify,\r
+ defend, and hold each Contributor harmless for any liability\r
+ incurred by, or claims asserted against, such Contributor by reason\r
+ of your accepting any such warranty or additional liability.\r
+\r
+ END OF TERMS AND CONDITIONS\r
+\r
+ APPENDIX: How to apply the Apache License to your work.\r
+\r
+ To apply the Apache License to your work, attach the following\r
+ boilerplate notice, with the fields enclosed by brackets "[]"\r
+ replaced with your own identifying information. (Don't include\r
+ the brackets!) The text should be enclosed in the appropriate\r
+ comment syntax for the file format. We also recommend that a\r
+ file or class name and description of purpose be included on the\r
+ same "printed page" as the copyright notice for easier\r
+ identification within third-party archives.\r
+\r
+ Copyright [yyyy] [name of copyright owner]\r
+\r
+ Licensed under the Apache License, Version 2.0 (the "License");\r
+ you may not use this file except in compliance with the License.\r
+ You may obtain a copy of the License at\r
+\r
+ http://www.apache.org/licenses/LICENSE-2.0\r
+\r
+ Unless required by applicable law or agreed to in writing, software\r
+ distributed under the License is distributed on an "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ See the License for the specific language governing permissions and\r
+ limitations under the License.\r
+\r
+\r
+\r
--- /dev/null
+if IS_SDK
+SUBDIRS = pkgconfig-i386
+else
+SUBDIRS = pkgconfig-arm
+endif
+SUBDIRS += init
+
+lib_LTLIBRARIES = libavsysaudio.la
+
+includelibavsysaudiodir = $(includedir)/avsystem
+includelibavsysaudio_HEADERS = include/avsystem.h \
+ include/avsys-types.h \
+ include/avsys-error.h \
+ include/avsys-audio.h
+
+
+libavsysaudio_la_SOURCES = avsys-common.c \
+ avsys-audio-logical-volume.c \
+ avsys-audio-handle.c \
+ avsys-audio-shm.c \
+ avsys-audio-sync.c \
+ avsys-audio-alsa.c \
+ avsys-audio.c \
+ avsys-audio-ascenario.c \
+ avsys-audio-path.c \
+ avsys-audio-pactrl.c
+
+libavsysaudio_la_CFLAGS = $(ALSA_CFLAGS) -I$(srcdir)/include
+
+libavsysaudio_la_LIBADD = $(ALSA_LIBS) -ldl -lrt -lpthread
+libavsysaudio_la_LDFLAGS = -Wl,-init, __init_module
+libavsysaudio_la_LDFLAGS += -Wl,-fini, __fini_module -version-info 0:1:0
+
+libavsysaudio_la_SOURCES += avsys-audio-pasimple.c
+libavsysaudio_la_CFLAGS += $(PASIMPLE_CFLAGS) $(PA_CFLAGS)
+libavsysaudio_la_LIBADD += $(PASIMPLE_LIBS) $(PA_LIBS)
+
+libavsysaudio_la_CFLAGS += $(ASCN_CFLAGS)
+libavsysaudio_la_LIBADD += $(ASCN_LIBS)
+
+
+if IS_SDK
+libavsysaudio_la_CFLAGS += -DAUDIO_SDK_BUILD \
+ -D_MMFW_I386_ALL_SIMULATOR
+endif
+
+libavsysaudio_la_CFLAGS += $(MMLOG_CFLAGS) \
+ -D__DEBUG_MODE__ \
+ -D__USE_LOGMANAGER__ \
+ -DMM_DEBUG_FLAG
+
+libavsysaudio_la_LIBADD += $(MMLOG_LIBS)
+
+
+bin_PROGRAMS = sound_initializer
+sound_initializer_SOURCES = avsys-audio-initializer.c
+sound_initializer_CFLAGS = -I$(srcdir)/include
+
+sound_initializer_CFLAGS += $(MMLOG_CFLAGS)
+sound_initializer_LDADD = libavsysaudio.la
+sound_initializer_DEPENDENCIES = libavsysaudio.la
+
+if WITH_AUDIOTEST
+bin_PROGRAMS += avsys_audio_test
+avsys_audio_test_SOURCES = audiotest/avsys-audio-test.c
+avsys_audio_test_CFLAGS = -I$(srcdir)/include
+avsys_audio_test_LDADD = libavsysaudio.la
+avsys_audio_test_DEPENDENCIES = libavsysaudio.la
+
+bin_PROGRAMS += avsys_volume_dump
+avsys_volume_dump_SOURCES = audiotest/avsys-audio-volume-dump.c
+avsys_volume_dump_LDADD = libavsysaudio.la
+avsys_volume_dump_DEPENDENCIES = libavsysaudio.la
+endif
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <alloca.h>
+#include <memory.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <signal.h>
+#include <avsys-audio.h>
+
+#define VERSION (0001)
+
+void usage(char *name)
+{
+ printf("Usage: %s [OPTION]... [FILE]...\n\n", name);
+ printf("-h\t\thelp\n");
+ printf("-p\t\tplay raw file (default mode 0) \n");
+ printf("-c\t\tcapture audio to raw file (default mode 0)\n");
+ printf("-m\t\tmode\n");
+ printf("\t\tmode 0 : S16LE / Stereo / 44100Hz\n");
+ printf("\t\tmode 1 : S16LE / Mono / 8000Hz\n");
+ printf("\t\tmode 2 : S16LE / Mono / 22050Hz\n");
+ printf("\t\tmode 3 : U8 / Mono / 8000Hz\n");
+ printf("-r\t\trouting\n");
+ printf("\t\trouting 0 : following policy\n");
+ printf("\t\trouting 1 : forced set to alsa\n");
+ printf("\n");
+ return;
+}
+
+enum {
+ OP_NONE = -1,
+ OP_PLAYBACK,
+ OP_CAPTURE,
+};
+
+#define MODE_MIN 0
+#define MODE_MAX 3
+
+static struct sigaction sigterm_action; /* Backup pointer of SIGTERM signal handler */
+int g_interrupted;
+
+int __make_param(int op, int mode, int routing, avsys_audio_param_t *param)
+{
+ if (!param)
+ return -1;
+
+ if (op == OP_PLAYBACK)
+ param->mode = AVSYS_AUDIO_MODE_OUTPUT;
+ else if (op == OP_CAPTURE)
+ param->mode = AVSYS_AUDIO_MODE_INPUT;
+ else
+ return -1;
+
+ param->priority = AVSYS_AUDIO_PRIORITY_NORMAL;
+ param->vol_type = AVSYS_AUDIO_VOLUME_TYPE_SYSTEM;
+ param->bluetooth = routing;
+
+ switch (mode) {
+ case 0:
+ param->format = AVSYS_AUDIO_FORMAT_16BIT;
+ param->samplerate = 44100;
+ param->channels = 2;
+ break;
+ case 1:
+ param->format = AVSYS_AUDIO_FORMAT_16BIT;
+ param->samplerate = 8000;
+ param->channels = 1;
+ break;
+ case 2:
+ param->format = AVSYS_AUDIO_FORMAT_16BIT;
+ param->samplerate = 22050;
+ param->channels = 1;
+ break;
+ case 3:
+ param->format = AVSYS_AUDIO_FORMAT_8BIT;
+ param->samplerate = 8000;
+ param->channels = 1;
+ break;
+ default:
+ return -1;
+ break;
+ }
+ return 0;
+}
+int _playback(int mode, int routing, char *filename)
+{
+ int res = 0;
+ avsys_audio_param_t param;
+ avsys_handle_t handle = -1;
+ int recommended_period_size = 0;
+ int fd = -1;
+ char *pcmbuf = NULL;
+ int size = 0;
+
+ if (!filename)
+ return -1;
+
+ memset(¶m, sizeof(avsys_audio_param_t), '\0');
+
+ if (__make_param(OP_PLAYBACK, mode, routing, ¶m)) {
+ printf("Can not make audio parameter\n");
+ return -1;
+ }
+
+ res = avsys_audio_open(¶m, &handle, &recommended_period_size);
+ if (res != 0) {
+ printf("Can not open handle 0x%x\n", res);
+ goto FAIL;
+ }
+
+ pcmbuf = alloca(recommended_period_size);
+ if (!pcmbuf)
+ goto FAIL;
+
+ fd = open(filename, O_RDONLY);
+ if (fd == -1)
+ goto FAIL;
+
+ while (((size = read(fd, pcmbuf, recommended_period_size)) > 0) && !g_interrupted) {
+ if (AVSYS_FAIL(avsys_audio_write(handle, pcmbuf, recommended_period_size))) {
+ printf("Oops!! audio play fail\n");
+ break;
+ }
+ }
+
+ close(fd);
+ avsys_audio_close(handle);
+ return 0;
+FAIL:
+ if (handle != -1)
+ avsys_audio_close(handle);
+
+ if (fd != -1)
+ close(fd);
+
+ return res;
+}
+
+int _capture(int mode, int routing, char *filename)
+{
+ int res = 0;
+ avsys_audio_param_t param;
+ avsys_handle_t handle = -1;
+ int recommended_period_size = 0;
+ int fd = -1;
+ char *pcmbuf = NULL;
+ int size = 0;
+ char namebuffer[64]= {0,};
+
+ if (!filename)
+ return -1;
+ else
+ snprintf(namebuffer, sizeof(namebuffer)-1, "%s.raw_%1d", filename, mode);
+
+ printf("[%s] real filename :%s\n", __func__, namebuffer);
+
+ memset(¶m, sizeof(avsys_audio_param_t), '\0');
+
+ if (__make_param(OP_CAPTURE, mode, routing, ¶m)) {
+ printf("Can not make audio parameter\n");
+ return -1;
+ }
+
+ res = avsys_audio_open(¶m, &handle, &recommended_period_size);
+ if (res != 0) {
+ printf("Can not open handle 0x%x\n", res);
+ goto FAIL;
+ }
+
+ pcmbuf = alloca(recommended_period_size);
+ if (!pcmbuf) {
+ printf("Can not alloca pcm buffer\n");
+ goto FAIL;
+ }
+
+ fd = open(namebuffer, O_WRONLY | O_CREAT);
+ if (fd == -1) {
+ printf("Can not open file %s, %s\n", namebuffer, strerror(errno));
+ goto FAIL;
+ }
+
+ while (((size = avsys_audio_read(handle, pcmbuf, recommended_period_size)) > 0) && !g_interrupted) {
+ if (-1 == write(fd, pcmbuf, size))
+ break;
+ }
+
+ close(fd);
+ avsys_audio_close(handle);
+ return 0;
+FAIL:
+ printf("[%s] FAIL\n",__func__);
+ if (handle != -1)
+ avsys_audio_close(handle);
+
+ if (fd != -1)
+ close(fd);
+
+ return res;
+}
+
+void sig_handler(int signo)
+{
+ g_interrupted = 1;
+}
+
+int main(int argc, char *argv[])
+{
+ int opt = 0;
+ int operation = OP_NONE;
+ int mode = 0;
+ int tmp = 0;
+ int routing = 0;
+ struct sigaction action;
+
+ while ((opt = getopt(argc, argv, "hpcm:r:")) != -1) {
+ switch (opt) {
+ case 'h':
+ usage(argv[0]);
+ return 0;
+ break;
+ case 'p':
+ if (operation != OP_NONE) {
+ usage(argv[0]);
+ return 0;
+ }
+ operation = OP_PLAYBACK;
+ break;
+ case 'c':
+ if (operation != OP_NONE) {
+ usage(argv[0]);
+ return 0;
+ }
+ operation = OP_CAPTURE;
+ break;
+ case 'm':
+ tmp = atoi(optarg);
+ if (tmp < MODE_MIN || tmp > MODE_MAX) {
+ usage(argv[0]);
+ printf("MESSAGE : Unsupported mode number\n");
+ return -1;
+ }
+ mode = tmp;
+ break;
+ case 'r':
+ tmp = atoi(optarg);
+ if (tmp < 0 || tmp > 1) {
+ usage(argv[0]);
+ printf("MESSAGE : Unsupported mode number\n");
+ return -1;
+ }
+ routing = tmp;
+ break;
+ default:
+ usage(argv[0]);
+ break;
+ }
+ }
+
+ action.sa_handler = sig_handler;
+ action.sa_flags = 0;
+ sigemptyset(&action.sa_mask);
+ sigaction(SIGINT, &action, &sigterm_action);
+
+ if (operation == OP_NONE) {
+ usage(argv[0]);
+ printf("MESSAGE : Operation is not determined\n");
+ return -1;
+ } else if (operation == OP_PLAYBACK) {
+ char *name = NULL;
+ name = argv[optind++];
+ printf("op %u, mode %u, routing %d, name %s\n", operation, mode, routing, name);
+ _playback(mode, routing, name);
+ } else if (operation == OP_CAPTURE) {
+ char *name = NULL;
+ name = argv[optind++];
+ if (strlen(name) < 2) {
+ printf("Insufficient filename length\n");
+ return -2;
+ }
+ printf("op %u, mode %u, routing %d, name %s\n", operation, mode, routing, name);
+ _capture(mode, routing, name);
+ }
+
+ return 0;
+}
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdio.h>
+#include <alloca.h>
+#include <string.h>
+#include "../include/avsys-audio.h"
+#include "../include/avsys-audio-logical-volume.h"
+
+#define VERSION_NUM 0001
+
+
+void usage(char *name)
+{
+ printf("Usage: %s [FILE]...\n\n", name);
+ printf("Version %04d\n", VERSION_NUM);
+ printf("\n");
+ return;
+}
+
+int main(int argc, char* argv[])
+{
+ int i = 0;
+ int j = 0;
+ int k = 0;
+ int err = 0;
+ char filepath[256]={0,};
+ FILE *fp = NULL;
+
+ if(argc > 2)
+ {
+ usage(argv[0]);
+ return 0;
+ }
+ else if(argc == 2)
+ {
+ strncpy(filepath, argv[1], sizeof(filepath)-1);
+ }
+ else if(argc == 1)
+ {
+ strncpy(filepath, VOLUME_FILE_PATH, sizeof(filepath)-1);
+ fprintf(stderr,"Use default file path %s\n", filepath);
+ }
+
+ fp = fopen(filepath, "w");
+ if(!fp)
+ {
+ fprintf(stderr,"Can not open file %s\n",filepath);
+ return -1;
+ }
+
+ for(i=AVSYS_AUDIO_LVOL_GAIN_TYPE_0; i<AVSYS_AUDIO_LVOL_GAIN_TYPE_MAX; i++)
+ {
+ for(j=AVSYS_AUDIO_LVOL_DEV_TYPE_SPK; j<=AVSYS_AUDIO_LVOL_DEV_TYPE_BTHEADSET;j++)
+ {
+ int lv = 0;
+ int rv = 0;
+ char *str_dev[] = { "SPK", "HEADSET", "BTHEADSET" };
+
+ for(k=0;k<LVOLUME_MAX_MULTIMEDIA;k++)
+ {
+ err = avsys_audio_get_volume_table(i, AVSYS_AUDIO_LVOL_DEV_TYPE_SPK, k, &lv, &rv);
+ if(err)
+ goto FAIL;
+
+ fprintf(fp,"%1d:%s:%d:%d:%d\n",i,str_dev[j],k,lv,rv);
+ }
+ }
+ }
+
+ if(fp != NULL)
+ {
+ fclose(fp);
+ }
+ printf("Success\n");
+ return 0;
+
+FAIL:
+ if(fp != NULL)
+ {
+ fclose(fp);
+ }
+ unlink(filepath);
+ fprintf(stderr,"Can not dump volume table\n");
+ return -1;
+}
--- /dev/null
+aclocal
+libtoolize --copy
+autoheader
+autoconf
+automake --add-missing --copy --foreign
+#./configure --with-xo-machine=W1
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <alsa/asoundlib.h>
+
+#include "avsys-audio-alsa.h"
+#include "avsys-types.h"
+#include "avsys-error.h"
+#include "avsys-debug.h"
+
+#if defined(_MMFW_I386_ALL_SIMULATOR)
+#define AIF2_DEVICE_NAME "default"
+#define AIF3_DEVICE_NAME "default"
+#else
+#define AIF2_DEVICE_NAME "AIF2"
+#define AIF3_DEVICE_NAME "AIF3"
+#endif
+
+int avsys_audio_alsa_open_AIF_device(const int AIF_type, avsys_audio_alsa_aif_handle_t *handle)
+{
+ snd_pcm_t *ahandle = NULL;
+ int err = -1;
+ char dev_name[16] = { 0, };
+ snd_pcm_stream_t stream = SND_PCM_STREAM_PLAYBACK;
+
+ avsys_info(AVAUDIO, "%s\n", __func__);
+ if (!handle)
+ return AVSYS_STATE_ERR_NULL_POINTER;
+
+ memset(dev_name, '\0', sizeof(dev_name));
+ switch (AIF_type) {
+ case AIF2_CAPTURE:
+ strncpy(dev_name, AIF2_DEVICE_NAME, sizeof(dev_name) - 1);
+ stream = SND_PCM_STREAM_CAPTURE;
+ break;
+ case AIF2_PLAYBACK:
+ strncpy(dev_name, AIF2_DEVICE_NAME, sizeof(dev_name) - 1);
+ stream = SND_PCM_STREAM_PLAYBACK;
+ break;
+ case AIF3_CAPTURE:
+ strncpy(dev_name, AIF3_DEVICE_NAME, sizeof(dev_name) - 1);
+ stream = SND_PCM_STREAM_CAPTURE;
+ break;
+ case AIF3_PLAYBACK:
+ strncpy(dev_name, AIF3_DEVICE_NAME, sizeof(dev_name) - 1);
+ stream = SND_PCM_STREAM_PLAYBACK;
+ break;
+ default:
+ avsys_critical_r(AVAUDIO, "Invalid AIF device %d\n", AIF_type);
+ return AVSYS_STATE_ERR_INVALID_MODE;
+ break;
+ }
+#if !defined(_MMFW_I386_ALL_SIMULATOR)
+ err = snd_pcm_open(&ahandle, dev_name, stream, 0);
+#else
+ avsys_warning_r(AVAUDIO, "Skip real device open in SDK\n");
+ err = 0; /* set fake return value */
+#endif
+
+ if (err < 0) {
+ avsys_error_r(AVAUDIO, "unable to open AIF device: %s\n", snd_strerror(err));
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ handle->alsa_handle = (void *)ahandle;
+ handle->type = AIF_type;
+
+ return AVSYS_STATE_SUCCESS;
+}
+
+int avsys_audio_alsa_close_AIF_device(avsys_audio_alsa_aif_handle_t* handle)
+{
+ int err = 0;
+ snd_pcm_t *ahandle = NULL;
+
+ avsys_info(AVAUDIO, "%s\n", __func__);
+#if defined(_MMFW_I386_ALL_SIMULATOR)
+ avsys_warning(AVAUDIO, "Skip close call device in SDK");
+ return AVSYS_STATE_SUCCESS;
+#endif
+ if (!handle)
+ return AVSYS_STATE_ERR_NULL_POINTER;
+
+ ahandle = (snd_pcm_t *)handle->alsa_handle;
+ if (!ahandle) {
+ avsys_error_r(AVAUDIO, "[%s] alsa handle is null\n", __func__);
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ }
+
+ err = snd_pcm_close(ahandle);
+ if (err < 0) {
+ avsys_critical_r(AVAUDIO, "unable to close pcm device: %s\n", snd_strerror(err));
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ handle->alsa_handle = NULL;
+
+ return AVSYS_STATE_SUCCESS;
+}
+
+int avsys_audio_alsa_set_AIF_params(avsys_audio_alsa_aif_handle_t *handle)
+{
+#if defined(_MMFW_I386_ALL_SIMULATOR)
+ return AVSYS_STATE_SUCCESS;
+#else
+ int err = 0;
+ snd_pcm_t *ahandle = NULL;
+ snd_pcm_hw_params_t *params;
+ unsigned int val;
+ int dir;
+
+ avsys_info(AVAUDIO, "%s\n", __func__);
+ if (!handle)
+ return AVSYS_STATE_ERR_NULL_POINTER;
+
+ ahandle = (snd_pcm_t *)handle->alsa_handle;
+ if (!ahandle)
+ return AVSYS_STATE_ERR_NULL_POINTER;
+
+ /* Allocate a hardware parameters object. */
+ snd_pcm_hw_params_alloca(¶ms);
+ /* Fill it in with default values. */
+ snd_pcm_hw_params_any(ahandle, params);
+
+ /* Set the desired hardware parameters. */
+ /* Interleaved mode */
+ snd_pcm_hw_params_set_access(ahandle, params, SND_PCM_ACCESS_RW_INTERLEAVED);
+
+ err = snd_pcm_hw_params(ahandle, params);
+ if (err < 0) {
+ avsys_error_r(AVAUDIO, "snd_pcm_hw_params() : failed! - %s\n", snd_strerror(err));
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ /* Dump current param */
+ snd_pcm_hw_params_get_access(params, (snd_pcm_access_t *) &val);
+ avsys_info(AVAUDIO, "access type = %s\n", snd_pcm_access_name((snd_pcm_access_t)val));
+
+ snd_pcm_hw_params_get_format(params, &val);
+ avsys_info(AVAUDIO, "format = '%s' (%s)\n",
+ snd_pcm_format_name((snd_pcm_format_t)val),
+ snd_pcm_format_description((snd_pcm_format_t)val));
+
+ snd_pcm_hw_params_get_subformat(params, (snd_pcm_subformat_t *)&val);
+ avsys_info(AVAUDIO, "subformat = '%s' (%s)\n",
+ snd_pcm_subformat_name((snd_pcm_subformat_t)val),
+ snd_pcm_subformat_description((snd_pcm_subformat_t)val));
+
+ snd_pcm_hw_params_get_channels(params, &val);
+ avsys_info(AVAUDIO, "channels = %d\n", val);
+
+ snd_pcm_hw_params_get_rate(params, &val, &dir);
+ avsys_info(AVAUDIO, "rate = %d bps\n", val);
+
+ return AVSYS_STATE_SUCCESS;
+#endif
+}
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#if !defined(_MMFW_I386_ALL_SIMULATOR)
+#include <alsa/ascenario.h>
+#endif
+#include <string.h>
+
+#include "avsys-audio-ascenario.h"
+#include "avsys-types.h"
+#include "avsys-error.h"
+#include "avsys-debug.h"
+#if defined(TIME_CHECK)
+#include <sys/time.h>
+#include <time.h>
+#endif
+
+#define STR_BUFF_MAX 128
+#define P_STR_MAX 42
+#define O_STR_MAX 44
+static int __avsys_audio_ascn_make_scenario_str(int input, char *buf, int buf_len)
+{
+ char fromStr[P_STR_MAX] = { 0, };
+ char toStr[P_STR_MAX] = { 0, };
+ char optStr[O_STR_MAX] = { 0, };
+
+ if (buf == NULL) {
+ avsys_error(AVAUDIO, "Input Buf is null\n");
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ }
+
+ if (input & INPUT_MAIN_MIC) {
+ strncpy(fromStr, "mainmic", sizeof(fromStr) - 1);
+ }
+ if (input & INPUT_SUB_MIC) {
+ strncpy(fromStr, "submic", sizeof(fromStr) - 1);
+ }
+ if (input & INPUT_STEREO_MIC) {
+ strncpy(fromStr, "stereomic", sizeof(fromStr) - 1);
+ }
+ if (input & INPUT_EAR_MIC) {
+ strncpy(fromStr, "earmic", sizeof(fromStr) - 1);
+ }
+ if (input & INPUT_BT_MIC) {
+ strncpy(fromStr, "bt", sizeof(fromStr) - 1);
+ }
+ if (input & INPUT_AP) {
+ strncpy(fromStr, "ap", sizeof(fromStr) - 1);
+ }
+ if (input & INPUT_CP) {
+ strncpy(fromStr, "cp", sizeof(fromStr) - 1);
+ }
+ if (input & INPUT_FMRADIO) {
+ strncpy(fromStr, "fmradio", sizeof(fromStr) - 1);
+ }
+
+ if (input & OUTPUT_HEADSET) {
+ strncpy(toStr, "headset", sizeof(toStr) - 1);
+ }
+ if (input & OUTPUT_LEFT_SPK) {
+ strncpy(toStr, "speaker_left", sizeof(toStr) - 1);
+ }
+ if (input & OUTPUT_RIGHT_SPK) {
+ strncpy(toStr, "speaker_right", sizeof(toStr) - 1);
+ }
+ if (input & OUTPUT_STEREO_SPK) {
+ strncpy(toStr, "speaker", sizeof(toStr) - 1);
+ }
+ if (input & OUTPUT_RECV) {
+ strncpy(toStr, "receiver", sizeof(toStr) - 1);
+ }
+ if (input & OUTPUT_BT_HEADSET) {
+ strncpy(toStr, "bt", sizeof(toStr) - 1);
+ }
+ if (input & OUTPUT_CP) {
+ strncpy(toStr, "cp", sizeof(toStr) - 1);
+ }
+ if (input & OUTPUT_AP) {
+ strncpy(toStr, "ap", sizeof(toStr) - 1);
+ }
+
+ if (input & GAIN_MODE) {
+ strncpy(optStr, "_gain", sizeof(optStr) - 1);
+ }
+ if (input & GAIN_VIDEO_CALL) {
+ strncpy(optStr, "_videocall_gain", sizeof(optStr) - 1);
+ }
+ if (input & GAIN_VOICE_CALL) {
+ strncpy(optStr, "_voicecall_gain", sizeof(optStr) - 1);
+ }
+ if (input & GAIN_CALLALERT) {
+ strncpy(optStr, "_ringtone_gain", sizeof(optStr) - 1);
+ }
+
+ snprintf(buf, buf_len - 1, "%s_to_%s%s", fromStr, toStr, optStr);
+ //avsys_info(AVAUDIO, "rslt str : %s\n", buf);
+ return AVSYS_STATE_SUCCESS;
+}
+
+int avsys_audio_ascn_bulk_set(int * bulk, int bulk_cnt, AscnResetType clear)
+{
+ struct snd_scenario *scn = NULL;
+ char card_name[STR_BUFF_MAX] = { 0, };
+ char str_buf[STR_BUFF_MAX] = { 0, };
+ char reset_str[STR_BUFF_MAX] = { 0, };
+ int err = AVSYS_STATE_SUCCESS;
+ int i = 0;
+#if defined(TIME_CHECK)
+ struct timeval t_start, t_stop;
+ unsigned long check = 0;
+#endif
+
+ avsys_info(AVAUDIO, "<< %s, clear = %d\n", __func__, clear);
+
+ if (clear < ASCN_RESET_NONE || clear > ASCN_RESET_MODEM) {
+ avsys_error_r(AVAUDIO, "invalid clear type %d\n", clear);
+ return AVSYS_STATE_ERR_RANGE_OVER;
+ }
+
+ if (bulk == NULL) {
+ avsys_error_r(AVAUDIO, "input bulk is null\n");
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ }
+ if (bulk_cnt < 0) {
+ avsys_error_r(AVAUDIO, "bulk_cnt is negative\n");
+ return AVSYS_STATE_ERR_RANGE_OVER;
+ }
+
+ snprintf(card_name, sizeof(card_name) - 1, "default");
+#if defined(TIME_CHECK)
+ gettimeofday(&t_start, NULL);
+#endif
+ //avsys_info(AVAUDIO, "snd_scenario_open() with [%s]\n", card_name);
+ scn = snd_scenario_open(card_name);
+#if defined(TIME_CHECK)
+ gettimeofday(&t_stop, NULL);
+ if (t_stop.tv_sec == t_start.tv_sec)
+ check = (t_stop.tv_usec - t_start.tv_usec) / 1000;
+ else
+ check = (t_stop.tv_sec - t_start.tv_sec) * 1000 + (t_stop.tv_usec - t_start.tv_usec) / 1000;
+ avsys_warning(AVAUDIO, "[snd_scenario_open()] takes %u msec\n", check);
+#endif
+ if (scn == NULL) {
+ avsys_error_r(AVAUDIO, "alsa scenario open failed %s\n", card_name);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+ //avsys_info(AVAUDIO, "snd_scenario_open() success\n");
+
+ if (clear != ASCN_RESET_NONE) {
+ switch (clear) {
+ case ASCN_RESET_ALL:
+ snprintf(reset_str, sizeof(reset_str) - 1, "%s", ASCN_STR_RESET);
+ break;
+ case ASCN_RESET_PLAYBACK:
+ snprintf(reset_str, sizeof(reset_str) - 1, "%s", ASCN_STR_RESET_PLAYBACK);
+ break;
+ case ASCN_RESET_CAPTURE:
+ snprintf(reset_str, sizeof(reset_str) - 1, "%s", ASCN_STR_RESET_CAPTURE);
+ break;
+ }
+#if defined(TIME_CHECK)
+ gettimeofday(&t_start, NULL);
+#endif
+ err = snd_scenario_set_scn(scn, reset_str);
+#if defined(TIME_CHECK)
+ gettimeofday(&t_stop, NULL);
+ if (t_stop.tv_sec == t_start.tv_sec)
+ check = (t_stop.tv_usec - t_start.tv_usec) / 1000;
+ else
+ check = (t_stop.tv_sec - t_start.tv_sec) * 1000 + (t_stop.tv_usec - t_start.tv_usec) / 1000;
+ avsys_warning(AVAUDIO, "[%s] takes %u msec\n", reset_str, check);
+#endif
+ if (err < 0) {
+ avsys_error(AVAUDIO, "Alsa sceanrio [%s] failed\n", reset_str);
+ } else {
+ avsys_warning(AVAUDIO, "Set [%s] success\n", reset_str);
+ }
+ }
+
+ for (i = 0; i < bulk_cnt; i++) {
+ if (bulk[i] == 0)
+ continue;
+ memset(str_buf, '\0', sizeof(str_buf));
+ //avsys_info(AVAUDIO, "make string for 0x%X\n", bulk[i]);
+ __avsys_audio_ascn_make_scenario_str(bulk[i], str_buf, sizeof(str_buf));
+ //avsys_info(AVAUDIO, "result string [%s]\n", str_buf);
+#if defined(TIME_CHECK)
+ gettimeofday(&t_start, NULL);
+#endif
+ err = snd_scenario_set_scn(scn, str_buf);
+#if defined(TIME_CHECK)
+ gettimeofday(&t_stop, NULL);
+ if (t_stop.tv_sec == t_start.tv_sec)
+ check = (t_stop.tv_usec - t_start.tv_usec) / 1000;
+ else
+ check = (t_stop.tv_sec - t_start.tv_sec) * 1000 + (t_stop.tv_usec - t_start.tv_usec) / 1000;
+ avsys_warning(AVAUDIO, "[%s] takes %u msec\n", str_buf, check);
+#endif
+ if (err < 0) {
+ avsys_error_r(AVAUDIO, "snd_scenario_set_scn(%s) failed with %d\n", str_buf, err);
+ goto bulk_error;
+ }
+ avsys_warning(AVAUDIO, "* [0x%010X] Set [%s] success\n", bulk[i], str_buf);
+ }
+
+bulk_error:
+#if defined(TIME_CHECK)
+ gettimeofday(&t_start, NULL);
+#endif
+ snd_scenario_close(scn);
+#if defined(TIME_CHECK)
+ gettimeofday(&t_stop, NULL);
+ if (t_stop.tv_sec == t_start.tv_sec)
+ check = (t_stop.tv_usec - t_start.tv_usec) / 1000;
+ else
+ check = (t_stop.tv_sec - t_start.tv_sec) * 1000 + (t_stop.tv_usec - t_start.tv_usec) / 1000;
+ avsys_warning(AVAUDIO, "[snd_scenario_close()] takes %u msec\n", check);
+#endif
+ return err;
+}
+
+
+int avsys_audio_ascn_single_set(char * str)
+{
+ struct snd_scenario *scn = NULL;
+ char card_name[STR_BUFF_MAX] = { 0, };
+ char cmd_str[STR_BUFF_MAX] = { 0, };
+ int err = AVSYS_STATE_SUCCESS;
+
+ if (str == NULL) {
+ avsys_error_r(AVAUDIO, "input str is null\n");
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ }
+
+ snprintf(card_name, sizeof(card_name) - 1, "default");
+// avsys_info(AVAUDIO, "snd_scenario_open() with [%s]\n", card_name);
+ scn = snd_scenario_open(card_name);
+ if (scn == NULL) {
+ avsys_error_r(AVAUDIO, "alsa scenario open failed %s\n", card_name);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+// avsys_info(AVAUDIO, "snd_scenario_open() success\n");
+
+ strncpy(cmd_str, str, sizeof(cmd_str) - 1);
+ err = snd_scenario_set_scn(scn, str);
+ avsys_warning(AVAUDIO, "alsa scenario set [%s]\n", str);
+
+ if (err < 0) {
+ avsys_error_r(AVAUDIO, "snd_scenario_set(%s) failed\n", str);
+ }
+
+ snd_scenario_close(scn);
+
+ return err;
+}
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "avsys-common.h"
+#include "avsys-audio-shm.h"
+#include "avsys-audio-sync.h"
+#include "avsys-debug.h"
+#include "avsys-audio-handle.h"
+#include "avsys-audio-shm.h"
+#include "avsys-audio-path.h"
+#include "avsys-audio-logical-volume.h"
+#include "avsys-audio-pactrl.h"
+
+#define DEFAULT_VOLUME_SYSTEM 2
+#define DEFAULT_VOLUME_RINGTONE 6
+#define DEFAULT_VOLUME_MEDIA 11
+#define DEFAULT_VOLUME_NOTIFICATION 6
+#define DEFAULT_VOLUME_ALARM 6
+#define DEFAULT_VOLUME_CALL 6
+#define DEFAULT_VOLUME_FIXED 0
+#define DEFAULT_VOLUME_JAVA 11
+
+#define AVSYS_GET_SHM(SHM,ERROR) do { \
+ if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_HANDLE, (void **)SHM))) { \
+ avsys_error(AVAUDIO,"avsys_audio_get_shm() failed in %s\n", __func__); \
+ return ERROR; \
+ } \
+} while (0)
+
+#define AVSYS_LOCK_SYNC() do { \
+ if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_HANDLE))) { \
+ avsys_error(AVAUDIO,"avsys_audio_lock_sync() failed in %s\n", __func__); \
+ return AVSYS_STATE_ERR_INTERNAL; \
+ } \
+} while (0)
+
+#define AVSYS_UNLOCK_SYNC() do { \
+ if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_HANDLE))) { \
+ avsys_error(AVAUDIO,"avsys_audio_unlock_sync() failed in %s\n", __func__); \
+ return AVSYS_STATE_ERR_INTERNAL; \
+ } \
+} while (0)
+
+EXPORT_API
+int avsys_audio_handle_init(void)
+{
+ int i, err = 0;
+ avsys_audio_handle_info_t *control = NULL;
+ avsys_audio_handle_info_t **temp = NULL;
+
+ /* Check root user */
+ err = avsys_check_root_privilege();
+ if (AVSYS_FAIL(err)) {
+ return err;
+ }
+
+ if (AVSYS_FAIL(avsys_audio_create_sync(AVSYS_AUDIO_SYNC_IDEN_HANDLE))) {
+ avsys_error(AVAUDIO, "avsys_audio_create_sync() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+ if (AVSYS_FAIL(avsys_audio_create_shm(AVSYS_AUDIO_SHM_IDEN_HANDLE))) {
+ avsys_error(AVAUDIO, "avsys_audio_create_shm() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ temp = &control;
+ AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
+ if (control == NULL) {
+ avsys_error(AVAUDIO, "control is null in %s\n", __func__);
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ }
+
+ /* init allocted bits */
+ control->allocated = 0;
+ control->handle_amp = 0;
+ control->volume_value[AVSYS_AUDIO_LVOL_GAIN_TYPE_0] = DEFAULT_VOLUME_SYSTEM;
+ control->volume_value[AVSYS_AUDIO_LVOL_GAIN_TYPE_1] = DEFAULT_VOLUME_NOTIFICATION;
+ control->volume_value[AVSYS_AUDIO_LVOL_GAIN_TYPE_2] = DEFAULT_VOLUME_ALARM;
+ control->volume_value[AVSYS_AUDIO_LVOL_GAIN_TYPE_3] = DEFAULT_VOLUME_RINGTONE;
+ control->volume_value[AVSYS_AUDIO_LVOL_GAIN_TYPE_4] = DEFAULT_VOLUME_MEDIA;
+ control->volume_value[AVSYS_AUDIO_LVOL_GAIN_TYPE_5] = DEFAULT_VOLUME_CALL;
+ control->volume_value[AVSYS_AUDIO_LVOL_GAIN_TYPE_6] = DEFAULT_VOLUME_FIXED;
+ control->volume_value[AVSYS_AUDIO_LVOL_GAIN_TYPE_7] = DEFAULT_VOLUME_JAVA;
+ control->volume_value[AVSYS_AUDIO_LVOL_GAIN_TYPE_8] = DEFAULT_VOLUME_MEDIA;
+ control->ext_device_amp = AVSYS_AUDIO_HANDLE_EXT_DEV_NONE;
+ control->primary_volume_pid = 0;
+ control->primary_volume_type = -1;
+ for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
+ control->handle_priority[i] = AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0;
+ }
+
+ for (i = 0; i < AVSYS_AUDIO_LOCK_SLOT_MAX; i++) {
+ control->handlelock_pid[i] = -1;
+ }
+ return AVSYS_STATE_SUCCESS;
+}
+
+EXPORT_API
+int avsys_audio_handle_fini(void)
+{
+
+ AVSYS_LOCK_SYNC();
+
+ if (AVSYS_FAIL(avsys_audio_remove_shm(AVSYS_AUDIO_SHM_IDEN_HANDLE))) {
+ avsys_error(AVAUDIO, "avsys_audio_remove_shm() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ AVSYS_UNLOCK_SYNC();
+
+ if (AVSYS_FAIL(avsys_audio_remove_sync(AVSYS_AUDIO_SYNC_IDEN_HANDLE))) {
+ avsys_error(AVAUDIO, "avsys_audio_remove_sync() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ return AVSYS_STATE_SUCCESS;
+}
+
+EXPORT_API
+int avsys_audio_handle_reset(int *volume_value)
+{
+ int i = 0, err = 0;
+ long long int flag = 0x01;
+ avsys_audio_handle_info_t *control = NULL;
+ avsys_audio_handle_info_t **temp = NULL;
+ int *lvolume = NULL;
+ int default_volume[] = { DEFAULT_VOLUME_SYSTEM, DEFAULT_VOLUME_NOTIFICATION,
+ DEFAULT_VOLUME_ALARM, DEFAULT_VOLUME_RINGTONE,
+ DEFAULT_VOLUME_MEDIA, DEFAULT_VOLUME_CALL,
+ DEFAULT_VOLUME_FIXED, DEFAULT_VOLUME_JAVA};
+ temp = &control;
+
+ /* Check root user */
+ err = avsys_check_root_privilege();
+ if (AVSYS_FAIL(err)) {
+ return err;
+ }
+
+ AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
+ if (control == NULL) {
+ avsys_error(AVAUDIO, "control is null in %s\n", __func__);
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ }
+
+ if (volume_value == NULL) {
+ lvolume = default_volume;
+ } else {
+ lvolume = volume_value;
+ }
+
+ for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
+ if (control->allocated & (flag << i)) { /* allocated condition */
+ if (AVSYS_FAIL(avsys_check_process(control->handles[i].pid))) {
+ /* process dead */
+ if (AVSYS_FAIL(avsys_audio_handle_free(i))) {
+ avsys_error(AVAUDIO, "Cleanup handle %d failed\n", i);
+ }
+ }
+ }
+ }
+
+ while (control->allocated) {
+ if (++i > 5)
+ break;
+ avsys_warning(AVAUDIO, "(%d)Waiting...0.5 sec for resume from hibernation\n", i);
+ printf("(%d)Waiting...0.5 sec for resume from hibernation\n", i);
+ usleep(500);
+ }
+
+ AVSYS_LOCK_SYNC();
+ if (volume_value == NULL) {
+ control->allocated = 0;
+ control->handle_amp = 0;
+ }
+ control->volume_value[AVSYS_AUDIO_LVOL_GAIN_TYPE_0] = lvolume[0]; /* DEFAULT_VOLUME_SYSTEM */
+ control->volume_value[AVSYS_AUDIO_LVOL_GAIN_TYPE_1] = lvolume[1]; /* DEFAULT_VOLUME_NOTIFICATION */
+ control->volume_value[AVSYS_AUDIO_LVOL_GAIN_TYPE_2] = lvolume[2]; /* DEFAULT_VOLUME_ALARM */
+ control->volume_value[AVSYS_AUDIO_LVOL_GAIN_TYPE_3] = lvolume[3]; /* DEFAULT_VOLUME_RINGTONE */
+ control->volume_value[AVSYS_AUDIO_LVOL_GAIN_TYPE_4] = lvolume[4]; /* DEFAULT_VOLUME_MEDIA */
+ control->volume_value[AVSYS_AUDIO_LVOL_GAIN_TYPE_5] = lvolume[5]; /* DEFAULT_VOLUME_CALL */
+ control->volume_value[AVSYS_AUDIO_LVOL_GAIN_TYPE_6] = lvolume[6]; /* DEFAULT_VOLUME_FIXED */
+ control->volume_value[AVSYS_AUDIO_LVOL_GAIN_TYPE_7] = lvolume[7]; /* DEFAULT_VOLUME_JAVA */
+ control->volume_value[AVSYS_AUDIO_LVOL_GAIN_TYPE_8] = lvolume[4]; /* DEFAULT_VOLUME_MEDIA */
+ control->ext_device_amp = AVSYS_AUDIO_HANDLE_EXT_DEV_NONE;
+ control->primary_volume_pid = 0;
+ control->primary_volume_type = -1;
+ for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
+ control->handle_priority[i] = AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0;
+ }
+ /* Clear semaphore condition */
+ for (i = 0; i < AVSYS_AUDIO_LOCK_SLOT_MAX; i++) {
+ control->handlelock_pid[i] = -1;
+ }
+
+ AVSYS_UNLOCK_SYNC();
+
+ return AVSYS_STATE_SUCCESS;
+}
+
+EXPORT_API
+int avsys_audio_handle_rejuvenation(void)
+{
+ int i = 0;
+ long long int flag = 0x01;
+ int dead_handle = 0x00;
+
+ avsys_audio_handle_info_t *control = NULL;
+ avsys_audio_handle_info_t **temp = NULL;
+ int dead_pids[AVSYS_AUDIO_HANDLE_MAX];
+
+ temp = &control;
+
+ AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
+ if (control == NULL) {
+ avsys_error(AVAUDIO, "control is null in %s\n", __func__);
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ }
+
+ AVSYS_LOCK_SYNC();
+
+ /* Clear semaphore condition */
+
+ for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
+ dead_pids[i] = -1;
+ if (control->allocated & (flag << i)) { /* allocated condition */
+ /* check pid of handle... still alive? */
+ if (AVSYS_FAIL(avsys_check_process(control->handles[i].pid))) {
+ avsys_error(AVAUDIO, "handle %d is dead\n", i);
+ dead_handle |= (flag << i);
+ dead_pids[i] = control->handles[i].pid;
+ }
+ }
+ }
+
+ AVSYS_UNLOCK_SYNC();
+
+ avsys_warning(AVAUDIO, "dead_handle : 0x%0X\n", dead_handle);
+ /* Cleanup dead handle... */
+ for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
+ if (dead_handle & (flag << i)) {
+ /* set priority of dead handle as lowest */
+ control->handle_priority[i] = AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0;
+ /* free this handle */
+ avsys_error(AVAUDIO, "Cleanup handle %d...\n", i);
+ if (AVSYS_FAIL(avsys_audio_handle_free(i)))
+ avsys_error(AVAUDIO, "Cleanup handle %d failed\n", i);
+ }
+ }
+ if (dead_handle) {
+ char high_priority_exist = 0;
+ AVSYS_LOCK_SYNC();
+ for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
+ if (control->handle_priority[i] > AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0) {
+ high_priority_exist = 1;
+ break;
+ }
+ }
+
+ for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
+ if (control->handle_priority[i] == AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0) {
+ if (high_priority_exist) {
+ /* sink input mute immediately */
+ if (control->handles[i].mute == AVSYS_AUDIO_UNMUTE) {
+ if (AVSYS_FAIL(avsys_audio_pa_ctrl_mute_by_index(control->handles[i].stream_index, AVSYS_AUDIO_MUTE))) {
+ avsys_error(AVAUDIO, "set sink input mute for %d failed\n", control->handles[i].stream_index);
+ } else {
+ avsys_warning(AVAUDIO, "set sink input mute for %d success\n", control->handles[i].stream_index);
+ }
+ control->handles[i].mute = AVSYS_AUDIO_MUTE;
+ }
+ } else {
+ /* sink input unmute immediately */
+ if (control->handles[i].mute == AVSYS_AUDIO_MUTE) {
+ if (AVSYS_FAIL(avsys_audio_pa_ctrl_mute_by_index(control->handles[i].stream_index, AVSYS_AUDIO_UNMUTE))) {
+ avsys_error(AVAUDIO, "set sink input unmute for %d failed\n", control->handles[i].stream_index);
+ } else {
+ avsys_warning(AVAUDIO, "set sink input unmute for %d success\n", control->handles[i].stream_index);
+ }
+ control->handles[i].mute = AVSYS_AUDIO_UNMUTE;
+ }
+ }
+
+ } else { /* this is high priority case */
+ /* sink input unmute immediately */
+ if (control->handles[i].mute == AVSYS_AUDIO_MUTE) {
+ if (AVSYS_FAIL(avsys_audio_pa_ctrl_mute_by_index(control->handles[i].stream_index, AVSYS_AUDIO_UNMUTE))) {
+ avsys_error(AVAUDIO, "set sink input unmute for %d failed\n", control->handles[i].stream_index);
+ } else {
+ avsys_warning(AVAUDIO, "set sink input unmute for %d success\n", control->handles[i].stream_index);
+ }
+ control->handles[i].mute = AVSYS_AUDIO_UNMUTE;
+ }
+ }
+ }
+
+ AVSYS_UNLOCK_SYNC();
+ }
+
+ return AVSYS_STATE_SUCCESS;
+}
+
+EXPORT_API
+int avsys_audio_handle_dump(void)
+{
+ avsys_audio_handle_info_t *control = NULL;
+ avsys_audio_handle_info_t **temp = NULL;
+ char *vol_str[] = { "System", "Notification", "Alarm", "Ringtone", "Media", "Call", "Fixed", "Java", "Media-HL" };
+ char *dev_str[] = { "Speaker", "Headset", "BTHeadset" };
+ int i = 0;
+ long long int flag = 0x01;
+
+ temp = &control;
+ AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
+ if (control == NULL) {
+ avsys_error(AVAUDIO, "control is null in %s\n", __func__);
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ }
+
+ fprintf(stdout, "======================================================================\n");
+ fprintf(stdout, " Opened Handles Information \n");
+ fprintf(stdout, "======================================================================\n");
+ fprintf(stdout, " Avsystem Handle alloc : %016x\n", control->allocated);
+ for (i = 0; i < AVSYS_AUDIO_LOCK_SLOT_MAX; i++) {
+ if (control->handlelock_pid[i] > 0) {
+ fprintf(stdout, " Handle Lock PIDs : %d\n", control->handlelock_pid[i]);
+ }
+ }
+ fprintf(stdout, "----------------------------------------------------------------------\n");
+ for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
+ if (control->allocated & (flag << i)) { /* allocated condition */
+ fprintf(stdout, " Avsystem Handle ID : %2d\n", i);
+ fprintf(stdout, " Run Process ID : 0x%08X (%d)\n", control->handles[i].pid, control->handles[i].pid);
+ fprintf(stdout, " Run Thread ID : 0x%08X (%d)\n", control->handles[i].tid, control->handles[i].tid);
+ fprintf(stdout, " Open Mode : %2d\n", control->handles[i].mode);
+ fprintf(stdout, " Format : %2d\n", control->handles[i].format);
+ fprintf(stdout, " Channels : %2d\n", control->handles[i].channels);
+ fprintf(stdout, " Samplerate : %2d\n", control->handles[i].samplerate);
+ fprintf(stdout, " Priority : %2d\n", control->handle_priority[i]);
+ if(control->handles[i].mode == AVSYS_AUDIO_MODE_OUTPUT || control->handles[i].mode == AVSYS_AUDIO_MODE_OUTPUT_CLOCK ||
+ control->handles[i].mode == AVSYS_AUDIO_MODE_OUTPUT_VIDEO || control->handles[i].mode == AVSYS_AUDIO_MODE_OUTPUT_LOW_LATENCY
+ || control->handles[i].mode == AVSYS_AUDIO_MODE_OUTPUT_AP_CALL) {
+ if (control->handles[i].dirty_volume) {
+ fprintf(stdout, " Dirty volume : %s\n", vol_str[control->handles[i].gain_setting.vol_type]);
+ } else {
+ fprintf(stdout, " Volume Type : %s\n", vol_str[control->handles[i].gain_setting.vol_type]);
+ }
+ fprintf(stdout, " Target device : %s\n", dev_str[control->handles[i].gain_setting.dev_type]);
+ fprintf(stdout, " Maximum Len : %2d\n", control->handles[i].gain_setting.max_len);
+ fprintf(stdout, " UI setted volume : L:%3d R:%3d\n", control->handles[i].setting_vol.level[0], control->handles[i].setting_vol.level[1]);
+ fprintf(stdout, " Real working volume : L:%3d R:%3d\n", control->handles[i].working_vol.level[0], control->handles[i].working_vol.level[1]);
+ }
+ fprintf(stdout, " ----------------------------------------------------------------------\n");
+ }
+ }
+
+ fprintf(stdout, " ----------------------------------------------------------------------\n");
+ fprintf(stdout, " External dev amp : 0x%08X\n", control->ext_device_amp);
+ fprintf(stdout, " External dev status : 0x%08X\n", control->ext_device_status);
+ if (control->primary_volume_type >= 0) {
+ fprintf(stdout, " Primary Volume type : %s\n", vol_str[control->primary_volume_type]);
+ }
+ fprintf(stdout, " Volume [System] : %2d ", control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_SYSTEM]);
+ for (i = 0; i < control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_SYSTEM]; i++)
+ fprintf(stdout, "+");
+ fprintf(stdout, "\n");
+ fprintf(stdout, " Volume [Notification] : %2d ", control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_NOTIFICATION]);
+ for (i = 0; i < control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_NOTIFICATION]; i++)
+ fprintf(stdout, "+");
+ fprintf(stdout, "\n");
+ fprintf(stdout, " Volume [Alarm] : %2d ", control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_ALARM]);
+ for (i = 0; i < control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_ALARM]; i++)
+ fprintf(stdout, "+");
+ fprintf(stdout, "\n");
+ fprintf(stdout, " Volume [Ringtone] : %2d ", control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_RINGTONE]);
+ for (i = 0; i < control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_RINGTONE]; i++)
+ fprintf(stdout, "+");
+ fprintf(stdout, "\n");
+ fprintf(stdout, " Volume [Media] : %2d ", control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_MEDIA]);
+ for (i = 0; i < control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_MEDIA]; i++)
+ fprintf(stdout, "+");
+ fprintf(stdout, "\n");
+ fprintf(stdout, " Volume [MediaHL] : %2d ", control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_MEDIA_HL]);
+ for (i = 0; i < control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_MEDIA_HL]; i++)
+ fprintf(stdout, "+");
+ fprintf(stdout, "\n");
+ fprintf(stdout, " Volume [Call] : %2d ", control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_CALL]);
+ for (i = 0; i < control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_CALL]; i++)
+ fprintf(stdout, "+");
+ fprintf(stdout, "\n");
+ fprintf(stdout, " Volume [Android] : %2d ", control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_ANDROID]);
+ for (i = 0; i < control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_ANDROID]; i++)
+ fprintf(stdout, "+");
+ fprintf(stdout, "\n");
+ fprintf(stdout, " Volume [Java] : %2d ", control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_JAVA]);
+ for (i = 0; i < control->volume_value[AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_JAVA]; i++)
+ fprintf(stdout, "+");
+ fprintf(stdout, "\n");
+ fprintf(stdout, "======================================================================\n");
+
+ return AVSYS_STATE_SUCCESS;
+}
+
+int avsys_audio_handle_alloc(int *handle)
+{
+ long long int flag = 0x01;
+ int i;
+ avsys_audio_handle_info_t *control = NULL;
+ avsys_audio_handle_info_t **temp = NULL;
+ temp = &control;
+
+ avsys_info(AVAUDIO, "%s\n", __func__);
+ AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
+
+ AVSYS_LOCK_SYNC();
+ for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
+ if ((control->allocated & flag) == 0) { /* alloc condition */
+ control->allocated |= flag;
+ break;
+ } else {
+ flag <<= 1;
+ }
+ }
+
+ AVSYS_UNLOCK_SYNC();
+
+ if (i == AVSYS_AUDIO_HANDLE_MAX) {
+ *handle = -1;
+ return AVSYS_STATE_ERR_RANGE_OVER;
+ } else {
+ avsys_info(AVAUDIO, "handle allocated %d\n", i);
+ memset(&control->handles[i], 0, sizeof(avsys_audio_handle_t));
+ control->handles[i].pid = getpid();
+ control->handles[i].tid = avsys_gettid();
+ *handle = i;
+ return AVSYS_STATE_SUCCESS;
+ }
+}
+
+int avsys_audio_handle_free(int handle)
+{
+ long long int flag = 0x01;
+ avsys_audio_handle_info_t *control = NULL;
+ avsys_audio_handle_info_t **temp = NULL;
+ temp = &control;
+
+ avsys_info(AVAUDIO, "%s, handle=[%d]\n", __func__, handle);
+
+ AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
+
+ flag <<= handle;
+
+ AVSYS_LOCK_SYNC();
+ if (control->allocated & flag) { /* find condition */
+ control->allocated &= ~flag;
+ /* clear handle mute field */
+ if (control->handle_amp & flag) {
+ control->handle_amp &= ~flag;
+ }
+ AVSYS_UNLOCK_SYNC();
+ return AVSYS_STATE_SUCCESS;
+ } else {
+ AVSYS_UNLOCK_SYNC();
+ return AVSYS_STATE_ERR_INVALID_VALUE;
+ }
+}
+
+int avsys_audio_handle_get_ptr(int handle, avsys_audio_handle_t **ptr, const int mode)
+{
+ long long int flag = 0x01;
+ avsys_audio_handle_info_t *control = NULL;
+ avsys_audio_handle_info_t **temp = NULL;
+ int ret = AVSYS_STATE_SUCCESS;
+
+ //avsys_info(AVAUDIO, "%s handle %d\n", __func__, handle);
+
+ if (handle < 0 || handle >= AVSYS_AUDIO_HANDLE_MAX) {
+ *ptr = NULL;
+ return AVSYS_STATE_ERR_INVALID_HANDLE;
+ }
+
+ if (mode < 0 || mode >= HANDLE_PTR_MODE_NUM) {
+ *ptr = NULL;
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ }
+
+ temp = &control;
+ if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_HANDLE, (void **)temp))) {
+ avsys_error(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
+ *ptr = NULL;
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ flag <<= handle;
+
+ if (mode == HANDLE_PTR_MODE_NORMAL) {
+ if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_HANDLE))) {
+ avsys_error(AVAUDIO, "avsys_audio_lock_sync() failed in %s\n", __func__);
+ *ptr = NULL;
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+ }
+
+ if (control->allocated & flag) {
+ //avsys_info(AVAUDIO, "input handle %d flag %x allocated %x\n", handle, flag, control->allocated);
+ *ptr = &(control->handles[handle]);
+ ret = AVSYS_STATE_SUCCESS;
+ } else {
+ *ptr = NULL;
+ ret = AVSYS_STATE_ERR_INVALID_VALUE;
+ }
+
+ if (mode == HANDLE_PTR_MODE_NORMAL) {
+ if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_HANDLE))) {
+ avsys_error(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
+ *ptr = NULL;
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+ }
+
+ return ret;
+}
+
+int avsys_audio_handle_release_ptr(int handle, const int mode)
+{
+ long long int flag = 0x01;
+ avsys_audio_handle_info_t *control = NULL;
+ avsys_audio_handle_info_t **temp = NULL;
+ int ret = AVSYS_STATE_SUCCESS;
+
+ //avsys_info(AVAUDIO, "%s handle %d\n", __func__, handle);
+
+ if (handle < 0 || handle >= AVSYS_AUDIO_HANDLE_MAX) {
+ return AVSYS_STATE_ERR_INVALID_HANDLE;
+ }
+
+ if (mode < 0 || mode >= HANDLE_PTR_MODE_NUM) {
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ }
+
+ temp = &control;
+ AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
+
+ flag <<= handle;
+
+ //avsys_info(AVAUDIO, "input handle %d flag %x allocated %x\n", handle, flag, control->allocated);
+ if (mode == HANDLE_PTR_MODE_NORMAL) {
+ AVSYS_LOCK_SYNC();
+ }
+
+ if (control->allocated & flag) {
+ ret = AVSYS_STATE_SUCCESS;
+ } else {
+ ret = AVSYS_STATE_ERR_INVALID_VALUE;
+ }
+
+ if (mode == HANDLE_PTR_MODE_NORMAL) {
+ AVSYS_UNLOCK_SYNC();
+ }
+
+ return ret;
+}
+
+int avsys_audio_handle_set_mute(int handle, int mute)
+{
+ long long int flag = 0x01;
+ int result = AVSYS_STATE_SUCCESS;
+ int path_mute = 0;
+ avsys_audio_handle_info_t *control = NULL;
+ avsys_audio_handle_info_t **temp = NULL;
+ avsys_audio_handle_t *ptr = NULL;
+ temp = &control;
+
+ avsys_info(AVAUDIO, "%s_%d_%d\n", __func__, handle, mute);
+ if (mute > AVSYS_AUDIO_MUTE || mute < AVSYS_AUDIO_UNMUTE) {
+ avsys_error_r(AVAUDIO, "input parameter range error : mute %d\n", mute);
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ }
+
+ AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
+
+ flag <<= handle;
+
+ AVSYS_LOCK_SYNC();
+
+ if (control->allocated & flag) { /* find condition */
+ /* update mute information for input handle parameter */
+ ptr = &(control->handles[handle]);
+ ptr->mute = mute;
+ avsys_audio_pa_ctrl_mute_by_index(ptr->stream_index, mute);
+
+ /* update handle amp information */
+ if (mute == AVSYS_AUDIO_UNMUTE) {
+#ifdef _VERBOSE_
+ if (control->handle_amp & flag)
+ avsys_warning(AVAUDIO, "handle 0x%x already powered\n");
+ else
+ control->handle_amp |= flag;
+#else
+ if (!(control->handle_amp & flag))
+ control->handle_amp |= flag;
+
+ /* reset fadedown mute */
+ ptr->fadeup_vol = 0;
+#endif
+ } else if (mute == AVSYS_AUDIO_MUTE) {
+ /* clear handle amp field */
+ if (control->handle_amp & flag)
+ control->handle_amp &= ~flag;
+#ifdef _VERBOSE_
+ else
+ avsys_warning(AVAUDIO, "handle 0x%x already off\n");
+#endif
+ }
+
+ result = AVSYS_STATE_SUCCESS;
+ } else {
+ avsys_warning(AVAUDIO, "[%s] handle %d does not allocated\n", __func__, handle);
+ if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_HANDLE))) {
+ avsys_error(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+ return AVSYS_STATE_ERR_INVALID_VALUE;
+ }
+
+ if (control->handle_amp | control->ext_device_amp)
+ path_mute = AVSYS_AUDIO_UNMUTE;
+ else
+ path_mute = AVSYS_AUDIO_MUTE;
+
+ AVSYS_UNLOCK_SYNC();
+
+ if (AVSYS_FAIL(avsys_audio_path_ex_set_mute(path_mute))) {
+ avsys_error_r(AVAUDIO, "Path mute control failed. %s_%d\n", __func__, path_mute);
+ result = AVSYS_STATE_ERR_IO_CONTROL;
+ }
+ return result;
+}
+
+int avsys_audio_handle_ext_dev_set_mute(avsysaudio_ext_device_t device_type, int mute)
+{
+ int bit = 0;
+ int result = AVSYS_STATE_SUCCESS;
+ int path_mute = 0;
+ avsys_audio_handle_info_t *control = NULL;
+ avsys_audio_handle_info_t **temp = NULL;
+ temp = &control;
+
+ avsys_info(AVAUDIO, "%s_%d_%d\n", __func__, (int)device_type, mute);
+ if (mute > AVSYS_AUDIO_MUTE || mute < AVSYS_AUDIO_UNMUTE) {
+ avsys_error_r(AVAUDIO, "input parameter range error : mute %d\n", mute);
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ }
+
+ switch (device_type) {
+ case AVSYS_AUDIO_EXT_DEVICE_FMRADIO:
+ bit = AVSYS_AUDIO_HANDLE_EXT_DEV_FMRADIO;
+ break;
+ default:
+ avsys_error(AVAUDIO, "Unknown device type %d\n", (int)device_type);
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ }
+
+ AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
+
+ AVSYS_LOCK_SYNC();
+
+ if (mute == AVSYS_AUDIO_MUTE) {
+ control->ext_device_amp |= bit;
+ } else {
+ control->ext_device_amp &= ~bit;
+ }
+
+ if (control->handle_amp | control->ext_device_amp)
+ path_mute = AVSYS_AUDIO_UNMUTE;
+ else
+ path_mute = AVSYS_AUDIO_MUTE;
+
+ AVSYS_UNLOCK_SYNC();
+
+ if (AVSYS_FAIL(avsys_audio_path_ex_set_mute(path_mute))) {
+ avsys_error_r(AVAUDIO, "Path mute control failed. %s_%d\n", __func__, path_mute);
+ result = AVSYS_STATE_ERR_IO_CONTROL;
+ }
+ return result;
+}
+
+int avsys_audio_handle_ext_dev_status(avsysaudio_ext_device_t device_type, int *onoff)
+{
+ int result = AVSYS_STATE_SUCCESS;
+ int ext_dev_state = 0;
+
+ avsys_audio_handle_info_t *control = NULL;
+ avsys_audio_handle_info_t **temp = NULL;
+ temp = &control;
+
+ avsys_info(AVAUDIO, "%s\n", __func__);
+
+ if (onoff == NULL) {
+ avsys_error(AVAUDIO, "Null pointer input parameter\n");
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ }
+
+ AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
+
+ AVSYS_LOCK_SYNC();
+
+ switch (device_type) {
+ case AVSYS_AUDIO_EXT_DEVICE_FMRADIO:
+ if (control->ext_device_status & AVSYS_AUDIO_HANDLE_EXT_DEV_FMRADIO) {
+ ext_dev_state = 1;
+ } else {
+ ext_dev_state = 0;
+ }
+ *onoff = ext_dev_state;
+ break;
+ default:
+ avsys_error(AVAUDIO, "Invalid device type %d\n", device_type);
+ result = AVSYS_STATE_ERR_INTERNAL;
+ break;
+ }
+
+ AVSYS_UNLOCK_SYNC();
+ return result;
+}
+
+int avsys_audio_handle_ext_dev_status_update(avsysaudio_ext_device_t device_type, int onoff)
+{
+ int bit = 0;
+ int result = AVSYS_STATE_SUCCESS;
+ avsys_audio_handle_info_t *control = NULL;
+ avsys_audio_handle_info_t **temp = NULL;
+ temp = &control;
+
+ avsys_info(AVAUDIO, "%s_%d_%d\n", __func__, (int)device_type, onoff);
+
+ switch (device_type) {
+ case AVSYS_AUDIO_EXT_DEVICE_FMRADIO:
+ bit = AVSYS_AUDIO_HANDLE_EXT_DEV_FMRADIO;
+ break;
+ default:
+ avsys_error(AVAUDIO, "Unknown device type %d\n", (int)device_type);
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ }
+
+ AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
+
+ AVSYS_LOCK_SYNC();
+
+ if (onoff > 0) {
+ control->ext_device_status |= bit;
+ } else if (onoff == 0) {
+ control->ext_device_status &= ~bit;
+ } else {
+ avsys_error(AVAUDIO, "[%s] Unknown parameter %d. To nothing\n", __func__, onoff);
+ }
+
+ AVSYS_UNLOCK_SYNC();
+ return result;
+}
+
+int avsys_audio_handle_current_playing_volume_type(int *type)
+{
+ int result = AVSYS_STATE_SUCCESS;
+ int i = 0;
+ char used_table[AVSYS_AUDIO_VOLUME_TYPE_MAX] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+ char capture_used = 0;
+ avsys_audio_handle_info_t *control = NULL;
+ avsys_audio_handle_info_t **temp = NULL;
+ temp = &control;
+
+ AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
+
+ AVSYS_LOCK_SYNC();
+
+ for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
+ long long int flag = 0x01;
+ flag <<= i;
+ if (control->allocated & flag) {
+ if(control->handles[i].mode == AVSYS_AUDIO_MODE_OUTPUT ||
+ control->handles[i].mode == AVSYS_AUDIO_MODE_OUTPUT_CLOCK ||
+ control->handles[i].mode == AVSYS_AUDIO_MODE_OUTPUT_VIDEO ||
+ control->handles[i].mode == AVSYS_AUDIO_MODE_OUTPUT_LOW_LATENCY ) {
+ used_table[control->handles[i].gain_setting.vol_type] = 1;
+ }
+ else if(control->handles[i].mode == AVSYS_AUDIO_MODE_INPUT ||
+ control->handles[i].mode == AVSYS_AUDIO_MODE_INPUT_HIGH_LATENCY ||
+ control->handles[i].mode == AVSYS_AUDIO_MODE_INPUT_LOW_LATENCY) {
+ capture_used = 1;
+ }
+ }
+ }
+ if (control->ext_device_status & AVSYS_AUDIO_HANDLE_EXT_DEV_FMRADIO) {
+ used_table[AVSYS_AUDIO_VOLUME_TYPE_MEDIA] = 1;
+ }
+
+ avsys_warning(AVAUDIO,"Call[%d] Ringtone[%d] Media[%d] MediaHL[%d] Alarm[%d] Notification[%d] System[%d] Android[%d] Java[%d] Capture[%d]\n",
+ used_table[AVSYS_AUDIO_VOLUME_TYPE_CALL],
+ used_table[AVSYS_AUDIO_VOLUME_TYPE_RINGTONE],
+ used_table[AVSYS_AUDIO_VOLUME_TYPE_MEDIA],
+ used_table[AVSYS_AUDIO_VOLUME_TYPE_MEDIA_HL],
+ used_table[AVSYS_AUDIO_VOLUME_TYPE_ALARM],
+ used_table[AVSYS_AUDIO_VOLUME_TYPE_NOTIFICATION],
+ used_table[AVSYS_AUDIO_VOLUME_TYPE_SYSTEM],
+ used_table[AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_ANDROID],
+ used_table[AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_JAVA],
+ capture_used);
+
+ if (control->primary_volume_pid > 2 && AVSYS_FAIL(avsys_check_process(control->primary_volume_pid))) {
+ avsys_warning(AVAUDIO, "Primary volume set pid does not exist anymore. clean primary volume\n");
+ control->primary_volume_type = 1;
+ control->primary_volume_pid = 0;
+ }
+
+ if (control->primary_volume_type != -1) {
+ *type = control->primary_volume_type;
+ avsys_warning(AVAUDIO, "Primary volume is %d\n", control->primary_volume_type);
+ } else if (used_table[AVSYS_AUDIO_VOLUME_TYPE_CALL]) {
+ *type = AVSYS_AUDIO_VOLUME_TYPE_CALL;
+ } else if (used_table[AVSYS_AUDIO_VOLUME_TYPE_RINGTONE]) {
+ *type = AVSYS_AUDIO_VOLUME_TYPE_RINGTONE;
+ } else if (used_table[AVSYS_AUDIO_VOLUME_TYPE_MEDIA]) {
+ *type = AVSYS_AUDIO_VOLUME_TYPE_MEDIA;
+ } else if (used_table[AVSYS_AUDIO_VOLUME_TYPE_MEDIA_HL]) {
+ *type = AVSYS_AUDIO_VOLUME_TYPE_MEDIA;
+ } else if (used_table[AVSYS_AUDIO_VOLUME_TYPE_ALARM]) {
+ *type = AVSYS_AUDIO_VOLUME_TYPE_ALARM;
+ } else if (used_table[AVSYS_AUDIO_VOLUME_TYPE_NOTIFICATION]) {
+ *type = AVSYS_AUDIO_VOLUME_TYPE_NOTIFICATION;
+ } else if (used_table[AVSYS_AUDIO_VOLUME_TYPE_SYSTEM]) {
+ *type = AVSYS_AUDIO_VOLUME_TYPE_SYSTEM;
+ } else if (used_table[AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_JAVA]) {
+ *type = AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_JAVA;
+ } else if (capture_used) {
+ /* No Playing instance just capture only. */
+ result = AVSYS_STATE_ERR_INVALID_MODE;
+ avsys_error(AVAUDIO, "Capture handle only...\n");
+ } else {
+ /* not playing */
+ result = AVSYS_STATE_ERR_ALLOCATION;
+ avsys_error(AVAUDIO, "There is no running handles...\n");
+ }
+
+ AVSYS_UNLOCK_SYNC();
+
+ return result;
+}
+
+
+int avsys_audio_handle_update_volume(avsys_audio_handle_t *p, const int vol_type)
+{
+ int result = AVSYS_STATE_SUCCESS;
+ avsys_audio_handle_info_t *control = NULL;
+ avsys_audio_handle_info_t **temp = NULL;
+ temp = &control;
+
+ avsys_audio_volume_t *set_volume = NULL;
+ int volume_type = vol_type;
+
+ AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
+
+ AVSYS_LOCK_SYNC();
+
+ set_volume = &(p->setting_vol);
+ set_volume->level[AVSYS_AUDIO_CHANNEL_LEFT] = control->volume_value[volume_type];
+ set_volume->level[AVSYS_AUDIO_CHANNEL_RIGHT] = control->volume_value[volume_type];
+ result = avsys_audio_logical_volume_convert(set_volume, &(p->working_vol), &(p->gain_setting));
+
+ AVSYS_UNLOCK_SYNC();
+
+ return result;
+}
+
+int avsys_audio_handle_update_volume_by_type(const int volume_type, const int volume_value)
+{
+ int i;
+ int result = AVSYS_STATE_SUCCESS;
+ avsys_audio_handle_info_t *control = NULL;
+ avsys_audio_handle_info_t **temp = NULL;
+ temp = &control;
+
+ avsys_info(AVAUDIO, "%s\n", __func__);
+ AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
+
+ AVSYS_LOCK_SYNC();
+
+ control->volume_value[volume_type] = volume_value;
+
+ for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
+ int mode;
+ avsys_audio_volume_t *set_volume = NULL;
+ long long int flag = 0x01;
+ flag <<= i;
+
+ if ((control->allocated & flag) == 0) {
+ continue;
+ }
+ mode = control->handles[i].mode;
+ if (mode != AVSYS_AUDIO_MODE_OUTPUT && mode != AVSYS_AUDIO_MODE_OUTPUT_CLOCK
+ && mode != AVSYS_AUDIO_MODE_OUTPUT_VIDEO && mode != AVSYS_AUDIO_MODE_OUTPUT_LOW_LATENCY
+ && mode != AVSYS_AUDIO_MODE_OUTPUT_AP_CALL) {
+ continue;
+ }
+
+ if (control->handles[i].gain_setting.vol_type != volume_type) {
+ continue;
+ }
+
+ if (control->handles[i].dirty_volume) {
+ /* This is volatile volume per handle */
+ continue;
+ }
+
+ set_volume = &(control->handles[i].setting_vol);
+ set_volume->level[AVSYS_AUDIO_CHANNEL_LEFT] = control->volume_value[volume_type];
+ set_volume->level[AVSYS_AUDIO_CHANNEL_RIGHT] = control->volume_value[volume_type];
+ result = avsys_audio_logical_volume_convert(set_volume, &(control->handles[i].working_vol), &(control->handles[i].gain_setting));
+ if (AVSYS_FAIL(result)) {
+ avsys_error(AVAUDIO, "Can not set volume for handle %d. Error 0x%x\n", i, result);
+ break;
+ }
+ avsys_warning(AVAUDIO, "stream index %d\n", control->handles[i].stream_index);
+ 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))) {
+ avsys_error(AVAUDIO, "avsys_audio_pa_ctrl_volume_by_index() failed\n");
+ }
+ }
+
+ AVSYS_UNLOCK_SYNC();
+
+ return result;
+}
+
+int avsys_audio_handle_set_primary_volume_type(const int pid, const int type, const int command)
+{
+ int result = AVSYS_STATE_SUCCESS;
+ avsys_audio_handle_info_t *control = NULL;
+ avsys_audio_handle_info_t **temp = NULL;
+ temp = &control;
+
+ avsys_info(AVAUDIO, "%s\n", __func__);
+ if (type < AVSYS_AUDIO_VOLUME_TYPE_SYSTEM || type >= AVSYS_AUDIO_VOLUME_TYPE_MAX || type == AVSYS_AUDIO_VOLUME_TYPE_FIXED) {
+ avsys_error(AVAUDIO, "Invalid primary type primary type\n");
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
+
+ AVSYS_LOCK_SYNC();
+
+ if (command == AVSYS_AUDIO_PRIMARY_VOLUME_SET) {
+ if (control->primary_volume_type != -1) {
+ avsys_warning(AVAUDIO,"Previous primary volume set by %d to %d\n",
+ control->primary_volume_pid,
+ control->primary_volume_type
+ );
+ }
+ avsys_warning(AVAUDIO, "Primary Volume Type Set to %d [%d]\n", type, pid);
+ control->primary_volume_pid = pid;
+ control->primary_volume_type = type;
+ } else if (command == AVSYS_AUDIO_PRIMARY_VOLUME_CLEAR) {
+ if (pid != control->primary_volume_pid) {
+ avsys_error(AVAUDIO, "Primary volume set api pair is not matched [%d] [%d]\n", control->primary_volume_pid, pid);
+ } else {
+ avsys_warning(AVAUDIO, "Primary Volume Type Clear [%d]\n", pid);
+ control->primary_volume_pid = 0;
+ control->primary_volume_type = -1;
+ }
+ } else {
+ avsys_error(AVAUDIO, "Unknown Parameter : %d\n", command);
+ result = AVSYS_STATE_ERR_INVALID_PARAMETER;
+ }
+
+ AVSYS_UNLOCK_SYNC();
+
+ return result;
+}
+
+int avsys_audio_handle_update_priority(int handle, int priority, int handle_route, int cmd)
+{
+ long long int flag = 0x01;
+ int path_mute = 0, i = 0;
+ char high_priority_exist = 0;
+ char transition_effect = 0;
+ int lpriority = AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0;
+ avsys_audio_handle_info_t *control = NULL;
+ avsys_audio_handle_info_t **temp = NULL;
+ int sink_info = 0;
+
+ temp = &control;
+
+ if (cmd < AVSYS_AUDIO_SET_PRIORITY || cmd > AVSYS_AUDIO_UNSET_PRIORITY) {
+ avsys_error_r(AVAUDIO, "Invalid command %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ if (priority >= AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_MAX || priority < AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0) {
+ avsys_error(AVAUDIO, "input parameter range error : priority %d. set lowest\n", priority);
+ lpriority = AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0;
+ } else {
+ lpriority = priority;
+ }
+
+ AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
+
+ flag <<= handle;
+
+ AVSYS_LOCK_SYNC();
+
+ if (control->allocated & flag) { /* find condition */
+ /* update for allocated handle */
+ if (cmd == AVSYS_AUDIO_SET_PRIORITY) {
+ control->handle_priority[handle] = lpriority;
+ } else if (cmd == AVSYS_AUDIO_UNSET_PRIORITY) {
+ control->handle_priority[handle] = AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0;
+ if (lpriority == AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_2) { /* unset with priority 2 */
+ transition_effect = 1;
+ }
+ }
+ } else {
+ avsys_warning(AVAUDIO, "[%s] handle %d does not allocated\n", __func__, handle);
+ AVSYS_UNLOCK_SYNC();
+ return AVSYS_STATE_ERR_INVALID_VALUE;
+ }
+
+ for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
+ if (control->handle_priority[i] == AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_1) {
+ high_priority_exist = 1;
+ } else if (control->handle_priority[i] == AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_2) {
+ high_priority_exist = 1;
+ transition_effect = 1;
+ }
+ }
+
+ for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
+ flag = 0x01;
+ flag <<= i;
+ if (!(control->allocated & flag))
+ continue;
+
+ if (control->handles[i].stream_index == 0) {
+ avsys_warning(AVAUDIO, "handle[%d] has stream index 0, skip....(only mono sink-input use 0)\n", i);
+ continue;
+ }
+
+ if (control->handle_priority[i] == AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0) {
+
+ if (high_priority_exist) { /* mute */
+ if (transition_effect) {
+ /* set fade out */
+ if (control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT] >= control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT]) {
+ control->handles[i].fadeup_vol = (-1) * control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT];
+ } else {
+ control->handles[i].fadeup_vol = (-1) * control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT];
+ }
+ control->handles[i].fadeup_multiplier = 0;
+ } else {
+ /* mute immediately */
+ if (AVSYS_FAIL(avsys_audio_pa_ctrl_mute_by_index(control->handles[i].stream_index, AVSYS_AUDIO_MUTE))) {
+ avsys_error(AVAUDIO, "set sink input mute for %d failed\n", control->handles[i].stream_index);
+ } else {
+ avsys_warning(AVAUDIO, "set sink input mute for %d success\n", control->handles[i].stream_index);
+ }
+ control->handles[i].mute = AVSYS_AUDIO_MUTE;
+ }
+ } else { /* unmute */
+ if (transition_effect) {
+ /* set fade in */
+ if (control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT] >= control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT]) {
+ control->handles[i].fadeup_vol = control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT];
+ } else {
+ control->handles[i].fadeup_vol = control->handles[i].setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT];
+ }
+ control->handles[i].fadeup_multiplier = 0;
+ } else {
+ /* unmute immediately */
+ if (control->handles[i].mute != AVSYS_AUDIO_UNMUTE) {
+ if (AVSYS_FAIL(avsys_audio_pa_ctrl_mute_by_index(control->handles[i].stream_index, AVSYS_AUDIO_UNMUTE))) {
+ avsys_error(AVAUDIO, "set sink input unmute for %d failed\n", control->handles[i].stream_index);
+ } else {
+ avsys_warning(AVAUDIO, "set sink input unmute for %d success\n", control->handles[i].stream_index);
+ }
+ control->handles[i].mute = AVSYS_AUDIO_UNMUTE;
+ }
+ }
+ }
+ }
+ }
+
+ AVSYS_UNLOCK_SYNC();
+
+ if (transition_effect)
+ sleep(1);
+ else if (!transition_effect && high_priority_exist)
+ usleep(20);
+
+ return AVSYS_STATE_SUCCESS;
+}
+
+int avsys_audio_handle_current_capture_status(int *on_capture)
+{
+ int i = 0;
+ char capture_used = 0;
+ avsys_audio_handle_info_t *control = NULL;
+ avsys_audio_handle_info_t **temp = NULL;
+
+ if (!on_capture)
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+
+ temp = &control;
+
+ AVSYS_GET_SHM(temp,AVSYS_STATE_ERR_INTERNAL);
+
+ AVSYS_LOCK_SYNC();
+
+ for (i = 0; i < AVSYS_AUDIO_HANDLE_MAX; i++) {
+ long long int flag = 0x01;
+ flag <<= i;
+ if (control->allocated & flag) {
+ if(control->handles[i].mode == AVSYS_AUDIO_MODE_INPUT ||
+ control->handles[i].mode == AVSYS_AUDIO_MODE_INPUT_HIGH_LATENCY ||
+ control->handles[i].mode == AVSYS_AUDIO_MODE_INPUT_LOW_LATENCY ||
+ control->handles[i].mode == AVSYS_AUDIO_MODE_INPUT_AP_CALL) {
+ capture_used = 1;
+ break;
+ }
+ }
+ }
+ if (capture_used) {
+ avsys_info(AVAUDIO, "Audio capture is running\n");
+ *on_capture = 1;
+ } else {
+ *on_capture = 0;
+ }
+
+ AVSYS_UNLOCK_SYNC();
+
+ return AVSYS_STATE_SUCCESS;
+}
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <signal.h>
+
+#include "include/avsys-error.h"
+#include "include/avsys-debug.h"
+
+#include "include/avsys-audio-handle.h"
+#include "include/avsys-audio-path.h"
+#include "include/avsys-audio-logical-volume.h"
+
+#define OP_NONE -1
+#define OP_USAGE 0
+#define OP_INIT 1
+#define OP_UNINIT 2
+#define OP_RESET 3
+#define OP_DUMP 4
+#define OP_DAEMON 5
+#define OP_AMP 6
+#define OP_SHUTDOWN 8
+#define OP_REJUVE 9
+
+static int usage(int argc, char *argv[]);
+static int get_options(int argc, char *argv[]);
+
+int main(int argc, char *argv[])
+{
+ int operation = OP_NONE;
+ int result = 0;
+ int mute = 1;
+ pid_t pid;
+ mode_t old_umask = 0;
+
+ static char *str_errormsg[] = {
+ "Operation is success.",
+ "Handle Init Fail",
+ "Path Init Fail",
+ "Handle Fini Fail",
+ "Path Fini Fail",
+ "Handle Reset Fail",
+ "Path Reset Fail",
+ "Handle Dump Fail",
+ "Path Dump Fail",
+ "Global Mute Fail",
+ "Handle Rejuvenation Fail",
+ "Vconf Get Value Fail",
+ "Sync Dump Fail",
+ };
+
+ operation = get_options(argc, argv);
+
+ switch (operation) {
+ case OP_INIT:
+ old_umask = umask(0);
+ fprintf(stderr, "old umask was [%o]\n", old_umask);
+ result = avsys_audio_handle_init();
+ if (AVSYS_FAIL(result)) {
+ result = 1;
+ umask(old_umask);
+ fprintf(stderr, "set umask to old value\n");
+ break;
+ }
+ result = avsys_audio_path_ex_init();
+ if (AVSYS_FAIL(result)) {
+ result = 2;
+ umask(old_umask);
+ fprintf(stderr, "set umask to old value\n");
+ break;
+ }
+ result = avsys_audio_logical_volume_init();
+ if (AVSYS_FAIL(result)) {
+ result = 2;
+ umask(old_umask);
+ fprintf(stderr, "set umask to old value\n");
+ break;
+ }
+ umask(old_umask);
+ fprintf(stderr, "set umask to old value\n");
+ break;
+
+ case OP_UNINIT:
+ result = avsys_audio_handle_fini();
+ if (AVSYS_FAIL(result)) {
+ result = 3;
+ break;
+ }
+
+ result = avsys_audio_path_ex_fini();
+ if (AVSYS_FAIL(result)) {
+ result = 4;
+ break;
+ }
+ break;
+ case OP_RESET:
+ result = avsys_audio_handle_reset(NULL);
+ if (AVSYS_FAIL(result)) {
+ result = 5;
+ break;
+ }
+
+ result = avsys_audio_path_ex_reset(0);
+ if (AVSYS_FAIL(result)) {
+ result = 6;
+ break;
+ }
+ break;
+ case OP_DUMP:
+ result = avsys_audio_handle_dump();
+ if (AVSYS_FAIL(result)) {
+ result = 7;
+ break;
+ }
+ result = avsys_audio_path_ex_dump();
+ if (AVSYS_FAIL(result)) {
+ result = 8;
+ break;
+ }
+
+ result = avsys_audio_dump_sync();
+ if (AVSYS_FAIL(result)) {
+ result = 12;
+ break;
+ }
+ break;
+ case OP_DAEMON:
+ result = 0;
+ break;
+ case OP_USAGE:
+ break;
+ case OP_SHUTDOWN:
+ result = avsys_audio_path_ex_set_mute(mute);
+ if (AVSYS_FAIL(result)) {
+ result = 9;
+ }
+ break;
+ case OP_REJUVE:
+ result = avsys_audio_handle_rejuvenation();
+ if (AVSYS_FAIL(result)) {
+ result = 10;
+ }
+ break;
+ default:
+ fprintf(stderr, "Unknown operation\n");
+ break;
+ }
+
+ if (result != 0) {
+ fprintf(stderr, "%s\n", str_errormsg[result]);
+ return 1;
+ } else
+ return 0;
+}
+
+static int get_options(int argc, char *argv[])
+{
+ int ch = 0;
+ int operation = OP_NONE;
+
+ if (argc != 2)
+ return usage(argc, argv);
+
+ while ((ch = getopt(argc, argv, "iurtdmjhap")) != EOF) {
+ switch (ch) {
+ case 'i':
+ if (operation != OP_NONE)
+ return usage(argc, argv);
+ operation = OP_INIT;
+ break;
+ case 'u':
+ if (operation != OP_NONE)
+ return usage(argc, argv);
+ operation = OP_UNINIT;
+ break;
+ case 'r':
+ if (operation != OP_NONE)
+ return usage(argc, argv);
+ operation = OP_RESET;
+ break;
+ case 'd':
+ if (operation != OP_NONE)
+ return usage(argc, argv);
+ operation = OP_DUMP;
+ break;
+ case 'h':
+ if (operation != OP_NONE)
+ return usage(argc, argv);
+ operation = OP_DAEMON;
+ break;
+ case 'm':
+ if (operation != OP_NONE)
+ return usage(argc, argv);
+ operation = OP_SHUTDOWN;
+ break;
+ case 'j':
+ if (operation != OP_NONE)
+ return usage(argc, argv);
+ operation = OP_REJUVE;
+ break;
+ default:
+ return usage(argc, argv);
+ }
+ if (optind != argc)
+ return usage(argc, argv);
+ }
+ return operation;
+}
+
+static int usage(int argc, char *argv[])
+{
+ fprintf(stderr, "Usage : %s option\n", argv[0]);
+ fprintf(stderr, "[OPTIONS]\n");
+ fprintf(stderr, " -i : Initialize audio system\n");
+ fprintf(stderr, " -u : Uninitialize audio system\n");
+ fprintf(stderr, " -r : Reset audio system\n");
+ fprintf(stderr, " -d : Dump audio system\n");
+ fprintf(stderr, " -m : Global mute\n");
+ fprintf(stderr, " -j : Handle rejuvenation\n");
+ return OP_USAGE;
+}
+
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "avsys-audio-logical-volume.h"
+#include "avsys-audio-shm.h"
+#include "avsys-error.h"
+#include "avsys-debug.h"
+
+/* {TYPE, {MAXLEN, {MAXLEN, SPK{L,R}...}, {MAXLEN, RECV {L,R}...}, {MAXLEN, HEADSET{L,R}...}, {MAXLEN, BT{L,R}...}}} */
+static const avsys_logical_gain_t g_volume_table[AVSYS_AUDIO_LVOL_GAIN_TYPE_MAX] = {
+ { AVSYS_AUDIO_LVOL_GAIN_TYPE_0, /* system : 0~15, default : 5 */
+ { /* FNT DEFAULT */
+ {LVOLUME_MAX_MULTIMEDIA, {{{0,0}}, {{19000,19000}}, {{22323,22323}}, {{25647,25647}}, {{28971,28971}}, {{32295,32295}}, {{35619,35619}}, {{38943,38943}}, {{42267,42267}}, {{45591,45591}}, {{48915,48915}}, {{52239,52239}}, {{55563,55563}}, {{58887,58887}}, {{62211,62211}}, {{65535,65535}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_SPK */
+ {LVOLUME_MAX_MULTIMEDIA, {{{0,0}}, {{20480,20480}}, {{23698,23698}}, {{26916,26916}}, {{30135,30135}}, {{33353,33353}}, {{36571,36571}}, {{39789,39789}}, {{43008,43008}}, {{46226,46226}}, {{49444,49444}}, {{52662,52662}}, {{55880,55880}}, {{59099,59099}}, {{62317,62317}}, {{65535,65535}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET0 */
+ {LVOLUME_MAX_MULTIMEDIA, {{{0,0}}, {{20480,20480}}, {{23698,23698}}, {{26916,26916}}, {{30135,30135}}, {{33353,33353}}, {{36571,36571}}, {{39789,39789}}, {{43008,43008}}, {{46226,46226}}, {{49444,49444}}, {{52662,52662}}, {{55880,55880}}, {{59099,59099}}, {{62317,62317}}, {{65535,65535}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_BTHEADSET */
+ },
+ },
+ { AVSYS_AUDIO_LVOL_GAIN_TYPE_1, /* notification : 0~15, default : 7 */
+ { /* FNT DEFAULT */
+ {LVOLUME_MAX_MULTIMEDIA, {{{0,0}}, {{19000,19000}}, {{22323,22323}}, {{25647,25647}}, {{28971,28971}}, {{32295,32295}}, {{35619,35619}}, {{38943,38943}}, {{42267,42267}}, {{45591,45591}}, {{48915,48915}}, {{52239,52239}}, {{55563,55563}}, {{58887,58887}}, {{62211,62211}}, {{65535,65535}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_SPK */
+ {LVOLUME_MAX_MULTIMEDIA, {{{0,0}}, {{20480,20480}}, {{23698,23698}}, {{26916,26916}}, {{30135,30135}}, {{33353,33353}}, {{36571,36571}}, {{39789,39789}}, {{43008,43008}}, {{46226,46226}}, {{49444,49444}}, {{52662,52662}}, {{55880,55880}}, {{59099,59099}}, {{62317,62317}}, {{65535,65535}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET0 */
+ {LVOLUME_MAX_MULTIMEDIA, {{{0,0}}, {{20480,20480}}, {{23698,23698}}, {{26916,26916}}, {{30135,30135}}, {{33353,33353}}, {{36571,36571}}, {{39789,39789}}, {{43008,43008}}, {{46226,46226}}, {{49444,49444}}, {{52662,52662}}, {{55880,55880}}, {{59099,59099}}, {{62317,62317}}, {{65535,65535}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_BTHEADSET */
+ },
+ },
+ { AVSYS_AUDIO_LVOL_GAIN_TYPE_2, /* alarm */
+ { /* FNT DEFAULT */
+ {LVOLUME_MAX_BASIC, {{{0,0}}, {{19000,19000}}, {{25991,25991}}, {{32982,32982}}, {{39973,39973}}, {{46964,46964}}, {{53955,53955}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_SPK */
+ {LVOLUME_MAX_BASIC, {{{0,0}}, {{20480,20480}}, {{27225,27225}}, {{33969,33969}}, {{40714,40714}}, {{47458,47458}}, {{54203,54203}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET0 */
+ {LVOLUME_MAX_BASIC, {{{0,0}}, {{20480,20480}}, {{27225,27225}}, {{33969,33969}}, {{40714,40714}}, {{47458,47458}}, {{54203,54203}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_BTHEADSET */
+ },
+ },
+ { AVSYS_AUDIO_LVOL_GAIN_TYPE_3, /* ringtone : 0~15, default : 13 */
+ { /* FNT DEFAULT */
+ {LVOLUME_MAX_MULTIMEDIA, {{{0,0}}, {{19000,19000}}, {{22323,22323}}, {{25647,25647}}, {{28971,28971}}, {{32295,32295}}, {{35619,35619}}, {{38943,38943}}, {{42267,42267}}, {{45591,45591}}, {{48915,48915}}, {{52239,52239}}, {{55563,55563}}, {{58887,58887}}, {{62211,62211}}, {{65535,65535}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_SPK */
+ {LVOLUME_MAX_MULTIMEDIA, {{{0,0}}, {{20480,20480}}, {{23698,23698}}, {{26916,26916}}, {{30135,30135}}, {{33353,33353}}, {{36571,36571}}, {{39789,39789}}, {{43008,43008}}, {{46226,46226}}, {{49444,49444}}, {{52662,52662}}, {{55880,55880}}, {{59099,59099}}, {{62317,62317}}, {{65535,65535}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET0 */
+ {LVOLUME_MAX_MULTIMEDIA, {{{0,0}}, {{20480,20480}}, {{23698,23698}}, {{26916,26916}}, {{30135,30135}}, {{33353,33353}}, {{36571,36571}}, {{39789,39789}}, {{43008,43008}}, {{46226,46226}}, {{49444,49444}}, {{52662,52662}}, {{55880,55880}}, {{59099,59099}}, {{62317,62317}}, {{65535,65535}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_BTHEADSET */
+ },
+ },
+ { AVSYS_AUDIO_LVOL_GAIN_TYPE_4, /* media */
+ { /* FNT DEFAULT */
+ {LVOLUME_MAX_MULTIMEDIA, {{{0,0}}, {{19000,19000}}, {{22323,22323}}, {{25647,25647}}, {{28971,28971}}, {{32295,32295}}, {{35619,35619}}, {{38943,38943}}, {{42267,42267}}, {{45591,45591}}, {{48915,48915}}, {{52239,52239}}, {{55563,55563}}, {{58887,58887}}, {{62211,62211}}, {{65535,65535}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_SPK */
+ {LVOLUME_MAX_MULTIMEDIA, {{{0,0}}, {{20480,20480}}, {{23698,23698}}, {{26916,26916}}, {{30135,30135}}, {{33353,33353}}, {{36571,36571}}, {{39789,39789}}, {{43008,43008}}, {{46226,46226}}, {{49444,49444}}, {{52662,52662}}, {{55880,55880}}, {{59099,59099}}, {{62317,62317}}, {{65535,65535}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET0 */
+ {LVOLUME_MAX_MULTIMEDIA, {{{0,0}}, {{20480,20480}}, {{23698,23698}}, {{26916,26916}}, {{30135,30135}}, {{33353,33353}}, {{36571,36571}}, {{39789,39789}}, {{43008,43008}}, {{46226,46226}}, {{49444,49444}}, {{52662,52662}}, {{55880,55880}}, {{59099,59099}}, {{62317,62317}}, {{65535,65535}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_BTHEADSET */
+ },
+ },
+ { AVSYS_AUDIO_LVOL_GAIN_TYPE_5, /* call */
+ { /* FNT DEFAULT */
+ {LVOLUME_MAX_BASIC, {{{0,0}}, {{19000,19000}}, {{25991,25991}}, {{32982,32982}}, {{39973,39973}}, {{46964,46964}}, {{53955,53955}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_SPK */
+ {LVOLUME_MAX_BASIC, {{{0,0}}, {{20480,20480}}, {{27225,27225}}, {{33969,33969}}, {{40714,40714}}, {{47458,47458}}, {{54203,54203}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET0 */
+ {LVOLUME_MAX_BASIC, {{{0,0}}, {{20480,20480}}, {{27225,27225}}, {{33969,33969}}, {{40714,40714}}, {{47458,47458}}, {{54203,54203}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}, {{60947,60947}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_BTHEADSET */
+ },
+ },
+ { AVSYS_AUDIO_LVOL_GAIN_TYPE_6, /* fixed */
+ { /* FNT DEFAULT */
+ {LVOLUME_MAX_SINGLE, {{{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_SPK */
+ {LVOLUME_MAX_SINGLE, {{{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET0 */
+ {LVOLUME_MAX_SINGLE, {{{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}, {{65535,65535}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_BTHEADSET */
+ },
+ },
+ { AVSYS_AUDIO_LVOL_GAIN_TYPE_7, /* java */
+ { /* FNT DEFAULT */
+ {LVOLUME_MAX_MULTIMEDIA, {{{0,0}}, {{19000,19000}}, {{22323,22323}}, {{25647,25647}}, {{28971,28971}}, {{32295,32295}}, {{35619,35619}}, {{38943,38943}}, {{42267,42267}}, {{45591,45591}}, {{48915,48915}}, {{52239,52239}}, {{55563,55563}}, {{58887,58887}}, {{62211,62211}}, {{65535,65535}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_SPK */
+ {LVOLUME_MAX_MULTIMEDIA, {{{0,0}}, {{20480,20480}}, {{23698,23698}}, {{26916,26916}}, {{30135,30135}}, {{33353,33353}}, {{36571,36571}}, {{39789,39789}}, {{43008,43008}}, {{46226,46226}}, {{49444,49444}}, {{52662,52662}}, {{55880,55880}}, {{59099,59099}}, {{62317,62317}}, {{65535,65535}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET0 */
+ {LVOLUME_MAX_MULTIMEDIA, {{{0,0}}, {{20480,20480}}, {{23698,23698}}, {{26916,26916}}, {{30135,30135}}, {{33353,33353}}, {{36571,36571}}, {{39789,39789}}, {{43008,43008}}, {{46226,46226}}, {{49444,49444}}, {{52662,52662}}, {{55880,55880}}, {{59099,59099}}, {{62317,62317}}, {{65535,65535}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_BTHEADSET */
+ },
+ },
+ { AVSYS_AUDIO_LVOL_GAIN_TYPE_8, /* music only (max level) */
+ { /* FNT DEFAULT */
+ {LVOLUME_MAX_MULTIMEDIA, {{{0,0}}, {{19000,19000}}, {{22323,22323}}, {{25647,25647}}, {{28971,28971}}, {{32295,32295}}, {{35619,35619}}, {{38943,38943}}, {{42267,42267}}, {{45591,45591}}, {{48915,48915}}, {{52239,52239}}, {{55563,55563}}, {{58887,58887}}, {{62211,62211}}, {{65535,65535}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_SPK */
+ {LVOLUME_MAX_MULTIMEDIA, {{{0,0}}, {{20480,20480}}, {{23698,23698}}, {{26916,26916}}, {{30135,30135}}, {{33353,33353}}, {{36571,36571}}, {{39789,39789}}, {{43008,43008}}, {{46226,46226}}, {{49444,49444}}, {{52662,52662}}, {{55880,55880}}, {{59099,59099}}, {{62317,62317}}, {{65535,65535}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET0 */
+ {LVOLUME_MAX_MULTIMEDIA, {{{0,0}}, {{20480,20480}}, {{23698,23698}}, {{26916,26916}}, {{30135,30135}}, {{33353,33353}}, {{36571,36571}}, {{39789,39789}}, {{43008,43008}}, {{46226,46226}}, {{49444,49444}}, {{52662,52662}}, {{55880,55880}}, {{59099,59099}}, {{62317,62317}}, {{65535,65535}}}}, /* AVSYS_AUDIO_LVOL_DEV_TYPE_BTHEADSET */
+ },
+ },
+};
+
+int avsys_audio_logical_volume_get_max(int vol_type, int dev_type, int *max)
+{
+ void **data = NULL;
+ avsys_logical_gain_t *table = NULL;
+ data = (void **)&table;
+ if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_LVOLUME, data))) {
+ avsys_error(AVAUDIO, "attach shared memory failed\n");
+ return AVSYS_STATE_ERR_ALLOCATION;
+ }
+
+ if (vol_type < 0 || vol_type >= AVSYS_AUDIO_LVOL_GAIN_TYPE_MAX ||
+ dev_type < 0 || dev_type >= AVSYS_AUDIO_LVOL_DEV_TYPE_MAX ||
+ max == NULL) {
+ avsys_error(AVAUDIO, "Input param wrong. Please check params\n\t type %d\n\tdevicetype %d\n",
+ vol_type, dev_type);
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ }
+
+ *max = table[vol_type].devices[dev_type].max_len;
+ return AVSYS_STATE_SUCCESS;
+}
+
+int avsys_audio_logical_volume_set_table(int vol_type, int dev_type, avsys_audio_volume_setting_t *setting)
+{
+ void **data = NULL;
+ avsys_logical_gain_t *table = NULL;
+ data = (void**)&table;
+ if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_LVOLUME, data))) {
+ avsys_error(AVAUDIO, "attach shared memory failed\n");
+ return AVSYS_STATE_ERR_ALLOCATION;
+ }
+
+ avsys_info(AVAUDIO, "Set Logical gain table\n");
+ avsys_info(AVAUDIO, "\t vol_type %d dev_type %d\n", vol_type, dev_type);
+
+ if (setting == NULL) {
+ avsys_error(AVAUDIO, "setting is null in %s\n", __func__);
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ }
+
+ /* Change ">" -> ">=" for CRASH LOGGER */
+ if ((vol_type < 0 || vol_type >= AVSYS_AUDIO_LVOL_GAIN_TYPE_MAX) ||
+ (dev_type < 0 || dev_type >= AVSYS_AUDIO_LVOL_DEV_TYPE_MAX)) {
+ avsys_error(AVAUDIO, "Input param wrong. Please check params\n\ttype %d\n\tdevicetype %d\n",
+ vol_type, dev_type);
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ }
+
+ if (table[vol_type].type != vol_type) {
+ avsys_error(AVAUDIO, "volume type does not match (%d, %d)in %s\n", table[vol_type].type, vol_type, __func__);
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ }
+
+ setting->vol_type = vol_type;
+ setting->dev_type = dev_type;
+ setting->max_len = table[vol_type].devices[dev_type].max_len;
+ setting->table = (avsys_audio_volume_t *)(((int)table[vol_type].devices[dev_type].gain) - (int)table);
+
+ avsys_info(AVAUDIO, "vol %d, dev%d table setted.\n", vol_type, dev_type);
+ return AVSYS_STATE_SUCCESS;
+}
+
+int avsys_audio_logical_volume_update_table(int dev_type, avsys_audio_volume_setting_t *setting)
+{
+ void **data = NULL;
+ avsys_logical_gain_t *table = NULL;
+ data = (void **)&table;
+ if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_LVOLUME, data))) {
+ avsys_error(AVAUDIO, "attach shared memory failed\n");
+ return AVSYS_STATE_ERR_ALLOCATION;
+ }
+
+ avsys_info(AVAUDIO, "Update Logical gain table\n");
+ avsys_info(AVAUDIO, "\t dev_type %d\n", dev_type);
+
+ if (setting == NULL) {
+ avsys_error(AVAUDIO, "setting is null in %s\n", __func__);
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ }
+ if (table[setting->vol_type].type != setting->vol_type) {
+ avsys_error(AVAUDIO, "volume type does not match in %s\n", __func__);
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ }
+
+ if (dev_type < 0 || dev_type >= AVSYS_AUDIO_LVOL_DEV_TYPE_MAX) {
+ avsys_error(AVAUDIO, "Input param wrong. Please check params\tdevicetype %d\n", dev_type);
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ }
+ setting->dev_type = dev_type;
+ setting->max_len = table[setting->vol_type].devices[dev_type].max_len;
+ setting->table = (avsys_audio_volume_t *)(((int)table[setting->vol_type].devices[dev_type].gain) - (int)table);
+ return AVSYS_STATE_SUCCESS;
+}
+
+int avsys_audio_logical_volume_convert(avsys_audio_volume_t *level, avsys_audio_volume_t *converted, avsys_audio_volume_setting_t *setting)
+{
+ void **data = NULL;
+ avsys_logical_gain_t *table = NULL;
+ data = (void **)&table;
+ if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_LVOLUME, data))) {
+ avsys_error(AVAUDIO, "attach shared memory failed\n");
+ return AVSYS_STATE_ERR_ALLOCATION;
+ }
+
+ if (level == NULL) {
+ avsys_error(AVAUDIO, "level is null in %s\n", __func__);
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ }
+ if (level->level[AVSYS_AUDIO_CHANNEL_LEFT] < 0) {
+ avsys_error(AVAUDIO, "negative volume level (left) in %s : %d\n", __func__, level->level[AVSYS_AUDIO_CHANNEL_LEFT]);
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ }
+ if (level->level[AVSYS_AUDIO_CHANNEL_RIGHT] < 0) {
+ avsys_error(AVAUDIO, "negative volume level (right) in %s : %d\n", __func__, level->level[AVSYS_AUDIO_CHANNEL_RIGHT]);
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ }
+
+ if (setting->max_len <= level->level[AVSYS_AUDIO_CHANNEL_LEFT] ||
+ setting->max_len <= level->level[AVSYS_AUDIO_CHANNEL_RIGHT] ||
+ 0 > level->level[AVSYS_AUDIO_CHANNEL_LEFT] ||
+ 0 > level->level[AVSYS_AUDIO_CHANNEL_RIGHT])
+ {
+ avsys_error(AVAUDIO, "Input param wrong. Please check params\n\t level %d %d\n", level->level[AVSYS_AUDIO_CHANNEL_LEFT], level->level[AVSYS_AUDIO_CHANNEL_RIGHT]);
+
+ return AVSYS_STATE_ERR_INVALID_VALUE;
+ }
+
+ converted->level[AVSYS_AUDIO_CHANNEL_LEFT] = ((avsys_audio_volume_t *)((int)table + (int)setting->table))[level->level[AVSYS_AUDIO_CHANNEL_LEFT]].level[AVSYS_AUDIO_CHANNEL_LEFT];
+ converted->level[AVSYS_AUDIO_CHANNEL_RIGHT] = ((avsys_audio_volume_t *)((int)table + (int)setting->table))[level->level[AVSYS_AUDIO_CHANNEL_RIGHT]].level[AVSYS_AUDIO_CHANNEL_RIGHT];
+
+ avsys_warning(AVAUDIO, "Volume converted vol_type %d dev_type %d\n", setting->vol_type, setting->dev_type);
+ avsys_warning(AVAUDIO, "\tL: %d to %d\n", level->level[AVSYS_AUDIO_CHANNEL_LEFT], converted->level[AVSYS_AUDIO_CHANNEL_LEFT]);
+ avsys_warning(AVAUDIO, "\tR: %d to %d\n", level->level[AVSYS_AUDIO_CHANNEL_RIGHT], converted->level[AVSYS_AUDIO_CHANNEL_RIGHT]);
+
+ return AVSYS_STATE_SUCCESS;
+}
+
+int avsys_audio_logical_volume_init(void)
+{
+ void *data = NULL;
+ avsys_audio_create_shm(AVSYS_AUDIO_SHM_IDEN_LVOLUME);
+ if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_LVOLUME, &data))) {
+ avsys_error(AVAUDIO, "attach shared memory failed\n");
+ return AVSYS_STATE_ERR_ALLOCATION;
+ }
+ memcpy(data, g_volume_table, sizeof(avsys_logical_gain_t) * AVSYS_AUDIO_LVOL_GAIN_TYPE_MAX);
+ if (AVSYS_FAIL(avsys_audio_load_volume_from_file())) {
+ avsys_error(AVAUDIO, "Loading volume table from file failed. use default table\n");
+ }
+ return AVSYS_STATE_SUCCESS;
+}
+
+int avsys_audio_logical_volume_set_to_table(int gain_type, int dev_type, int step, int lv, int rv)
+{
+ void **data = NULL;
+ avsys_logical_gain_t *table = NULL;
+ data = (void **)&table;
+ if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_LVOLUME, data))) {
+ avsys_error(AVAUDIO, "attach shared memory failed\n");
+ return AVSYS_STATE_ERR_ALLOCATION;
+ }
+
+ table[gain_type].devices[dev_type].gain[step].level[0] = lv;
+ table[gain_type].devices[dev_type].gain[step].level[1] = rv;
+ return AVSYS_STATE_SUCCESS;
+}
+
+int avsys_audio_logical_volume_get_from_table(int gain_type, int dev_type, int step, int *lv, int *rv)
+{
+ void **data = NULL;
+ avsys_logical_gain_t *table = NULL;
+ data = (void **)&table;
+ if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_LVOLUME, data))) {
+ avsys_error(AVAUDIO, "attach shared memory failed\n");
+ return AVSYS_STATE_ERR_ALLOCATION;
+ }
+
+ *lv = table[gain_type].devices[dev_type].gain[step].level[0];
+ *rv = table[gain_type].devices[dev_type].gain[step].level[1];
+ return AVSYS_STATE_SUCCESS;
+}
+
+int avsys_audio_load_volume_from_file()
+{
+ FILE *fp = NULL;
+ int result = AVSYS_STATE_SUCCESS;
+ char strBuffer[128];
+
+ fp = fopen(VOLUME_FILE_PATH, "r");
+ if (fp == NULL) {
+ printf("Loading volume table from file failed\n");
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ memset(strBuffer, '\0', sizeof(strBuffer));
+ while (fgets(strBuffer, sizeof(strBuffer), fp) != NULL) {
+ char *pEnd = NULL;
+ char *pStart = NULL;
+ int volumetable = 0;
+ int device = 0;
+ int level = 0;
+ int lvalue = 0, rvalue = 0;
+ char parseBuf[10] = "";
+
+ /* remove newline */
+ if (strBuffer[strlen(strBuffer) - 1] == '\n')
+ strBuffer[strlen(strBuffer) - 1] = '\0';
+ if (strBuffer[strlen(strBuffer) - 1] == '\r')
+ strBuffer[strlen(strBuffer) - 1] = '\0';
+ if (strBuffer[0] == '#')
+ continue;
+
+ pStart = strBuffer;
+ pEnd = strstr(pStart, ":");
+ if (pEnd) {
+ memset(parseBuf, '\0', sizeof(parseBuf));
+ memcpy(parseBuf, pStart, pEnd - pStart);
+ volumetable = atoi(parseBuf);
+ } else {
+ result = AVSYS_STATE_ERR_INTERNAL;
+ break;
+ }
+
+ pStart = ++pEnd;
+ pEnd = strstr(pStart, ":");
+ if (pEnd) {
+ memset(parseBuf, '\0', sizeof(parseBuf));
+ memcpy(parseBuf, pStart, pEnd - pStart);
+ if (strcmp(parseBuf, "SPK") == 0)
+ device = 0;
+ else if (strcmp(parseBuf, "HEADSET") == 0)
+ device = 1;
+ else if (strcmp(parseBuf, "BTHEADSET") == 0)
+ device = 2;
+ } else {
+ result = AVSYS_STATE_ERR_INTERNAL;
+ break;
+ }
+
+ pStart = ++pEnd;
+ pEnd = strstr(pStart, ":");
+ if (pEnd) {
+ memset(parseBuf, '\0', sizeof(parseBuf));
+ memcpy(parseBuf, pStart, pEnd - pStart);
+ level = atoi(parseBuf);
+ } else {
+ result = AVSYS_STATE_ERR_INTERNAL;
+ break;
+ }
+
+ pStart = ++pEnd;
+ if (pEnd) {
+ pEnd = strstr(pStart, ":");
+ memset(parseBuf, '\0', sizeof(parseBuf));
+ memcpy(parseBuf, pStart, pEnd - pStart);
+ lvalue = atoi(parseBuf);
+ } else {
+ result = AVSYS_STATE_ERR_INTERNAL;
+ break;
+ }
+
+ pStart = ++pEnd;
+ rvalue = atoi(pStart);
+ avsys_audio_set_volume_table(volumetable, device, level, lvalue, rvalue);
+ }
+ fclose(fp);
+ //avsys_info(AVAUDIO,"Load volume table from file success\n");
+ return result;
+}
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <string.h>
+#include <stdio.h>
+
+#include "avsys-audio-pactrl.h"
+#include "avsys-debug.h"
+
+enum {
+ AVSYS_PA_CTL_CMD_VOLUME,
+ AVSYS_PA_CTL_CMD_MUTE,
+ AVSYS_PA_CTL_CMD_GET_SINK_INFO,
+ AVSYS_PA_CTL_CMD_GET_DEFAULT_SINK,
+ AVSYS_PA_CTL_CMD_MAX,
+};
+
+typedef struct avsys_pa_ctrl_info {
+ pa_threaded_mainloop *m;
+ int cmd;
+ int mute;
+ int idx;
+ int vol;
+ int ch;
+ int res;
+} avsys_pa_ctrl_info_t;
+
+static void __avsys_audio_pa_ctrl_success_cb(pa_context *c, int success, void *userdata)
+{
+ pa_threaded_mainloop *mainloop = (pa_threaded_mainloop *)userdata;
+ avsys_assert_r(c);
+ avsys_assert_r(mainloop);
+
+ if (!success) {
+ avsys_error(AVAUDIO, "pa control failed\n");
+ } else {
+ avsys_info(AVAUDIO, "pa control success\n");
+ }
+ pa_threaded_mainloop_signal(mainloop, 0);
+}
+
+static void __avsys_audio_pa_ctrl_get_sink_info_cb(pa_context *c, const pa_sink_info *i, int is_last, void *userdata)
+{
+ avsys_pa_ctrl_info_t *info = NULL;
+ avsys_assert_r(userdata);
+ info = (avsys_pa_ctrl_info_t *)userdata;
+ int sink_state;
+ int sink_name;
+
+ if (is_last < 0) {
+ avsys_error(AVAUDIO, "Failed to get sink information: %s", pa_strerror(pa_context_errno(c)));
+ return;
+ }
+
+ if (is_last) {
+ pa_threaded_mainloop_signal(info->m, 0);
+ return;
+ }
+
+ avsys_assert_r(i);
+
+ if (!strncmp(i->name, "alsa_", 4)) {
+ sink_name = ALSA_SINK;
+ } else if (!strncmp(i->name, "bluez", 5)) {
+ sink_name = BLUEZ_SINK;
+ } else {
+ return;
+ }
+
+ switch (i->state) {
+ case PA_SINK_RUNNING:
+ sink_state = _ACTIVE;
+ break;
+ case PA_SINK_IDLE:
+ case PA_SINK_SUSPENDED:
+ sink_state = _DEACTIVE;
+ break;
+ default:
+ sink_state = _EXIST;
+ break;
+ }
+
+ info->res |= ((1 << (sink_state + sink_name)));
+}
+
+static void __avsys_audio_pa_ctrl_get_server_info_cb(pa_context *c, const pa_server_info *i, void *userdata)
+{
+ avsys_pa_ctrl_info_t *info = NULL;
+ avsys_assert_r(userdata);
+ info = (avsys_pa_ctrl_info_t *)userdata;
+
+ if (!i) {
+ info->res = AVSYS_AUDIO_PA_CTL_SINK_UNKNOWN;
+ } else {
+ if (strstr(i->default_sink_name, "alsa_"))
+ info->res = AVSYS_AUDIO_PA_CTL_SINK_ALSA;
+ else if (strstr(i->default_sink_name, "bluez"))
+ info->res = AVSYS_AUDIO_PA_CTL_SINK_BLUEZ;
+ else
+ info->res = AVSYS_AUDIO_PA_CTL_SINK_UNKNOWN;
+ }
+ pa_threaded_mainloop_signal(info->m, 0);
+}
+
+static void __avsys_audio_pa_ctrl_state_cb(pa_context *c, void *userdata)
+{
+ pa_cvolume cv;
+ avsys_pa_ctrl_info_t *info = NULL;
+
+ avsys_assert_r(c);
+ info = (avsys_pa_ctrl_info_t *)userdata;
+ avsys_assert_r(info);
+ avsys_assert_r(info->m);
+
+ switch (pa_context_get_state(c)) {
+ case PA_CONTEXT_READY:
+ if (info->cmd == AVSYS_PA_CTL_CMD_VOLUME) {
+ pa_cvolume_set(&cv, info->ch, info->vol);
+ pa_operation_unref(pa_context_set_sink_input_volume(c, info->idx, &cv, __avsys_audio_pa_ctrl_success_cb, (void *)info->m));
+ } else if (info->cmd == AVSYS_PA_CTL_CMD_MUTE) {
+ pa_operation_unref(pa_context_set_sink_input_mute(c, info->idx, info->mute, __avsys_audio_pa_ctrl_success_cb, (void *)info->m));
+ } else if (info->cmd == AVSYS_PA_CTL_CMD_GET_SINK_INFO) {
+ pa_operation_unref(pa_context_get_sink_info_list(c, __avsys_audio_pa_ctrl_get_sink_info_cb, (void *)info));
+ } else if (info->cmd == AVSYS_PA_CTL_CMD_GET_DEFAULT_SINK) {
+ pa_operation_unref(pa_context_get_server_info(c, __avsys_audio_pa_ctrl_get_server_info_cb, (void *)info));
+ }
+ break;
+ case PA_CONTEXT_TERMINATED:
+ case PA_CONTEXT_FAILED:
+ pa_threaded_mainloop_signal(info->m, 0);
+ break;
+
+ case PA_CONTEXT_UNCONNECTED:
+ case PA_CONTEXT_CONNECTING:
+ case PA_CONTEXT_AUTHORIZING:
+ case PA_CONTEXT_SETTING_NAME:
+ break;
+ }
+}
+
+int avsys_audio_pa_ctrl_volume_by_index(unsigned int idx, int volume, int ch)
+{
+ pa_threaded_mainloop *mainloop = NULL;
+ pa_context *context = NULL;
+ int error = PA_ERR_INTERNAL;
+ avsys_pa_ctrl_info_t *info = NULL;
+
+ if (volume < 0 || volume > 65535) {
+ avsys_error(AVAUDIO, "invalid volume value %d\n", volume);
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ }
+ if (ch < 0) {
+ avsys_error(AVAUDIO, "invalid channel value\n", ch);
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ }
+
+ if (!(mainloop = pa_threaded_mainloop_new()))
+ goto fail;
+
+ if (!(context = pa_context_new(pa_threaded_mainloop_get_api(mainloop), NULL)))
+ goto fail;
+
+ if (!(info = (avsys_pa_ctrl_info_t *)calloc(sizeof(avsys_pa_ctrl_info_t), 1)))
+ goto fail;
+
+ info->m = mainloop;
+ info->cmd = AVSYS_PA_CTL_CMD_VOLUME;
+ info->idx = idx;
+ info->vol = volume;
+ info->ch = ch;
+ pa_context_set_state_callback(context, __avsys_audio_pa_ctrl_state_cb, (void *)info);
+
+ if (pa_context_connect(context, NULL, 0, NULL) < 0) {
+ error = pa_context_errno(context);
+ goto fail;
+ }
+
+ pa_threaded_mainloop_lock(mainloop);
+
+ if (pa_threaded_mainloop_start(mainloop) < 0)
+ goto unlock_and_fail;
+
+ for (;;) {
+ pa_context_state_t state;
+
+ state = pa_context_get_state(context);
+
+ if (state == PA_CONTEXT_READY)
+ break;
+
+ if (!PA_CONTEXT_IS_GOOD(state)) {
+ error = pa_context_errno(context);
+ goto unlock_and_fail;
+ }
+
+ /* Wait until the context is ready */
+ pa_threaded_mainloop_wait(mainloop);
+ }
+
+ pa_threaded_mainloop_unlock(mainloop);
+
+ pa_threaded_mainloop_stop(mainloop);
+ pa_context_disconnect(context);
+ pa_context_unref(context);
+ pa_threaded_mainloop_free(mainloop);
+ free(info);
+
+ return AVSYS_STATE_SUCCESS; /* for success */
+
+unlock_and_fail:
+ pa_threaded_mainloop_unlock(mainloop);
+
+ if (mainloop)
+ pa_threaded_mainloop_stop(mainloop);
+
+ if (context)
+ pa_context_disconnect(context);
+
+fail:
+ avsys_error(AVAUDIO, "pa error : %s\n", pa_strerror(error));
+
+ if (context)
+ pa_context_unref(context);
+
+ if (mainloop)
+ pa_threaded_mainloop_free(mainloop);
+
+ if (info)
+ free(info);
+
+ return AVSYS_STATE_ERR_INTERNAL;
+}
+
+int avsys_audio_pa_ctrl_mute_by_index(unsigned int idx, int mute)
+{
+ pa_threaded_mainloop *mainloop = NULL;
+ pa_context *context = NULL;
+ int error = PA_ERR_INTERNAL;
+ avsys_pa_ctrl_info_t *info = NULL;
+
+ if (mute != AVSYS_AUDIO_MUTE && mute != AVSYS_AUDIO_UNMUTE) {
+ avsys_error(AVAUDIO, "invalid mute value %d\n", mute);
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ }
+
+ if (!(mainloop = pa_threaded_mainloop_new()))
+ goto fail;
+
+ if (!(context = pa_context_new(pa_threaded_mainloop_get_api(mainloop), NULL)))
+ goto fail;
+
+ if (!(info = (avsys_pa_ctrl_info_t *)calloc(sizeof(avsys_pa_ctrl_info_t), 1)))
+ goto fail;
+
+ info->m = mainloop;
+ info->cmd = AVSYS_PA_CTL_CMD_MUTE;
+ info->idx = idx;
+ info->mute = mute;
+
+ pa_context_set_state_callback(context, __avsys_audio_pa_ctrl_state_cb, (void *)info);
+
+ if (pa_context_connect(context, NULL, 0, NULL) < 0) {
+ error = pa_context_errno(context);
+ goto fail;
+ }
+
+ pa_threaded_mainloop_lock(mainloop);
+
+ if (pa_threaded_mainloop_start(mainloop) < 0)
+ goto unlock_and_fail;
+
+ for (;;) {
+ pa_context_state_t state;
+
+ state = pa_context_get_state(context);
+
+ if (state == PA_CONTEXT_READY)
+ break;
+
+ if (!PA_CONTEXT_IS_GOOD(state)) {
+ error = pa_context_errno(context);
+ goto unlock_and_fail;
+ }
+
+ /* Wait until the context is ready */
+ pa_threaded_mainloop_wait(mainloop);
+ }
+
+ pa_threaded_mainloop_unlock(mainloop);
+
+ pa_threaded_mainloop_stop(mainloop);
+ pa_context_disconnect(context);
+ pa_context_unref(context);
+ pa_threaded_mainloop_free(mainloop);
+ free(info);
+
+ return AVSYS_STATE_SUCCESS; /* for success */
+
+unlock_and_fail:
+ pa_threaded_mainloop_unlock(mainloop);
+
+ if (mainloop)
+ pa_threaded_mainloop_stop(mainloop);
+
+ if (context)
+ pa_context_disconnect(context);
+
+fail:
+ avsys_error(AVAUDIO, "pa error : %s\n", pa_strerror(error));
+
+ if (context)
+ pa_context_unref(context);
+
+ if (mainloop)
+ pa_threaded_mainloop_free(mainloop);
+
+ if (info)
+ free(info);
+
+ return AVSYS_STATE_ERR_INTERNAL;
+}
+
+int avsys_audio_pa_ctrl_get_default_sink(int *sink)
+{
+ pa_threaded_mainloop *mainloop = NULL;
+ pa_context *context = NULL;
+ int error = PA_ERR_INTERNAL;
+ avsys_pa_ctrl_info_t *info = NULL;
+
+ if (!sink)
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+
+ if (!(mainloop = pa_threaded_mainloop_new()))
+ goto fail;
+
+ if (!(context = pa_context_new(pa_threaded_mainloop_get_api(mainloop), NULL)))
+ goto fail;
+
+ if (!(info = (avsys_pa_ctrl_info_t *)calloc(sizeof(avsys_pa_ctrl_info_t), 1)))
+ goto fail;
+
+ info->m = mainloop;
+ info->cmd = AVSYS_PA_CTL_CMD_GET_DEFAULT_SINK;
+
+ pa_context_set_state_callback(context, __avsys_audio_pa_ctrl_state_cb, (void *)info);
+
+ if (pa_context_connect(context, NULL, 0, NULL) < 0) {
+ error = pa_context_errno(context);
+ goto fail;
+ }
+
+ pa_threaded_mainloop_lock(mainloop);
+
+ if (pa_threaded_mainloop_start(mainloop) < 0)
+ goto unlock_and_fail;
+
+ for (;;) {
+ pa_context_state_t state;
+
+ state = pa_context_get_state(context);
+
+ if (state == PA_CONTEXT_READY)
+ break;
+
+ if (!PA_CONTEXT_IS_GOOD(state)) {
+ error = pa_context_errno(context);
+ goto unlock_and_fail;
+ }
+
+ /* Wait until the context is ready */
+ pa_threaded_mainloop_wait(mainloop);
+ }
+
+ *sink = info->res;
+
+ pa_threaded_mainloop_unlock(mainloop);
+
+ pa_threaded_mainloop_stop(mainloop);
+ pa_context_disconnect(context);
+ pa_context_unref(context);
+ pa_threaded_mainloop_free(mainloop);
+ free(info);
+
+ return AVSYS_STATE_SUCCESS; /* for success */
+
+unlock_and_fail:
+ pa_threaded_mainloop_unlock(mainloop);
+
+ if (mainloop)
+ pa_threaded_mainloop_stop(mainloop);
+
+ if (context)
+ pa_context_disconnect(context);
+
+fail:
+ avsys_error(AVAUDIO, "pa error : %s\n", pa_strerror(error));
+
+ if (context)
+ pa_context_unref(context);
+
+ if (mainloop)
+ pa_threaded_mainloop_free(mainloop);
+
+ if (info)
+ free(info);
+
+ return AVSYS_STATE_ERR_INTERNAL;
+}
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "avsys-audio-pasimple.h"
+#include "avsys-types.h"
+#include "avsys-error.h"
+#include "avsys-debug.h"
+
+#define PA_SIMPLE_SAMPLES_PER_PERIOD_DEFAULT 1536 /* frames */
+#define PA_SIMPLE_PERIODS_PER_BUFFER_FASTMODE 4
+#define PA_SIMPLE_PERIODS_PER_BUFFER_DEFAULT 6
+#define PA_SIMPLE_PERIODS_PER_BUFFER_PLAYBACK 8
+#define PA_SIMPLE_PERIODS_PER_BUFFER_CAPTURE 12
+#define PA_SIMPLE_PERIODS_PER_BUFFER_VIDEO 10
+
+#define PA_SIMPLE_PERIOD_TIME_FOR_ULOW_LATENCY_MSEC 20
+#define PA_SIMPLE_PERIOD_TIME_FOR_LOW_LATENCY_MSEC 25
+#define PA_SIMPLE_PERIOD_TIME_FOR_MID_LATENCY_MSEC 50
+#define PA_SIMPLE_PERIOD_TIME_FOR_HIGH_LATENCY_MSEC 75
+
+#define MSEC_TO_SAMPLE(samplerate,period_time) (samplerate*period_time/1000)
+
+#define CHECK_VALID_HANDLE(handle) \
+do { \
+ if (handle == NULL) { \
+ return AVSYS_STATE_ERR_NULL_POINTER; \
+ } \
+ device = (avsys_audio_pasimple_handle_t *)handle->device; \
+ if (device == NULL) { \
+ return AVSYS_STATE_ERR_NULL_POINTER; \
+ } \
+ if (device->pasimple_handle == NULL) { \
+ return AVSYS_STATE_ERR_NULL_POINTER; \
+ } \
+} while (0)
+
+#define SET_PA_ATTR(pt,spp,ppb,pb,mr,tl,ml,fs) \
+do { \
+ period_time = pt; \
+ samples_per_period = spp; \
+ periods_per_buffer = ppb; \
+ attr.prebuf = pb; \
+ attr.minreq = mr; \
+ attr.tlength = tl; \
+ attr.maxlength = ml; \
+ attr.fragsize = fs; \
+} while (0)
+
+int avsys_audio_pasimple_open_device(const int mode, const unsigned int format, const unsigned int channel, const unsigned int samplerate, avsys_audio_handle_t *handle, int policy)
+{
+ pa_simple *s = NULL;
+ pa_sample_spec ss;
+ avsys_audio_pasimple_handle_t *device = NULL;
+ pa_buffer_attr attr;
+ int err = AVSYS_STATE_SUCCESS;
+ int period_time = PA_SIMPLE_PERIOD_TIME_FOR_MID_LATENCY_MSEC;
+
+ int samples_per_period = PA_SIMPLE_SAMPLES_PER_PERIOD_DEFAULT;
+ int periods_per_buffer = PA_SIMPLE_PERIODS_PER_BUFFER_DEFAULT;
+
+ avsys_info(AVAUDIO, ">>>[%s] mode=%d, format=%d, channel=%d, samplerate=%d\n", __func__, mode, format, channel, samplerate);
+ avsys_assert(handle != NULL);
+
+ if (channel < 1 || channel > 2)
+ return AVSYS_STATE_ERR_DEVICE_NOT_SUPPORT;
+
+ device = (avsys_audio_pasimple_handle_t *)malloc(sizeof(avsys_audio_pasimple_handle_t));
+ if (device == NULL) {
+ avsys_critical(AVAUDIO, "PA Simple handle alloc fail\n");
+ return AVSYS_STATE_ERR_ALLOCATION;
+ }
+
+ ss.rate = samplerate;
+ ss.channels = channel;
+
+ switch (format) {
+ case AVSYS_AUDIO_FORMAT_8BIT:
+ ss.format = PA_SAMPLE_U8;
+ device->samplesize = 1 * channel;
+ break;
+ case AVSYS_AUDIO_FORMAT_16BIT:
+
+ ss.format = PA_SAMPLE_S16LE;
+ device->samplesize = 2 * channel;
+ break;
+ default:
+ free(device);
+ avsys_error(AVAUDIO, "Invalid format\n");
+ return AVSYS_STATE_ERR_DEVICE_NOT_SUPPORT;
+ }
+ handle->device = (void *)device;
+
+ pa_proplist *proplist = pa_proplist_new();
+
+ /* Set policy property */
+ avsys_info(AVAUDIO, ">>>[%s] policy=[%d], vol_type=[%d]\n", __func__, policy, handle->gain_setting.vol_type);
+ if (policy == AVSYS_AUDIO_HANDLE_ROUTE_HANDSET_ONLY) {
+ avsys_info(AVAUDIO, ": set media plicy to PHONE\n");
+ pa_proplist_sets(proplist, PA_PROP_MEDIA_POLICY, "phone");
+ } else {
+ /* AVSYS_AUDIO_HANDLE_ROUTE_FOLLOWING_POLICY */
+ /* check stream type (vol type) */
+ if (handle->gain_setting.vol_type == AVSYS_AUDIO_VOLUME_TYPE_NOTIFICATION ||
+ handle->gain_setting.vol_type == AVSYS_AUDIO_VOLUME_TYPE_ALARM) {
+ avsys_info(AVAUDIO, ": set media plicy to ALL\n");
+ pa_proplist_sets(proplist, PA_PROP_MEDIA_POLICY, "all");
+ } else {
+ avsys_info(AVAUDIO, ": set media plicy to AUTO\n");
+ pa_proplist_sets(proplist, PA_PROP_MEDIA_POLICY, "auto");
+ }
+ }
+
+ handle->handle_route = policy;
+
+ memset(&attr, '\0', sizeof(attr));
+
+ switch (mode) {
+ case AVSYS_AUDIO_MODE_INPUT:
+ SET_PA_ATTR(PA_SIMPLE_PERIOD_TIME_FOR_MID_LATENCY_MSEC,
+ MSEC_TO_SAMPLE(samplerate,period_time),
+ PA_SIMPLE_PERIODS_PER_BUFFER_DEFAULT,
+ 0, -1, -1, -1, samples_per_period * device->samplesize);
+
+ s = pa_simple_new_proplist(NULL, "AVSYSTEM", PA_STREAM_RECORD, NULL, "CAPTURE", &ss, NULL, &attr, proplist, &err);
+ break;
+
+ case AVSYS_AUDIO_MODE_INPUT_LOW_LATENCY:
+ SET_PA_ATTR(PA_SIMPLE_PERIOD_TIME_FOR_ULOW_LATENCY_MSEC,
+ MSEC_TO_SAMPLE(samplerate,period_time),
+ PA_SIMPLE_PERIODS_PER_BUFFER_FASTMODE,
+ 0, -1, -1, -1, samples_per_period * device->samplesize);
+
+ s = pa_simple_new_proplist(NULL, "AVSYSTEM", PA_STREAM_RECORD, NULL, "LOW LATENCY CAPTURE", &ss, NULL, &attr, proplist, &err);
+ break;
+
+ case AVSYS_AUDIO_MODE_INPUT_HIGH_LATENCY:
+ SET_PA_ATTR(PA_SIMPLE_PERIOD_TIME_FOR_HIGH_LATENCY_MSEC,
+ MSEC_TO_SAMPLE(samplerate,period_time),
+ PA_SIMPLE_PERIODS_PER_BUFFER_CAPTURE,
+ 0, -1, -1, -1, samples_per_period * device->samplesize);
+
+ s = pa_simple_new_proplist(NULL, "AVSYSTEM", PA_STREAM_RECORD, NULL, "HIGH LATENCY CAPTURE", &ss, NULL, &attr, proplist, &err);
+ break;
+
+ case AVSYS_AUDIO_MODE_OUTPUT: /* mid latency playback for normal audio case. */
+ SET_PA_ATTR(PA_SIMPLE_PERIOD_TIME_FOR_MID_LATENCY_MSEC,
+ MSEC_TO_SAMPLE(samplerate,period_time),
+ PA_SIMPLE_PERIODS_PER_BUFFER_DEFAULT,
+ -1, -1, periods_per_buffer * samples_per_period * device->samplesize, attr.tlength, 0);
+
+ s = pa_simple_new_proplist(NULL, "AVSYSTEM", PA_STREAM_PLAYBACK, NULL, "PLAYBACK", &ss, NULL, &attr, proplist, &err);
+ break;
+
+ case AVSYS_AUDIO_MODE_OUTPUT_LOW_LATENCY: /* This is special case for touch sound playback */
+ SET_PA_ATTR(PA_SIMPLE_PERIOD_TIME_FOR_LOW_LATENCY_MSEC,
+ MSEC_TO_SAMPLE(samplerate,period_time),
+ PA_SIMPLE_PERIODS_PER_BUFFER_FASTMODE,
+ samples_per_period * device->samplesize, -1, samples_per_period * device->samplesize + 3430, (uint32_t)-1, 0);
+
+ s = pa_simple_new_proplist(NULL,"AVSYSTEM", PA_STREAM_PLAYBACK, NULL, "LOW LATENCY PLAYBACK", &ss, NULL, &attr, proplist, &err);
+ break;
+ case AVSYS_AUDIO_MODE_OUTPUT_CLOCK: /* high latency playback - lager buffer size */
+ SET_PA_ATTR(PA_SIMPLE_PERIOD_TIME_FOR_HIGH_LATENCY_MSEC,
+ MSEC_TO_SAMPLE(samplerate,period_time),
+ PA_SIMPLE_PERIODS_PER_BUFFER_PLAYBACK,
+ (uint32_t) -1, (uint32_t) -1, periods_per_buffer * samples_per_period * device->samplesize, (uint32_t)-1, 0);
+
+ s = pa_simple_new_proplist(NULL, "AVSYSTEM", PA_STREAM_PLAYBACK, NULL, "HIGH LATENCY PLAYBACK", &ss, NULL, &attr, proplist, &err);
+ break;
+
+ case AVSYS_AUDIO_MODE_OUTPUT_VIDEO: /* low latency playback */
+ SET_PA_ATTR(PA_SIMPLE_PERIOD_TIME_FOR_LOW_LATENCY_MSEC,
+ MSEC_TO_SAMPLE(samplerate,period_time),
+ PA_SIMPLE_PERIODS_PER_BUFFER_VIDEO,
+ 4*(samples_per_period * device->samplesize), samples_per_period * device->samplesize, periods_per_buffer * samples_per_period * device->samplesize, (uint32_t)-1, 0);
+
+ s = pa_simple_new_proplist(NULL, "AVSYSTEM", PA_STREAM_PLAYBACK, NULL, "LOW LATENCY PLAYBACK", &ss, NULL, &attr, proplist, &err);
+ break;
+
+ case AVSYS_AUDIO_MODE_OUTPUT_AP_CALL:
+#if defined(_MMFW_I386_ALL_SIMULATOR)
+ avsys_warning(AVAUDIO, "Does not support AP call mode at i386 simulator\n");
+ s = NULL;
+#else
+ SET_PA_ATTR(PA_SIMPLE_PERIOD_TIME_FOR_LOW_LATENCY_MSEC,
+ MSEC_TO_SAMPLE(samplerate,period_time),
+ PA_SIMPLE_PERIODS_PER_BUFFER_DEFAULT,
+ (uint32_t) -1, (uint32_t) -1, periods_per_buffer * samples_per_period * device->samplesize, attr.tlength, 0);
+
+
+ s = pa_simple_new_proplist(NULL, "AVSYSTEM", PA_STREAM_PLAYBACK, NULL, "VoIP PLAYBACK", &ss, NULL, &attr, proplist, &err);
+#endif
+ break;
+ case AVSYS_AUDIO_MODE_INPUT_AP_CALL:
+#if defined(_MMFW_I386_ALL_SIMULATOR)
+ avsys_warning(AVAUDIO, "Does not support AP call mode at i386 simulator\n");
+ s = NULL;
+#else
+ SET_PA_ATTR(PA_SIMPLE_PERIOD_TIME_FOR_LOW_LATENCY_MSEC,
+ MSEC_TO_SAMPLE(samplerate,period_time),
+ PA_SIMPLE_PERIODS_PER_BUFFER_DEFAULT,
+ 0, (uint32_t) -1, (uint32_t) -1, (uint32_t) -1, samples_per_period * device->samplesize);
+
+ s = pa_simple_new_proplist(NULL, "AVSYSTEM", PA_STREAM_RECORD, NULL, "VoIP CAPTURE", &ss, NULL, &attr, proplist, &err);
+#endif
+ break;
+ case AVSYS_AUDIO_MODE_CALL_OUT:
+ case AVSYS_AUDIO_MODE_CALL_IN:
+ //TODO
+ avsys_error(AVAUDIO, "Does not support call device handling\n");
+ avsys_assert_r(0);
+ break;
+ default:
+ avsys_critical_r(AVAUDIO, "Invalid open mode %d\n", mode);
+ avsys_assert_r(0);
+ return AVSYS_STATE_ERR_INVALID_MODE;
+ break;
+ }
+
+ if (!s) {
+ avsys_error_r(AVAUDIO, "Open pulseaudio handle has failed - %s\n", pa_strerror(err));
+ err = AVSYS_STATE_ERR_INTERNAL;
+ goto fail;
+ }
+
+ avsys_info(AVAUDIO, "Samples(per period) : %d\t Periods(per buffer) : %d\n", samples_per_period, periods_per_buffer);
+
+ device->pasimple_handle = (void *)s;
+ device->mode = mode;
+ device->period_frames = samples_per_period;
+ device->buffer_frames = periods_per_buffer * device->period_frames;
+ device->periods_per_buffer = periods_per_buffer;
+ handle->period = device->period_frames * device->samplesize;
+ handle->msec_per_period = period_time;
+ if (0 > pa_simple_get_stream_index(s, &handle->stream_index, &err)) {
+ avsys_error(AVAUDIO, "Can not get stream index %s\n", pa_strerror(err));
+ err = AVSYS_STATE_ERR_INVALID_HANDLE;
+ }
+
+fail:
+ if (proplist)
+ pa_proplist_free(proplist);
+
+ return err;
+}
+
+int avsys_audio_pasimple_close_device(avsys_audio_handle_t *handle)
+{
+ int err = 0;
+ avsys_audio_pasimple_handle_t *device = NULL;
+ pa_simple *s = NULL;
+
+ avsys_info(AVAUDIO, "%s\n", __func__);
+
+ avsys_assert(handle != NULL);
+ CHECK_VALID_HANDLE(handle);
+
+ switch (handle->mode) {
+ case AVSYS_AUDIO_MODE_CALL_OUT:
+ case AVSYS_AUDIO_MODE_CALL_IN:
+ avsys_warning(AVAUDIO, "Unsupported close mode in pa function\n");
+ return AVSYS_STATE_ERR_INVALID_MODE;
+ case AVSYS_AUDIO_MODE_OUTPUT_AP_CALL:
+ case AVSYS_AUDIO_MODE_INPUT_AP_CALL:
+#if defined(_MMFW_I386_ALL_SIMULATOR)
+ avsys_warning(AVAUDIO, "Skip close call device in SDK");
+ return AVSYS_STATE_SUCCESS;
+#endif
+ default:
+ break;
+ }
+
+ s = (pa_simple *)device->pasimple_handle;
+ avsys_assert(s != NULL);
+
+ switch (handle->mode) {
+ case AVSYS_AUDIO_MODE_OUTPUT:
+ case AVSYS_AUDIO_MODE_OUTPUT_CLOCK:
+ case AVSYS_AUDIO_MODE_OUTPUT_LOW_LATENCY:
+ case AVSYS_AUDIO_MODE_OUTPUT_AP_CALL:
+ case AVSYS_AUDIO_MODE_OUTPUT_VIDEO:
+ if (0 > pa_simple_flush(s, &err)) {
+ avsys_error(AVAUDIO, "pa_simple_flush() failed with %s\n", pa_strerror(err));
+ }
+ break;
+ default:
+ break;
+ }
+
+ pa_simple_free(s);
+
+ device->pasimple_handle = NULL;
+ free(device);
+
+ return AVSYS_STATE_SUCCESS;
+}
+
+int avsys_audio_pasimple_write(avsys_audio_handle_t *handle, const void *buf, int size)
+{
+ pa_simple *s = NULL;
+ avsys_audio_pasimple_handle_t *device = NULL;
+ int err = 0;
+
+ if (buf == NULL)
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ CHECK_VALID_HANDLE(handle);
+
+ if (size < 0)
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ else if (size == 0)
+ return 0;
+
+ s = (pa_simple *)device->pasimple_handle;
+
+ if (0 > pa_simple_write(s, buf, size, &err)) {
+ avsys_error(AVAUDIO, "pa_simple_write() failed with %s\n", pa_strerror(err));
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ return size;
+}
+
+int avsys_audio_pasimple_read(avsys_audio_handle_t *handle, void *buf, int size)
+{
+ pa_simple *s = NULL;
+ avsys_audio_pasimple_handle_t *device = NULL;
+ int err = 0;
+
+ if (buf == NULL)
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ CHECK_VALID_HANDLE(handle);
+
+ if (size < 0)
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ else if (size == 0)
+ return 0;
+
+ s = (pa_simple *)device->pasimple_handle;
+
+ if (0 > pa_simple_read(s, buf, size, &err)) {
+ avsys_error(AVAUDIO, "pa_simple_read() failed with %s\n", pa_strerror(err));
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ return size;
+}
+
+int avsys_audio_pasimple_reset(avsys_audio_handle_t *handle)
+{
+ pa_simple *s = NULL;
+ avsys_audio_pasimple_handle_t *device = NULL;
+ int err = 0;
+
+ CHECK_VALID_HANDLE(handle);
+
+ if (handle->mode == AVSYS_AUDIO_MODE_INPUT || handle->mode == AVSYS_AUDIO_MODE_INPUT_LOW_LATENCY) {
+ avsys_warning(AVAUDIO, "Skip pa_simple_flush() when input mode\n");
+ return AVSYS_STATE_SUCCESS;
+ }
+
+ s = (pa_simple *)device->pasimple_handle;
+
+ if (0 > pa_simple_flush(s, &err)) {
+ avsys_error(AVAUDIO, "pa_simple_flush() failed with %s\n", pa_strerror(err));
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ return AVSYS_STATE_SUCCESS;
+}
+
+int avsys_audio_pasimple_drain(avsys_audio_handle_t *handle)
+{
+ pa_simple *s = NULL;
+ avsys_audio_pasimple_handle_t *device = NULL;
+ int err = 0;
+
+ CHECK_VALID_HANDLE(handle);
+
+ s = (pa_simple *)device->pasimple_handle;
+
+ if (0 > pa_simple_drain(s, &err)) {
+ avsys_error(AVAUDIO, "pa_simple_drain() failed with %s\n", pa_strerror(err));
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ return AVSYS_STATE_SUCCESS;
+}
+
+int avsys_audio_pasimple_set_volume(avsys_audio_handle_t *handle, int volume)
+{
+ pa_simple *s = NULL;
+ avsys_audio_pasimple_handle_t *device = NULL;
+ int err = 0;
+
+ CHECK_VALID_HANDLE(handle);
+
+ s = (pa_simple *)device->pasimple_handle;
+
+ if (0 > pa_simple_set_volume(s, volume, &err)) {
+ avsys_error(AVAUDIO, "pa_simple_set_volume() failed with %s\n", pa_strerror(err));
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ return AVSYS_STATE_SUCCESS;
+}
+
+#define USEC_TO_SAMPLE(usec, rate) ((usec*rate)/1000000)
+#define SAMPLES_TO_USEC(samples,rate) ((samples*1000000)/rate)
+#define BYTES_TO_USEC(bytes,size_per_sample,rate) ((bytes*1000000)/(size_per_sample*rate))
+
+int avsys_audio_pasimple_delay(avsys_audio_handle_t *handle, int *delay)
+{
+ pa_simple *s = NULL;
+ avsys_audio_pasimple_handle_t *device = NULL;
+ int err = 0;
+ pa_usec_t latency_time = 0;
+ unsigned int latency_frames = 0;
+
+ if (delay == NULL) {
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ }
+ CHECK_VALID_HANDLE(handle);
+
+ s = (pa_simple *)device->pasimple_handle;
+
+ latency_time = pa_simple_get_latency(s, &err);
+ if (err > 0 && latency_time == 0) {
+ avsys_error(AVAUDIO, "pa_simple_get_latency() failed with %s\n", pa_strerror(err));
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+ /* convert time to sample */
+ latency_frames = USEC_TO_SAMPLE(latency_time, handle->samplerate);
+ *delay = latency_frames;
+
+ return AVSYS_STATE_SUCCESS;
+}
+
+int avsys_audio_pasimple_get_period_buffer_time(avsys_audio_handle_t *handle, unsigned int *period_time, unsigned int *buffer_time)
+{
+ avsys_audio_pasimple_handle_t *device = NULL;
+
+ if ((period_time == NULL) || (buffer_time == NULL))
+ return AVSYS_STATE_ERR_INTERNAL;
+
+ CHECK_VALID_HANDLE(handle);
+
+ *period_time = SAMPLES_TO_USEC(device->period_frames,handle->samplerate);
+ *buffer_time = *period_time * device->periods_per_buffer;
+
+ avsys_info(AVAUDIO, "[%s][%d] period = %d, buffer = %d\n", __func__, __LINE__, *period_time, *buffer_time);
+
+ return AVSYS_STATE_SUCCESS;
+}
+
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <stdlib.h>
+
+#include "avsys-audio-shm.h"
+#include "avsys-audio-sync.h"
+#include "avsys-audio-path.h"
+#include "avsys-audio-shm.h"
+#include "avsys-debug.h"
+#include "avsys-common.h"
+#include "avsys-audio-handle.h"
+#include "avsys-audio-logical-volume.h"
+#include "avsys-audio-alsa.h"
+#include "avsys-audio-ascenario.h"
+
+#define EXPORT_API __attribute__((__visibility__("default")))
+
+#define RET_IO_CTL_ERR_IF_FAIL(SECTION) { if(AVSYS_FAIL(SECTION)) { \
+ avsys_error_r(AVAUDIO,"%s %d\n",__func__,__LINE__); \
+ return AVSYS_STATE_ERR_IO_CONTROL; \
+ } }
+
+#define OPEN_AIF_BEFORE_SCENARIO_SET
+
+static int g_playback_path_select_data[AVSYS_AUDIO_PLAYBACK_GAIN_MAX][AVSYS_AUDIO_PATH_EX_OUTMAX] = {
+ { /* AVSYS_AUDIO_PLAYBACK_GAIN_AP */
+ /* NONE SPK RECV HEADSET BTHEADSET A2DP HANDSFREE HDMI */
+ 0, 1, 0, 1, 0, 0, 0, 0
+ },
+ { /* AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO */
+ /* NONE SPK RECV HEADSET BTHEADSET A2DP HANDSFREE HDMI */
+ 1, 1, 0, 1, 0, 0, 0, 0
+ },
+ { /* AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL */
+ /* NONE SPK RECV HEADSET BTHEADSET A2DP HANDSFREE HDMI */
+ 1, 1, 1, 1, 1, 0, 0, 0
+ },
+ { /* AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL */
+ /* NONE SPK RECV HEADSET BTHEADSET A2DP HANDSFREE HDMI */
+ 1, 1, 1, 1, 1, 0, 0, 0
+ },
+ { /* AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT */
+ /* NONE SPK RECV HEADSET BTHEADSET A2DP HANDSFREE HDMI */
+ 0, 1, 1, 1, 1, 0, 0, 0
+ }
+};
+
+static int g_capture_path_select_data[AVSYS_AUDIO_CAPTURE_GAIN_MAX][AVSYS_AUDIO_PATH_EX_INMAX] = {
+ { /* AVSYS_AUDIO_CAPTURE_GAIN_AP */
+ /* NONE MIC HMIC BMIC FMIN HFREE */
+ 1, 1, 1, 1, 0, 0
+ },
+ { /* AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO */
+ /* NONE MIC HMIC BMIC FMIN HFREE */
+ 1, 0, 0, 0, 1, 0
+ },
+ { /* AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL */
+ /* NONE MIC HMIC BMIC FMIN HFREE */
+ 1, 1, 1, 1, 0, 0
+ },
+ { /* AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL */
+ /* NONE MIC HMIC BMIC FMIN HFREE */
+ 1, 1, 1, 1, 0, 0
+ },
+};
+
+static int g_playback_gain_select_data[AVSYS_AUDIO_PLAYBACK_GAIN_MAX][AVSYS_AUDIO_PLAYBACK_GAIN_MAX] = {
+ { /* AVSYS_AUDIO_PLAYBACK_GAIN_AP */
+ AVSYS_AUDIO_PLAYBACK_GAIN_AP, /* AVSYS_AUDIO_PLAYBACK_GAIN_AP */
+ AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO, /* AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO */
+ AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL, /* AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL */
+ AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL, /* AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL */
+ AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT, /* AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT */
+ },
+ { /* AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO */
+ AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO, /* AVSYS_AUDIO_PLAYBACK_GAIN_AP */
+ AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO, /* AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO */
+ AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL, /* AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL */
+ AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL, /* AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL */
+ AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO, /* AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT */
+ },
+ { /* AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL */
+ AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL, /* AVSYS_AUDIO_PLAYBACK_GAIN_AP */
+ AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL, /* AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO */
+ AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL, /* AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL */
+ AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL, /* AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL */
+ AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT, /* AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT */
+ },
+ { /* AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL */
+ AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL, /* AVSYS_AUDIO_PLAYBACK_GAIN_AP */
+ AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL, /* AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO */
+ AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL, /* AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL */
+ AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL, /* AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL */
+ AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT, /* AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT */
+ },
+ { /* AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT */
+ AVSYS_AUDIO_PLAYBACK_GAIN_AP, /* AVSYS_AUDIO_PLAYBACK_GAIN_AP */
+ AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO, /* AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO */
+ AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL, /* AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL */
+ AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL, /* AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL */
+ AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT, /* AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT */
+ },
+};
+
+static int g_capture_gain_select_data[AVSYS_AUDIO_CAPTURE_GAIN_MAX][AVSYS_AUDIO_CAPTURE_GAIN_MAX] = {
+ { /* AVSYS_AUDIO_CAPTURE_GAIN_AP */
+ AVSYS_AUDIO_CAPTURE_GAIN_AP, /* AVSYS_AUDIO_CAPTURE_GAIN_AP */
+ AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO, /* AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO */
+ AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL, /* AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL */
+ AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL, /* AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL */
+ },
+ { /* AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO */
+ AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO, /* AVSYS_AUDIO_CAPTURE_GAIN_AP */
+ AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO, /* AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO */
+ AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL, /* AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL */
+ AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL, /* AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL */
+ },
+ { /* AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL */
+ AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL, /* AVSYS_AUDIO_CAPTURE_GAIN_AP */
+ AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL, /* AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO */
+ AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL, /* AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL */
+ AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL, /* AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL */
+ },
+ { /* AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL */
+ AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL, /* AVSYS_AUDIO_CAPTURE_GAIN_AP */
+ AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL, /* AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO */
+ AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL, /* AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL */
+ AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL, /* AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL */
+ },
+};
+
+
+static int __avsys_audio_path_set_ascn_ap_playback(avsys_audio_path_ex_info_t *control);
+static int __avsys_audio_path_set_ascn_voicecall(avsys_audio_path_ex_info_t *control);
+static int __avsys_audio_path_set_ascn_videocall(avsys_audio_path_ex_info_t *control);
+static int __avsys_audio_path_set_ascn_fmradio(avsys_audio_path_ex_info_t *control);
+static int __avsys_audio_path_set_ascn_ap_capture(avsys_audio_path_ex_info_t *control);
+
+
+typedef int (*_internal_gain_func)(avsys_audio_path_ex_info_t *control);
+static _internal_gain_func playback_gain_func_table[AVSYS_AUDIO_PLAYBACK_GAIN_MAX] =
+{
+ __avsys_audio_path_set_ascn_ap_playback,
+ __avsys_audio_path_set_ascn_fmradio,
+ __avsys_audio_path_set_ascn_voicecall,
+ __avsys_audio_path_set_ascn_videocall,
+ __avsys_audio_path_set_ascn_ap_playback,
+};
+
+static _internal_gain_func capture_gain_func_table[AVSYS_AUDIO_CAPTURE_GAIN_MAX] =
+{
+ __avsys_audio_path_set_ascn_ap_capture,
+ __avsys_audio_path_set_ascn_fmradio,
+ __avsys_audio_path_set_ascn_voicecall,
+ __avsys_audio_path_set_ascn_videocall,
+};
+
+static int __avsys_audio_path_set_hw_controls(avsys_audio_path_ex_info_t *control);
+static int __avsys_audio_path_get_earjack_type(void);
+
+#define AUDIOSYSTEM_CONF "/opt/etc/audio_system.conf"
+#define CONF_ITEM_COUNT 2
+#define INPUT_DEV_MAX 20
+static char *conf_string[] = {
+ "headset_detection",
+ "headset_node",
+};
+
+typedef struct {
+ char headset_detection;
+ char headset_node_number;
+} AudioSystemConf;
+
+static int __load_conf(AudioSystemConf *data)
+{
+#if defined(_MMFW_I386_ALL_SIMULATOR)
+ if (data == NULL)
+ return AVSYS_STATE_ERR_NULL_POINTER;
+
+ data->headset_detection = 1;
+ data->headset_node_number = 4;
+#else
+ FILE *fp = NULL;
+ int i = 0;
+ char buffer[64] = { 0, };
+ char conf_data[CONF_ITEM_COUNT] = { 1, 0 };
+
+ if (data == NULL)
+ return AVSYS_STATE_ERR_NULL_POINTER;
+
+ fp = fopen(AUDIOSYSTEM_CONF, "r");
+ if (fp == NULL) {
+ char filename[128] = { 0, };
+ char readBuffer[32] = { 0, };
+ char headset_find = 0;
+ int num = 0, headset_num = -1;
+
+ for (num = 0; num < INPUT_DEV_MAX; num++) {
+ FILE *sfp = NULL;
+ memset(filename, '\0', sizeof(filename));
+ snprintf(filename, sizeof(filename), "/sys/class/input/input%01d/name", num);
+ if (NULL == (sfp = fopen(filename, "r")))
+ continue;
+ memset(readBuffer, '\0', sizeof(readBuffer));
+ if (NULL == fgets(readBuffer, sizeof(readBuffer) - 1, sfp)) {
+ fclose(sfp);
+ continue;
+ }
+ if (strstr(readBuffer, "Headset")) {
+ headset_find = 1;
+ headset_num = num;
+ }
+
+ fclose(sfp);
+ if (headset_num != -1) {
+ break;
+ }
+ }
+ if (headset_num == -1)
+ return AVSYS_STATE_ERR_INTERNAL;
+
+ if (NULL == (fp = fopen(AUDIOSYSTEM_CONF, "w"))) {
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ fprintf(fp, "%s:1\n", conf_string[0]);
+ fprintf(fp, "%s:%d\n", conf_string[1], headset_num);
+ fflush(fp);
+ fclose(fp);
+ fp = NULL;
+ sync();
+ data->headset_detection = 1;
+ data->headset_node_number = headset_num;
+ return AVSYS_STATE_SUCCESS;
+ }
+
+ while (fgets(buffer, sizeof(buffer) - 1, fp) != NULL) {
+ if ((strlen(buffer) < 3) || (buffer[0] == '#') || (buffer[0] == '!'))
+ continue;
+ if (buffer[strlen(buffer) - 1] == '\n')
+ buffer[strlen(buffer) - 1] = '\0';
+ for (i = 0; i < CONF_ITEM_COUNT; i++) {
+ if (0 == strncmp(buffer, conf_string[i], strlen(conf_string[i]))) {
+ char *ptr = NULL;
+ if (NULL == (ptr = strstr(buffer, ":")))
+ break;
+ conf_data[i] = atoi(ptr + 1);
+ avsys_warning(AVAUDIO, "%s[%d]\n", buffer, conf_data[i]);
+ }
+ }
+ }
+ fclose(fp);
+ data->headset_detection = conf_data[0];
+ data->headset_node_number = conf_data[1];
+#endif
+ return AVSYS_STATE_SUCCESS;
+}
+
+EXPORT_API
+int avsys_audio_path_ex_init(void)
+{
+ avsys_audio_path_ex_info_t *control = NULL;
+ avsys_audio_path_ex_info_t **temp = NULL;
+ gain_info_t default_gain = { AVSYS_AUDIO_PLAYBACK_GAIN_AP, AVSYS_AUDIO_CAPTURE_GAIN_AP };
+ path_info_t default_path = { AVSYS_AUDIO_PATH_EX_SPK, AVSYS_AUDIO_PATH_EX_MIC };
+ gain_status_t clean_gain_status = { GS_GAIN_NONE, GS_GAIN_NONE };
+ path_status_t clean_path_status = { PS_PATH_NONE, PS_PATH_NONE };
+ option_info_t default_option = { AVSYS_AUDIO_PATH_OPTION_JACK_AUTO, AVSYS_AUDIO_PATH_OPTION_JACK_AUTO };
+ int index = 0;
+ int err = AVSYS_STATE_SUCCESS;
+ AudioSystemConf conf = { 1, 4 };
+
+ /* Check root user */
+ err = avsys_check_root_privilege();
+ if (AVSYS_FAIL(err)) {
+ return err;
+ }
+
+ temp = &control;
+ avsys_assert(AVSYS_SUCCESS(avsys_audio_create_sync(AVSYS_AUDIO_SYNC_IDEN_PATH)));
+ avsys_assert(AVSYS_SUCCESS(avsys_audio_create_sync(AVSYS_AUDIO_SYNC_IDEN_SOUNDPATH))); /* for audio route policy */
+ avsys_assert(AVSYS_SUCCESS(avsys_audio_create_shm(AVSYS_AUDIO_SHM_IDEN_PATH)));
+
+ avsys_assert(AVSYS_SUCCESS(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp)));
+ if (control == NULL)
+ return AVSYS_STATE_ERR_NULL_POINTER;
+
+ /* init values */
+ control->pregain = default_gain;
+ control->gain = default_gain;
+ control->reqgain = default_gain;
+ control->path = default_path;
+ control->backup_gain = default_gain;
+ control->backup_path = default_path;
+ control->option = default_option;
+ control->gain_status = clean_gain_status;
+ control->path_status = clean_path_status;
+ control->p_gain_status = clean_gain_status;
+ control->p_path_status = clean_path_status;
+
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
+ control->inserted = AVSYS_AUDIO_INSERTED_NONE;
+ control->route_policy = AVSYS_AUDIO_ROUTE_POLICY_DEFAULT;
+ if (AVSYS_FAIL(__load_conf(&conf)))
+ avsys_error_r(AVAUDIO, "Can not load audio system configuration file\n");
+
+ if (conf.headset_detection) {
+ control->inserted = __avsys_audio_path_get_earjack_type();
+ if (control->inserted == AVSYS_AUDIO_INSERTED_NONE)
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
+ else
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET;
+ } else {
+ avsys_warning(AVAUDIO, "Ignore headset detection. Use speaker device\n");
+ control->inserted = AVSYS_AUDIO_INSERTED_NONE;
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
+ }
+
+ avsys_error_r(AVAUDIO, "Earjack init value is %d\n", control->inserted);
+
+ {
+ /* Gain tunning Debug mode */
+ FILE *gainTunningFp = NULL;
+ if (NULL != (gainTunningFp = fopen("/opt/etc/gain_tuner.ini", "r"))) {
+ char buffer[32] = "";
+ avsys_warning(AVAUDIO, "GAIN TUNNING DEBUG MODE...This degrade sound path performance\n");
+ memset(buffer, '\0', sizeof(buffer));
+ if (NULL == fgets(buffer, sizeof(buffer) - 1, gainTunningFp)) {
+ fclose(gainTunningFp);
+ control->gain_debug_mode = 0;
+ } else {
+ fclose(gainTunningFp);
+ if (0 == strncmp("debug=1", buffer, 7)) {
+ control->gain_debug_mode = 1;
+ } else {
+ control->gain_debug_mode = 0;
+ }
+ }
+ } else {
+ control->gain_debug_mode = 0;
+ }
+ }
+ control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_MANUAL;
+ control->mute = AVSYS_AUDIO_UNMUTE;
+ control->path_fixed = PATH_FIXED_NONE;
+
+ index = 0;
+ do {
+ control->pathlock_pid[index] = -1;
+ index++;
+ } while (index < AVSYS_AUDIO_LOCK_SLOT_MAX);
+
+ index = 0;
+ do {
+ control->path_fixed_pid[index] = -1;
+ index++;
+ } while (index < PATH_FIXED_TYPE_MAX);
+
+ /* call path control */
+ err = __avsys_audio_path_set_ascn_ap_playback(control);
+ if (AVSYS_SUCCESS(err))
+ err = __avsys_audio_path_set_hw_controls(control);
+
+ if (AVSYS_SUCCESS(err))
+ err = __avsys_audio_path_set_ascn_ap_capture(control);
+
+ return err;
+}
+
+EXPORT_API
+int avsys_audio_path_ex_fini(void)
+{
+ if (AVSYS_FAIL(avsys_audio_remove_shm(AVSYS_AUDIO_SHM_IDEN_PATH))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_remove_shm() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+ if (AVSYS_FAIL(avsys_audio_remove_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_remove_sync() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+ return AVSYS_STATE_SUCCESS;
+}
+
+EXPORT_API
+int avsys_audio_path_ex_reset(int forced)
+{
+ avsys_audio_path_ex_info_t *control = NULL;
+ avsys_audio_path_ex_info_t **temp = NULL;
+ gain_info_t default_gain = { AVSYS_AUDIO_PLAYBACK_GAIN_AP, AVSYS_AUDIO_CAPTURE_GAIN_AP };
+ path_info_t default_path = { AVSYS_AUDIO_PATH_EX_SPK, AVSYS_AUDIO_PATH_EX_MIC };
+ gain_status_t clean_gain_status = { GS_GAIN_NONE, GS_GAIN_NONE };
+ path_status_t clean_path_status = { PS_PATH_NONE, PS_PATH_NONE };
+ option_info_t default_option = { AVSYS_AUDIO_PATH_OPTION_JACK_AUTO, AVSYS_AUDIO_PATH_OPTION_JACK_AUTO };
+ int index = 0;
+ int err = AVSYS_STATE_SUCCESS;
+ int backup_debug = 0;
+ AudioSystemConf conf = { 1, 4 };
+
+ /* Check root user */
+ err = avsys_check_root_privilege();
+ if (AVSYS_FAIL(err)) {
+ return err;
+ }
+
+ temp = &control;
+ if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+ if (control == NULL)
+ return AVSYS_STATE_ERR_NULL_POINTER;
+
+ if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_lock_sync() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ /* init values */
+ control->pregain = default_gain;
+ control->gain = default_gain;
+ control->reqgain = default_gain;
+ control->path = default_path;
+ control->backup_gain = default_gain;
+ control->backup_path = default_path;
+ control->option = default_option;
+ control->gain_status = clean_gain_status;
+ control->path_status = clean_path_status;
+ control->p_gain_status = clean_gain_status;
+ control->p_path_status = clean_path_status;
+
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
+ control->inserted = AVSYS_AUDIO_INSERTED_NONE;
+ control->route_policy = AVSYS_AUDIO_ROUTE_POLICY_DEFAULT;
+ if (AVSYS_FAIL(__load_conf(&conf)))
+ avsys_error_r(AVAUDIO, "Can not load audio system configuration file\n");
+
+ if (conf.headset_detection) {
+ control->inserted = __avsys_audio_path_get_earjack_type();
+ if (control->inserted == AVSYS_AUDIO_INSERTED_NONE)
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
+ else
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET;
+ } else {
+ avsys_warning(AVAUDIO, "Ignore headset detection. Use speaker device\n");
+ control->inserted = AVSYS_AUDIO_INSERTED_NONE;
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
+ }
+
+ avsys_error_r(AVAUDIO, "Earjack init value is %d\n", control->inserted);
+
+ {
+ /* Gain tunning Debug mode */
+ FILE *gainTunningFp = NULL;
+ if (NULL != (gainTunningFp = fopen("/opt/etc/gain_tuner.ini", "r"))) {
+ char buffer[32] = "";
+ avsys_warning(AVAUDIO, "GAIN TUNNING DEBUG MODE...This degrade sound path performance\n");
+ memset(buffer, '\0', sizeof(buffer));
+ if (NULL == fgets(buffer, sizeof(buffer) - 1, gainTunningFp)) {
+ fclose(gainTunningFp);
+ control->gain_debug_mode = 0;
+ } else {
+ fclose(gainTunningFp);
+ if (0 == strncmp("debug=1", buffer, 7)) {
+ control->gain_debug_mode = 1;
+ } else {
+ control->gain_debug_mode = 0;
+ }
+ }
+ } else {
+ control->gain_debug_mode = 0;
+ }
+ }
+ control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_MANUAL;
+ control->mute = AVSYS_AUDIO_UNMUTE;
+ control->path_fixed = PATH_FIXED_NONE;
+
+ index = 0;
+ do {
+ control->pathlock_pid[index] = -1;
+ index++;
+ } while (index < AVSYS_AUDIO_LOCK_SLOT_MAX);
+
+ index = 0;
+ do {
+ control->path_fixed_pid[index] = -1;
+ index++;
+ } while (index < PATH_FIXED_TYPE_MAX);
+
+ if (forced) {
+ backup_debug = control->gain_debug_mode;
+ control->gain_debug_mode = 1;
+ }
+ /* call path control */
+ err = __avsys_audio_path_set_ascn_ap_playback(control);
+ if (AVSYS_SUCCESS(err))
+ err = __avsys_audio_path_set_hw_controls(control);
+
+ if (AVSYS_SUCCESS(err))
+ err = __avsys_audio_path_set_ascn_ap_capture(control);
+
+ if (forced) {
+ control->gain_debug_mode = backup_debug;
+ }
+
+ if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ return err;
+}
+
+EXPORT_API
+int avsys_audio_path_ex_dump(void)
+{
+ avsys_audio_path_ex_info_t *control = NULL;
+ avsys_audio_path_ex_info_t **temp = NULL;
+ const static char *str_earType[] = { "None", "EarOnly", "EarMic", "TVout" };
+ const static char *str_yn[] = { "NO", "YES" };
+ const static char *str_ear[] = { "MANUAL", "AUTO_MUTE", "AUTO_NOMUTE" };
+ const static char *str_out[AVSYS_AUDIO_PATH_EX_OUTMAX] = {
+ "NONE", "SPK", "RECV", "HEADSET", "BTHEADSET", "A2DP", "HANSFREE"
+ };
+ const static char *str_in[AVSYS_AUDIO_PATH_EX_INMAX] = {
+ "NONE", "MIC", "HEADMIC", "BTMIC", "FMINPUT", "HANSFREEMIC"
+ };
+ const static char *str_route[AVSYS_AUDIO_ROUTE_POLICY_MAX] = {
+ "DEFAULT", "IGN_A2DP", "HANDSET"
+ };
+ /*
+ const static char *str_gain[AVSYS_AUDIO_GAIN_EX_MAX] = {
+ "KEYTONE", "RINGTONE", "ALARMTONE", "CALLTONE", "AUDIOPLAYER", "VIDEOPLAYER",
+ "VOICECALL", "VIDEOCALL", "FMRADIO", "VOICEREC", "CAMCORDER", "CAMERA", "GAME"};
+ */
+ const static char *str_playback_gain[AVSYS_AUDIO_PLAYBACK_GAIN_MAX] = {
+ "AP", "FMRADIO", "VOICECALL", "VIDEOCALL", "CALLALERT",
+ };
+ const static char *str_capture_gain[AVSYS_AUDIO_CAPTURE_GAIN_MAX] = {
+ "AP", "FMRADIO", "VOICECALL", "VIDEOCALL",
+ };
+
+ int index = 0;
+
+ temp = &control;
+
+ if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+ if (control == NULL)
+ return AVSYS_STATE_ERR_NULL_POINTER;
+
+ fprintf(stdout, "======================================================================\n");
+ fprintf(stdout, " Avsystem Audio Path Control Information \n");
+ fprintf(stdout, "======================================================================\n");
+#if defined(_MMFW_I386_ALL_SIMULATOR)
+ fprintf(stdout, " In simulator, follow informations don`t have means.\n");
+#endif
+
+ fprintf(stdout, " GAIN : P (%-s / %-s) - R (%-s / %-s) - C (%-s / %-s)\n",
+ str_playback_gain[control->pregain.playback], str_capture_gain[control->pregain.capture],
+ str_playback_gain[control->reqgain.playback], str_capture_gain[control->reqgain.capture],
+ str_playback_gain[control->gain.playback], str_capture_gain[control->gain.capture]);
+ fprintf(stdout, " Current Out / In : %-s / %-s\n", str_out[control->path.playback], str_in[control->path.capture] );
+ fprintf(stdout, " Gain debug mode : 0x%-x\n", control->gain_debug_mode);
+ fprintf(stdout, " Gain status : 0x%x 0x%x\n", control->gain_status.playback, control->gain_status.capture);
+ fprintf(stdout, " Path status : 0x%x 0x%x\n", control->path_status.playback, control->path_status.capture);
+ fprintf(stdout, " Auto EarJack Control : %-s\n", str_ear[control->ear_auto]);
+ fprintf(stdout, " Audio Route Policy : %-s\n", str_route[control->route_policy]);
+ fprintf(stdout, " Physical Earjack? [type] : %-s [%-s]\n", str_yn[control->inserted != AVSYS_AUDIO_INSERTED_NONE], str_earType[control->inserted]);
+ fprintf(stdout, " Path Fixed State : 0x%-x\n", control->path_fixed);
+ fprintf(stdout, " Mute status : %d\n", control->mute);
+ if (control->path_fixed_pid[PATH_FIXED_TYPE_FMRADIO] != -1)
+ fprintf(stdout, " FM Radio path pid : %d\n", control->path_fixed_pid[PATH_FIXED_TYPE_FMRADIO]);
+ if (control->path_fixed_pid[PATH_FIXED_TYPE_CALL] != -1)
+ fprintf(stdout, " Call path pid : %d\n", control->path_fixed_pid[PATH_FIXED_TYPE_CALL]);
+
+ index = 0;
+ do {
+ if (control->pathlock_pid[index] != -1)
+ fprintf(stdout, " Path sync lock required PIDs : %d\n", control->pathlock_pid[index]);
+ index++;
+ } while (index < AVSYS_AUDIO_LOCK_SLOT_MAX);
+ fprintf(stdout, " Option Lagacy : %-s\n", str_yn[(control->option.playback & AVSYS_AUDIO_PATH_OPTION_LEGACY_MODE) ? 1 : 0]);
+ fprintf(stdout, " Option Jack Playback : %-s\n", str_yn[(control->option.playback & AVSYS_AUDIO_PATH_OPTION_JACK_AUTO) ? 1 : 0]);
+ fprintf(stdout, " Option Jack Capture : %-s\n", str_yn[(control->option.capture & AVSYS_AUDIO_PATH_OPTION_JACK_AUTO) ? 1 : 0]);
+ fprintf(stdout, " Option Dual out : %-s\n", str_yn[(control->option.playback & AVSYS_AUDIO_PATH_OPTION_DUAL_OUT) ? 1 : 0]);
+ fprintf(stdout, " Option Forced : %-s\n", str_yn[(control->option.playback & AVSYS_AUDIO_PATH_OPTION_FORCED) ? 1 : 0]);
+
+ return AVSYS_STATE_SUCCESS;
+}
+
+static int __avsys_audio_path_get_earjack_type (void)
+{
+ int fd = 0;
+ char readval = AVSYS_AUDIO_INSERTED_NONE;
+ fd = open("/sys/devices/platform/jack/earjack_online", O_RDONLY);
+
+ if (fd == -1) {
+ avsys_error_r(AVAUDIO, "Can not get initial jack type\n");
+ return AVSYS_AUDIO_INSERTED_NONE;
+ }
+ read(fd, &readval, sizeof(readval));
+ switch (readval) {
+ case '0':
+ readval = AVSYS_AUDIO_INSERTED_NONE;
+ break;
+ case '1':
+ readval = AVSYS_AUDIO_INSERTED_3;
+ break;
+ case '3':
+ readval = AVSYS_AUDIO_INSERTED_4;
+ break;
+ case '8':
+ readval = AVSYS_AUDIO_INSERTED_AV;
+ break;
+ case '2':
+ if (1 == read(fd, &readval, sizeof(readval))) {
+ if (readval == '0') {
+ readval = AVSYS_AUDIO_INSERTED_AV;
+ } else {
+ avsys_error(AVAUDIO, "Unknown jack type value...2%d\n", readval);
+ readval = AVSYS_AUDIO_INSERTED_NONE;
+ }
+ } else {
+ avsys_error(AVAUDIO, "jack type read error...\n");
+ readval = AVSYS_AUDIO_INSERTED_NONE;
+ }
+ break;
+ default:
+ avsys_error(AVAUDIO, "jack type unknown value...%c\n", readval);
+ readval = AVSYS_AUDIO_INSERTED_NONE;
+ break;
+ }
+
+ close(fd);
+ return readval;
+}
+
+int avsys_audio_path_earjack_init(int *init_type, int *outfd)
+{
+#if !defined(_MMFW_I386_ALL_SIMULATOR)
+ char eventnode_filename[32] = { 0, };
+ int fd = 0;
+ AudioSystemConf conf = { 1, 4 };
+
+ if (outfd == NULL || init_type == NULL) {
+ avsys_error(AVAUDIO, "input parameter is null\n");
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ }
+
+ if (AVSYS_FAIL(__load_conf(&conf))) {
+ avsys_error_r(AVAUDIO, "Can not load audio system configuration file\n");
+ }
+
+ if (!conf.headset_detection) {
+ avsys_error(AVAUDIO, "Earjack control daemon will be closed by user option...\n");
+ return AVSYS_STATE_SUCCESS;
+ }
+
+ snprintf(eventnode_filename, sizeof(eventnode_filename), "/dev/event%01d", conf.headset_node_number);
+
+ fd = open(eventnode_filename, O_RDONLY);
+ if (fd == -1) {
+ avsys_error_r(AVAUDIO, "Device file open error\n");
+ return AVSYS_STATE_ERR_INTERNAL;
+ } else {
+ avsys_audio_path_ex_info_t *control = NULL;
+ avsys_audio_path_ex_info_t **temp = NULL;
+ void *vol_data = NULL;
+ void *handle_data = NULL;
+ temp = &control;
+
+ if(AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_LVOLUME, &vol_data))) {
+ avsys_error(AVAUDIO,"attach logical volume shared memory failed\n");
+ return AVSYS_STATE_ERR_ALLOCATION;
+ }
+ if(AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_HANDLE, &handle_data))) {
+ avsys_error(AVAUDIO,"attach handle shared memory failed\n");
+ return AVSYS_STATE_ERR_ALLOCATION;
+ }
+ if(AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void**)temp))) {
+ avsys_error_r(AVAUDIO,"avsys_audio_get_shm() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ *init_type = control->inserted;
+ *outfd = fd;
+ return AVSYS_STATE_SUCCESS;
+ }
+#else
+ return AVSYS_STATE_ERR_DEVICE_NOT_SUPPORT;
+#endif
+}
+
+int avsys_audio_path_earjack_wait(int fd, int *current_type, int *new_type, int *is_auto_mute)
+{
+#if !defined(_MMFW_I386_ALL_SIMULATOR)
+ fd_set set;
+ int readtemp;
+ int select_ret = 0;
+ struct avsys_audio_jack_event jevent;
+ int res = AVSYS_STATE_SUCCESS;
+ int set_flag = 0;
+ int cur_type = -1;
+
+ if (new_type == NULL || is_auto_mute == NULL)
+ return AVSYS_STATE_ERR_NULL_POINTER;
+
+ FD_ZERO(&set);
+ FD_SET(fd, &set);
+
+ cur_type = *current_type;
+
+ select_ret = select(fd + 1, &set, NULL, NULL, NULL);
+ avsys_info(AVAUDIO, "SELECT returns......\n");
+
+ if (select_ret != 1) {
+ if (select_ret == 0) {
+ avsys_error_r(AVAUDIO, "Earjack timeout in autocontrol\n");
+ } else if (select_ret == -1) {
+ avsys_error_r(AVAUDIO, "Earjack detect unknown error: %d\n", errno);
+ }
+ return AVSYS_STATE_WAR_INVALID_VALUE;
+ }
+#ifdef EARJACK_LOCK /* currently this is disabled to avoid semapore value increase */
+ if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_lock_sync() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+#endif
+ if (read(fd, &jevent, sizeof(jevent)) < 0) {
+ avsys_error(AVAUDIO, "read fd failed with 0x%x\n", errno);
+ return AVSYS_STATE_WAR_INVALID_MODE;
+ }
+ avsys_info(AVAUDIO, "*** JEVENT : code=%d, value=%d\n", jevent.code, jevent.value);
+ if (jevent.type != TYPE_EVENT_SWITCH) {
+ avsys_info(AVAUDIO, "Not a switch event\n");
+ return AVSYS_STATE_WAR_INVALID_MODE;
+ }
+
+ switch (jevent.code) {
+ case CODE_HEADPHONE_INSERT:
+ case CODE_LINEOUT_INSERT:
+ case CODE_JACK_PHYSICAL_INSERT:
+ if (jevent.value == 1) {
+ readtemp = __avsys_audio_path_get_earjack_type();
+ } else {
+ readtemp = 0;
+ }
+
+ set_flag = 1; /* need change earphone status */
+ break;
+ default:
+ readtemp = cur_type; /* same value */
+ break;
+ }
+
+ *new_type = readtemp;
+
+ avsys_audio_path_ex_info_t *control = NULL;
+ avsys_audio_path_ex_info_t **temp = NULL;
+ temp = &control;
+
+ if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ avsys_info(AVAUDIO, "control->ear_auto = %d\n", control->ear_auto);
+ if (control->ear_auto == AVSYS_AUDIO_EAR_SWITCH_AUTO_WITH_MUTE) {
+ *current_type = control->inserted;
+ *is_auto_mute = 1;
+ res = AVSYS_STATE_SUCCESS;
+ } else if (control->ear_auto == AVSYS_AUDIO_EAR_SWITCH_AUTO_WITHOUT_MUTE) {
+ *current_type = control->inserted;
+ *is_auto_mute = 0;
+ res = AVSYS_STATE_SUCCESS;
+ } else if (control->ear_auto == AVSYS_AUDIO_EAR_SWITCH_MANUAL) {
+ *is_auto_mute = 0;
+ /* return warning */
+ if (set_flag) {
+ control->inserted = *new_type;
+ set_flag = 0;
+ }
+ res = AVSYS_STATE_WAR_INTERNAL;
+ }
+
+ return res;
+#else
+ return AVSYS_STATE_ERR_DEVICE_NOT_SUPPORT;
+#endif
+}
+
+int avsys_audio_path_earjack_process(int new_type)
+{
+#if !defined(_MMFW_I386_ALL_SIMULATOR)
+ avsys_audio_path_ex_info_t *control = NULL;
+ avsys_audio_path_ex_info_t **temp = NULL;
+ int err = AVSYS_STATE_SUCCESS;
+ temp = &control;
+
+ avsys_info(AVAUDIO, "new_type = %d\n", new_type);
+ if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ control->inserted = new_type;
+
+ if (control->ear_auto == AVSYS_AUDIO_EAR_SWITCH_MANUAL) {
+ return AVSYS_STATE_SUCCESS;
+ }
+
+ /* Capture/Playback Gain Control */
+ avsys_warning(AVAUDIO, "Gain C(%d), P(%d)\n", control->gain.capture, control->gain.playback);
+ err = capture_gain_func_table[control->gain.capture] (control);
+ if (AVSYS_FAIL(err)) {
+ avsys_error_r(AVAUDIO, "earjack change failed for %d gain : error 0x%x\n", control->gain.capture, err);
+ }
+
+ err = playback_gain_func_table[control->gain.playback] (control);
+ if (AVSYS_SUCCESS(err)) {
+ /* H/W Control */
+ err = __avsys_audio_path_set_hw_controls(control);
+ if (AVSYS_FAIL(err)) {
+ avsys_error_r(AVAUDIO, "__avsys_audio_path_set_hw_controls() failed in %s\n", __func__);
+ }
+ } else
+ avsys_error_r(AVAUDIO, "earjack change failed for %d gain : error 0x%x\n", control->gain.playback, err);
+
+ return err;
+#else
+ return AVSYS_STATE_ERR_DEVICE_NOT_SUPPORT;
+#endif
+}
+
+int avsys_audio_path_earjack_deinit(int fd)
+{
+#if !defined(_MMFW_I386_ALL_SIMULATOR)
+ close(fd);
+ return AVSYS_STATE_SUCCESS;
+#else
+ return AVSYS_STATE_ERR_DEVICE_NOT_SUPPORT;
+#endif
+}
+
+int avsys_audio_path_earjack_unlock()
+{
+#ifdef EARJACK_LOCK /* currently this is disabled to avoid semapore value increase */
+ if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+#endif
+ return AVSYS_STATE_SUCCESS;
+};
+
+#define DO_IF_VALID(c, p) { if(c > -1) p; }
+#define DO_IF_INVALID(c, p) { if(c == -1) p; }
+#define CHECK_VALID(c) (c>-1 ? 1 : 0)
+
+enum {
+ CMD_DEVICE_NONE = 0,
+ CMD_DEVICE_OPEN,
+ CMD_DEVICE_CLOSE,
+ CMD_DEVICE_MAX
+};
+
+avsys_audio_alsa_aif_handle_t *g_hAIF[AIF_DEVICE_MAX] = { NULL, NULL, NULL, NULL };
+char *strAIF[AIF_DEVICE_MAX] = { "AIF2 Capture", "AIF2 Playback", "AIF3 Capture", "AIF3 Playback" };
+
+#define SET_AIF(index) \
+do { \
+ if(g_hAIF[index]) { \
+ avsys_warning(AVAUDIO,#index" device already opened\n"); \
+ AIF_control[index] = CMD_DEVICE_NONE; \
+ } else { \
+ AIF_control[index] = CMD_DEVICE_OPEN; \
+ } \
+} while (0)
+
+static int __avsys_open_aif(char AIF_control[])
+{
+ int iAIF = 0;
+ int err = AVSYS_STATE_SUCCESS;
+
+ for (iAIF = 0; iAIF < AIF_DEVICE_MAX; iAIF++) {
+ /* check command */
+ if (AIF_control[iAIF] != CMD_DEVICE_OPEN)
+ continue;
+
+ /* check handle allocation */
+ if (g_hAIF[iAIF]) {
+ avsys_warning(AVAUDIO, "Oops! Free %s device handle first", strAIF[iAIF]);
+ free(g_hAIF[iAIF]);
+ g_hAIF[iAIF] = NULL;
+ }
+ /* memory allocation for handle */
+ avsys_warning(AVAUDIO, "%s handle alloc", strAIF[iAIF]);
+ g_hAIF[iAIF] = calloc(sizeof(avsys_audio_handle_t), 1);
+ if (!g_hAIF[iAIF]) {
+ avsys_error_r(AVAUDIO, "Can not alloc memory for %s device handle", strAIF[iAIF]);
+ err = AVSYS_STATE_ERR_ALLOCATION;
+ continue;
+ }
+
+ if (AVSYS_FAIL(avsys_audio_alsa_open_AIF_device(iAIF, g_hAIF[iAIF]))) {
+ avsys_error_r(AVAUDIO, "open %s device failed\n", strAIF[iAIF]);
+ err = AVSYS_STATE_ERR_INVALID_HANDLE;
+ } else {
+ avsys_warning(AVAUDIO, "open %s device success\n", strAIF[iAIF]);
+ if (AVSYS_FAIL(avsys_audio_alsa_set_AIF_params(g_hAIF[iAIF]))) {
+ avsys_error_r(AVAUDIO, "%s device set parameter failed\n", strAIF[iAIF]);
+ err = AVSYS_STATE_ERR_INVALID_PARAMETER;
+ } else {
+ avsys_warning(AVAUDIO, "%s device set parameter success\n", strAIF[iAIF]);
+ }
+ }
+ }
+ return err;
+}
+
+static void __avsys_close_aif ()
+{
+ int iAIF = 0;
+
+ for (iAIF = 0; iAIF < AIF_DEVICE_MAX; iAIF++) {
+ if (g_hAIF[iAIF]) {
+ avsys_info(AVAUDIO, "close device :: %s\n", strAIF[iAIF]);
+ if (AVSYS_FAIL(avsys_audio_alsa_close_AIF_device(g_hAIF[iAIF]))) {
+ avsys_error_r(AVAUDIO, "close %s device failed\n", strAIF[iAIF]);
+ }
+ free(g_hAIF[iAIF]);
+ g_hAIF[iAIF] = NULL;
+ avsys_warning(AVAUDIO, "%s device handle free\n", strAIF[iAIF]);
+ } else {
+ avsys_info(AVAUDIO, "skip closing device :: %s\n", strAIF[iAIF]);
+ }
+ }
+}
+
+static int __avsys_audio_release_path (gain_info_t local_gain, avsys_audio_path_ex_info_t *control)
+{
+ int err = AVSYS_STATE_SUCCESS;
+ int iAIF = 0;
+
+ avsys_warning(AVAUDIO, "Release path for %d %d\n", local_gain.playback, local_gain.capture);
+
+ switch (local_gain.playback) {
+ case AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL:
+ case AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL:
+ if (getpid() == control->path_fixed_pid[PATH_FIXED_TYPE_CALL]) {
+#ifndef OPEN_AIF_BEFORE_SCENARIO_SET /* FIXME : disable here, close after scenario set */
+ __avsys_close_aif();
+#endif
+
+ if (AVSYS_FAIL(avsys_audio_ascn_single_set(ASCN_CODEC_DISABLE_ON_SUSPEND))) {
+ avsys_error_r(AVAUDIO, "[%s] failed to set codec_disable_on_suspend\n", __func__);
+ }
+ control->p_path_status.playback |= PS_CODEC_DISABLE_ON_SUSPEND;
+ } else {
+ if (control->path_fixed_pid[PATH_FIXED_TYPE_CALL] < 0) {
+ avsys_warning(AVAUDIO, "Sound path for call released already\n");
+ } else {
+ avsys_warning(AVAUDIO, "Try to close call path from other process.. original pid[%d]\n", control->path_fixed_pid[PATH_FIXED_TYPE_CALL]);
+ avsys_warning(AVAUDIO, "Just mark handle as off\n");
+ }
+ }
+
+ if ((control->path_fixed & PATH_FIXED_WITH_CALL) == 0) {
+ avsys_error(AVAUDIO, "Call path release without call path request\n");
+ }
+ control->path_fixed &= ~PATH_FIXED_WITH_CALL;
+ control->path_fixed_pid[PATH_FIXED_TYPE_CALL] = -1;
+
+ break;
+
+ case AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO:
+ /* TODO: Reset & Codec disable on suspend script */
+ if (AVSYS_FAIL(avsys_audio_ascn_single_set(ASCN_CODEC_DISABLE_ON_SUSPEND))) {
+ avsys_error_r(AVAUDIO, "[%s] failed to set codec_disable_on_suspend\n", __func__);
+ }
+ control->p_path_status.playback |= PS_CODEC_DISABLE_ON_SUSPEND;
+
+ if (AVSYS_FAIL(avsys_audio_ascn_single_set(ASCN_STR_RESET))) {
+ avsys_error_r(AVAUDIO, "[%s] failed to set reset\n", __func__);
+ } else {
+ control->p_path_status.playback = PS_PATH_NONE;
+ }
+
+ /* TODO: Path fixed clear (path_fixed, path_fixed_pid) */
+ if ((control->path_fixed & PATH_FIXED_WITH_FMRADIO) == 0) {
+ avsys_error(AVAUDIO, "FM-Radio path release without radio path request\n");
+ }
+ control->path_fixed &= ~PATH_FIXED_WITH_FMRADIO;
+ control->path_fixed_pid[PATH_FIXED_TYPE_FMRADIO] = -1;
+ break;
+
+ default:
+ avsys_warning(AVAUDIO, "unexpected path release\n");
+ break;
+ }
+
+ if (control->path_fixed != PATH_FIXED_NONE) {
+ avsys_error(AVAUDIO, "Still remain another path_fixed request : 0x%08X\n", control->path_fixed);
+ avsys_error(AVAUDIO, "This is not expected condition\n");
+ } else {
+ avsys_warning(AVAUDIO, "Path Release to default condition....\n");
+ control->gain.playback = AVSYS_AUDIO_PLAYBACK_GAIN_AP;
+ control->gain.capture = AVSYS_AUDIO_CAPTURE_GAIN_AP;
+ control->path.playback = AVSYS_AUDIO_PATH_EX_SPK;
+ control->path.capture = AVSYS_AUDIO_PATH_EX_MIC;
+
+ switch(control->route_policy)
+ {
+ case AVSYS_AUDIO_ROUTE_POLICY_DEFAULT:
+ case AVSYS_AUDIO_ROUTE_POLICY_IGNORE_A2DP:
+ control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_AUTO_WITH_MUTE;
+ control->option.playback = AVSYS_AUDIO_PATH_OPTION_JACK_AUTO;
+ control->option.capture = AVSYS_AUDIO_PATH_OPTION_JACK_AUTO;
+ break;
+
+ case AVSYS_AUDIO_ROUTE_POLICY_HANDSET_ONLY:
+ control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_AUTO_WITHOUT_MUTE;
+ control->option.playback = AVSYS_AUDIO_PATH_OPTION_NONE;
+ control->option.capture = AVSYS_AUDIO_PATH_OPTION_NONE;
+ break;
+
+ default:
+ break;
+ }
+
+ control->p_path_status.playback = PS_PATH_NONE;
+ control->p_path_status.capture = PS_PATH_NONE;
+ control->p_gain_status.playback = GS_GAIN_NONE;
+ control->p_gain_status.capture = GS_GAIN_NONE;
+
+ /* Playback */
+ err = __avsys_audio_path_set_ascn_ap_playback(control);
+ if (AVSYS_SUCCESS(err)) {
+ err = __avsys_audio_path_set_hw_controls(control);
+ if (AVSYS_FAIL(err)) {
+ avsys_error(AVAUDIO, "Update logical volume failure\n");
+ }
+ } else {
+ avsys_error(AVAUDIO, "Set ap playback failure\n");
+ }
+
+ /* Capture */
+ err = __avsys_audio_path_set_ascn_ap_capture(control);
+ if (AVSYS_FAIL(err)) {
+ avsys_error(AVAUDIO, "Set ap capture failure\n");
+ }
+ }
+
+ /* FIXME : Close AIF, this will be moved before scneario set */
+#ifdef OPEN_AIF_BEFORE_SCENARIO_SET
+ if ((local_gain.playback == AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL || local_gain.playback == AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL) &&
+ getpid() == control->path_fixed_pid[PATH_FIXED_TYPE_CALL]) {
+ __avsys_close_aif();
+ }
+#endif
+
+ return err;
+}
+
+int avsys_audio_path_ex_set_path(int gain, int out, int in, int option)
+{
+ avsys_audio_path_ex_info_t *control = NULL;
+ avsys_audio_path_ex_info_t **temp = NULL;
+ gain_info_t local_gain = { -1, -1 };
+ gain_info_t req_gain = { -1, -1 };
+ pid_t current_pid;
+ int err = AVSYS_STATE_SUCCESS;
+ char req_release_path = 0;
+ char AIF_control[AIF_DEVICE_MAX] = { CMD_DEVICE_NONE, CMD_DEVICE_NONE, CMD_DEVICE_NONE, CMD_DEVICE_NONE };
+ int iAIF = 0;
+
+ avsys_warning(AVAUDIO, "=================== [Input Param] gain %d, out %d, in %d, opt 0x%x ====================\n", gain, out, in, option);
+
+ /* Determine REQUESTs */
+ switch (gain) {
+ case AVSYS_AUDIO_GAIN_EX_KEYTONE:
+ case AVSYS_AUDIO_GAIN_EX_ALARMTONE:
+ case AVSYS_AUDIO_GAIN_EX_AUDIOPLAYER:
+ case AVSYS_AUDIO_GAIN_EX_VIDEOPLAYER:
+ case AVSYS_AUDIO_GAIN_EX_CAMERA:
+ case AVSYS_AUDIO_GAIN_EX_GAME:
+ req_gain.playback = AVSYS_AUDIO_PLAYBACK_GAIN_AP;
+ break;
+
+ case AVSYS_AUDIO_GAIN_EX_RINGTONE:
+ case AVSYS_AUDIO_GAIN_EX_CALLTONE:
+ req_gain.playback = AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT;
+ break;
+
+ case AVSYS_AUDIO_GAIN_EX_VOICEREC:
+ case AVSYS_AUDIO_GAIN_EX_CAMCORDER:
+ req_gain.capture = AVSYS_AUDIO_CAPTURE_GAIN_AP;
+ break;
+
+ case AVSYS_AUDIO_GAIN_EX_VOICECALL:
+ req_gain.playback = AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL;
+ req_gain.capture = AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL;
+ if (out == AVSYS_AUDIO_PATH_EX_NONE && in == AVSYS_AUDIO_PATH_EX_NONE)
+ req_release_path = 1;
+ break;
+
+ case AVSYS_AUDIO_GAIN_EX_VIDEOCALL:
+ req_gain.playback = AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL;
+ req_gain.capture = AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL;
+ if (out == AVSYS_AUDIO_PATH_EX_NONE && in == AVSYS_AUDIO_PATH_EX_NONE)
+ req_release_path = 1;
+ break;
+
+ case AVSYS_AUDIO_GAIN_EX_FMRADIO:
+ req_gain.playback = AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO;
+ req_gain.capture = AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO;
+ if (out == AVSYS_AUDIO_PATH_EX_NONE && in == AVSYS_AUDIO_PATH_EX_NONE)
+ req_release_path = 1;
+ break;
+ }
+
+ /* Get avsys shared memeory */
+ temp = &control;
+ if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+ /* LOCK */
+ if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_lock_sync() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ current_pid = getpid(); /* moved from below */
+
+ /* Check FORCED option */
+ if (option & AVSYS_AUDIO_PATH_OPTION_FORCED) {
+ DO_IF_VALID(req_gain.playback, local_gain.playback = req_gain.playback)
+ DO_IF_VALID(req_gain.capture, local_gain.capture = req_gain.capture)
+ } else {
+ DO_IF_VALID(req_gain.playback, local_gain.playback = g_playback_gain_select_data[control->gain.playback][req_gain.playback])
+ DO_IF_VALID(req_gain.capture, local_gain.capture = g_capture_gain_select_data[control->gain.capture][req_gain.capture])
+ }
+
+ avsys_info(AVAUDIO, "Gain : req(%d,%d) local(%d,%d)\n", req_gain.playback, req_gain.capture, local_gain.playback, local_gain.capture);
+
+ /* Check path fixed process alive. */
+ if (control->path_fixed & PATH_FIXED_WITH_CALL) {
+ if (AVSYS_FAIL(avsys_check_process(control->path_fixed_pid[PATH_FIXED_TYPE_CALL]))) {
+ control->path_fixed &= ~PATH_FIXED_WITH_CALL;
+ }
+ }
+ if (control->path_fixed & PATH_FIXED_WITH_FMRADIO) {
+ if (AVSYS_FAIL(avsys_check_process(control->path_fixed_pid[PATH_FIXED_TYPE_FMRADIO]))) {
+ control->path_fixed &= ~PATH_FIXED_WITH_FMRADIO;
+ }
+ }
+ if (control->path_fixed == PATH_FIXED_NONE) {
+ /* forced gain setting when path fixed by dead process */
+ if (req_gain.playback != local_gain.playback) {
+ local_gain.playback = req_gain.playback;
+ }
+ if (req_gain.capture != local_gain.capture) {
+ local_gain.capture = req_gain.capture;
+ }
+ }
+
+ if (CHECK_VALID(local_gain.playback)) {
+ if (g_playback_path_select_data[local_gain.playback][out] == 0) {
+ avsys_error(AVAUDIO, "[PLAYBACK] Does not support request sound path : conv gain %d, out path %d\n", local_gain.playback, out);
+ if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+ return AVSYS_STATE_ERR_INVALID_STATE;
+ }
+ }
+ if (CHECK_VALID(local_gain.capture)) {
+ if (g_capture_path_select_data[local_gain.capture][in] == 0) {
+ avsys_error(AVAUDIO, "[CAPTURE] Does not support request sound path : conv gain %d, in path %d\n", local_gain.capture, in);
+ if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+ return AVSYS_STATE_ERR_INVALID_STATE;
+ }
+ }
+ /* overwrite local_gain with current gain if it is simplex sound path */
+ DO_IF_INVALID(local_gain.playback, local_gain.playback = control->gain.playback)
+ DO_IF_INVALID(local_gain.capture, local_gain.capture = control->gain.capture)
+ control->pregain = control->gain;
+ control->gain = local_gain;
+
+ DO_IF_VALID(req_gain.playback, control->reqgain.playback = req_gain.playback)
+ DO_IF_VALID(req_gain.capture, control->reqgain.capture = req_gain.capture)
+ DO_IF_VALID(local_gain.playback, control->option.playback = option)
+ DO_IF_VALID(local_gain.capture, control->option.capture = option)
+
+ /* Check for Release PATH */
+ if (req_release_path && (req_gain.playback == local_gain.playback) && (req_gain.capture == local_gain.capture)) {
+ avsys_warning(AVAUDIO,"Release path for %d %d\n", local_gain.playback, local_gain.capture);
+
+ err = __avsys_audio_release_path(local_gain, control);
+ goto FINISHED;
+ }
+ if (CHECK_VALID(req_gain.playback)) {
+ if(req_gain.playback != local_gain.playback) {
+ avsys_warning(AVAUDIO, "Sound Path is protected. use current configuration (playback_gain %d, out %d, opt 0x%x)\n",
+ local_gain.playback, control->path.playback, control->option.playback);
+ if (req_gain.playback == AVSYS_AUDIO_PLAYBACK_GAIN_AP) {
+ control->backup_gain.playback = control->reqgain.playback;
+ control->backup_path.playback = out;
+ }
+ } else {
+ control->path.playback = out;
+ control->backup_gain.playback = local_gain.playback;
+ control->backup_path.playback = out;
+
+ switch (local_gain.playback) {
+ case AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL:
+ control->path_fixed_pid[PATH_FIXED_TYPE_CALL] = current_pid;
+ case AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT:
+ if (control->path.playback == AVSYS_AUDIO_PATH_EX_BTHEADSET) {
+ SET_AIF(AIF3_PLAYBACK);
+ SET_AIF(AIF3_CAPTURE);
+ }
+ break;
+
+ case AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL:
+ control->path_fixed_pid[PATH_FIXED_TYPE_CALL] = current_pid;
+ SET_AIF(AIF2_PLAYBACK);
+
+ if (control->path.playback == AVSYS_AUDIO_PATH_EX_BTHEADSET) {
+ SET_AIF(AIF3_PLAYBACK);
+ }
+ break;
+
+ case AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO:
+ control->path_fixed_pid[PATH_FIXED_TYPE_FMRADIO] = current_pid;
+ break;
+ }
+ }
+ }
+
+ if (CHECK_VALID(req_gain.capture)) {
+ if (req_gain.capture != local_gain.capture) {
+ avsys_warning(AVAUDIO, "Sound Path is protected. use current configuration (capture_gain %d, in %d, opt 0x%x)\n",
+ local_gain.capture, control->path.capture, control->option.capture);
+ if (req_gain.capture == AVSYS_AUDIO_CAPTURE_GAIN_AP) {
+ control->backup_gain.capture = control->reqgain.capture;
+ control->backup_path.capture = in;
+ }
+ } else {
+ control->path.capture = in;
+ control->backup_gain.capture = local_gain.capture;
+ control->backup_path.capture = in;
+
+ switch (local_gain.capture) {
+ case AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL:
+ control->path_fixed_pid[PATH_FIXED_TYPE_CALL] = current_pid;
+ if (control->path.capture == AVSYS_AUDIO_PATH_EX_BTMIC) {
+ SET_AIF(AIF3_CAPTURE);
+ }
+ break;
+
+ case AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL:
+ control->path_fixed_pid[PATH_FIXED_TYPE_CALL] = current_pid;
+ SET_AIF(AIF2_CAPTURE);
+
+ if (control->path.capture == AVSYS_AUDIO_PATH_EX_BTMIC) {
+ SET_AIF(AIF3_CAPTURE);
+ }
+ break;
+
+ case AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO:
+ control->path_fixed_pid[PATH_FIXED_TYPE_FMRADIO] = current_pid;
+ break;
+ }
+ }
+ }
+
+ /* Open AIFs */
+ /* FIXME: this will be moved to after alsa scenraio set */
+#ifdef OPEN_AIF_BEFORE_SCENARIO_SET
+ err = __avsys_open_aif(AIF_control);
+#endif
+
+ /* Do ALSA scenario control based on gain */
+ /* Playback */
+ if (local_gain.playback == AVSYS_AUDIO_PLAYBACK_GAIN_AP) {
+ avsys_warning(AVAUDIO, "playback gain : ap\n");
+ err = __avsys_audio_path_set_ascn_ap_playback(control);
+ if (AVSYS_SUCCESS(err)) {
+ err = __avsys_audio_path_set_hw_controls(control);
+ }
+ } else if(local_gain.playback == AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT) {
+ avsys_warning(AVAUDIO,"playback gain : callalert\n");
+ err = __avsys_audio_path_set_ascn_ap_playback(control);
+ if (AVSYS_SUCCESS(err)) {
+ err = __avsys_audio_path_set_hw_controls(control);
+ }
+ } else if (local_gain.playback == AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO &&
+ local_gain.capture == AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO) {
+ avsys_warning(AVAUDIO, "fmradio gain\n");
+ err = __avsys_audio_path_set_ascn_fmradio(control);
+ } else if (local_gain.playback == AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL &&
+ local_gain.capture == AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL) {
+ avsys_warning(AVAUDIO, "voicecall gain\n");
+ err = __avsys_audio_path_set_ascn_voicecall(control);
+ } else if (local_gain.playback == AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL &&
+ local_gain.capture == AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL) {
+ avsys_warning(AVAUDIO, "videocall gain\n");
+ err = __avsys_audio_path_set_ascn_videocall(control);
+ }
+ /* Capture */
+ if (local_gain.capture == AVSYS_AUDIO_CAPTURE_GAIN_AP) {
+ avsys_warning(AVAUDIO, "capture gain : ap\n");
+ err = __avsys_audio_path_set_ascn_ap_capture(control);
+ }
+#ifndef OPEN_AIF_BEFORE_SCENARIO_SET
+ err = __avsys_open_aif(AIF_control);
+#endif
+
+FINISHED:
+ /* UnLOCK */
+ if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+ avsys_info(AVAUDIO, "------------------------------------------------\n");
+ return err;
+}
+
+int avsys_audio_path_ex_get_path(int *gain, int *out, int *in, int *option)
+{
+ avsys_audio_path_ex_info_t *control = NULL;
+ avsys_audio_path_ex_info_t ** temp = NULL;
+
+ if(gain == NULL || out == NULL || in == NULL || option == NULL) {
+ avsys_error(AVAUDIO,"Invalid parameter\n");
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ }
+
+ temp = &control;
+
+ if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+ if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_lock_sync() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ switch (control->gain.playback) {
+ case AVSYS_AUDIO_PLAYBACK_GAIN_AP:
+ *gain = AVSYS_AUDIO_GAIN_EX_KEYTONE;
+ *out = control->path.playback;
+ *in = AVSYS_AUDIO_PATH_EX_NONE;
+ *option = control->option.playback;
+ break;
+ case AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT:
+ *gain = AVSYS_AUDIO_GAIN_EX_RINGTONE;
+ *out = control->path.playback;
+ *in = AVSYS_AUDIO_PATH_EX_NONE;
+ *option = control->option.playback;
+ break;
+ case AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL:
+ *gain = AVSYS_AUDIO_GAIN_EX_VOICECALL;
+ *out = control->path.playback;
+ *in = control->path.capture;
+ *option = control->option.playback;
+ break;
+ case AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL:
+ *gain = AVSYS_AUDIO_GAIN_EX_VIDEOCALL;
+ *out = control->path.playback;
+ *in = control->path.capture;
+ *option = control->option.playback;
+ break;
+ case AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO:
+ *gain = AVSYS_AUDIO_GAIN_EX_FMRADIO;
+ *out = control->path.playback;
+ *in = control->path.capture;
+ *option = control->option.playback;
+ break;
+ }
+
+ if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ return AVSYS_STATE_SUCCESS;
+}
+
+int avsys_audio_path_ex_set_amp(const int onoff)
+{
+ //not yet implemented.
+ return AVSYS_STATE_SUCCESS;
+}
+
+int avsys_audio_path_ex_set_mute(const int mute)
+{
+ avsys_audio_path_ex_info_t *control = NULL;
+ avsys_audio_path_ex_info_t **temp = NULL;
+
+ temp = &control;
+
+ if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ if (control == NULL) {
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ }
+
+ if (mute == AVSYS_AUDIO_UNMUTE || mute == AVSYS_AUDIO_MUTE) {
+ if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_lock_sync() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ if (control->mute == mute) {
+ avsys_info(AVAUDIO, "[Path Mute] skip mute ctrl op: %d\n", mute);
+ if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() 2 failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+ return AVSYS_STATE_SUCCESS;
+ } else {
+ control->mute = mute;
+ avsys_warning(AVAUDIO, "[Path Mute] run mute ctrl op: %d\n", mute);
+ }
+
+ if (control->mute) {
+ if (AVSYS_FAIL(avsys_audio_ascn_single_set(ASCN_STR_PLAYBACK_MUTE))) {
+ if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() 1 failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+ avsys_error(AVAUDIO, "Mute fail %s\n", __func__);
+ return AVSYS_STATE_ERR_IO_CONTROL;
+ }
+ } else {
+ if (AVSYS_FAIL(avsys_audio_ascn_single_set(ASCN_STR_PLAYBACK_UNMUTE))) {
+ if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() 1 failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+ avsys_error(AVAUDIO, "Unmute fail %s\n", __func__);
+ return AVSYS_STATE_ERR_IO_CONTROL;
+ }
+ }
+
+ if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() 2 failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+ } else {
+ int mute_nolock;
+ if (mute == AVSYS_AUDIO_UNMUTE_NOLOCK) /* set nomalize */
+ mute_nolock = AVSYS_AUDIO_UNMUTE;
+ else
+ mute_nolock = AVSYS_AUDIO_MUTE;
+
+ if (control->mute == mute_nolock) {
+ avsys_info(AVAUDIO, "[Path Mute] skip mute ctrl op: %d\n", mute);
+ return AVSYS_STATE_SUCCESS;
+ } else {
+ control->mute = mute_nolock;
+ avsys_warning(AVAUDIO, "[Path Mute] run mute ctrl op: %d\n", mute);
+ }
+
+ if (control->mute) {
+ if (AVSYS_FAIL(avsys_audio_ascn_single_set(ASCN_STR_PLAYBACK_MUTE))) {
+ avsys_error(AVAUDIO, "Mute fail %s\n", __func__);
+ return AVSYS_STATE_ERR_IO_CONTROL;
+ }
+ } else {
+ if (AVSYS_FAIL(avsys_audio_ascn_single_set(ASCN_STR_PLAYBACK_UNMUTE))) {
+ avsys_error(AVAUDIO, "Unmute fail %s\n", __func__);
+ return AVSYS_STATE_ERR_IO_CONTROL;
+ }
+ }
+ }
+
+ if (mute == AVSYS_AUDIO_UNMUTE || mute == AVSYS_AUDIO_UNMUTE_NOLOCK)
+ avsys_info_r(AVAUDIO, "Global Mute Disabled\n");
+ else if (mute == AVSYS_AUDIO_MUTE || mute == AVSYS_AUDIO_MUTE_NOLOCK)
+ avsys_info_r(AVAUDIO, "Global Mute Enabled\n");
+ return AVSYS_STATE_SUCCESS;
+}
+
+int avsys_audio_path_ex_get_mute(int *mute)
+{
+ avsys_audio_path_ex_info_t *control = NULL;
+ avsys_audio_path_ex_info_t **temp = NULL;
+
+ temp = &control;
+
+ if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ if (control == NULL) {
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ }
+
+ if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_lock_sync() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ *mute = control->mute;
+
+ if (AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_unlock_sync() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ return AVSYS_STATE_SUCCESS;
+}
+
+static int __avsys_audio_path_set_ascn_ap_playback(avsys_audio_path_ex_info_t *control)
+{
+ int cmd_gain[2] = { 0, 0 };
+ int cmd_path[3] = { 0, 0, 0 };
+ char callalert_mode = 0;
+
+ avsys_info(AVAUDIO, "<< path.playback = %d, option = %x, gain.playback = %d, inserted = %d\n",
+ control->path.playback, control->option.playback, control->gain.playback, control->inserted);
+
+ callalert_mode = (control->gain.playback == AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT) ? 1 : 0;
+ control->path_fixed = PATH_FIXED_NONE;
+
+ switch (control->path.playback) {
+ case AVSYS_AUDIO_PATH_EX_SPK:
+ if (control->option.playback & AVSYS_AUDIO_PATH_OPTION_LEGACY_MODE) {
+ avsys_warning(AVAUDIO, "Does not support legacy mode anymore\n");
+ }
+
+ if (control->option.playback & AVSYS_AUDIO_PATH_OPTION_DUAL_OUT) {
+ if (callalert_mode) {
+ control->gain_status.playback = GS_AP_TO_SPK_CALLALERT;
+ cmd_gain[0] = INPUT_AP | OUTPUT_STEREO_SPK | GAIN_CALLALERT;
+ } else {
+ control->gain_status.playback = GS_AP_TO_SPK;
+ cmd_gain[0] = INPUT_AP | OUTPUT_STEREO_SPK | GAIN_MODE;
+ }
+
+ if (control->inserted == AVSYS_AUDIO_INSERTED_NONE) {
+ control->path_status.playback = PS_AP_TO_SPK;
+ cmd_path[0] = INPUT_AP | OUTPUT_STEREO_SPK;
+ } else {
+ control->path_status.playback = PS_AP_TO_SPK | PS_AP_TO_HEADSET;
+ cmd_path[0] = INPUT_AP | OUTPUT_STEREO_SPK;
+ cmd_path[1] = INPUT_AP | OUTPUT_HEADSET;
+ }
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
+ } else {
+ if (control->option.playback & AVSYS_AUDIO_PATH_OPTION_JACK_AUTO) {
+ control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_AUTO_WITH_MUTE;
+ if (control->inserted == AVSYS_AUDIO_INSERTED_NONE) {
+ if (callalert_mode) {
+ control->gain_status.playback = GS_AP_TO_SPK_CALLALERT;
+ cmd_gain[0] = INPUT_AP | OUTPUT_STEREO_SPK | GAIN_CALLALERT;
+ } else {
+ control->gain_status.playback = GS_AP_TO_SPK;
+ cmd_gain[0] = INPUT_AP | OUTPUT_STEREO_SPK | GAIN_MODE;
+ }
+ control->path_status.playback = PS_AP_TO_SPK;
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
+ cmd_path[0] = INPUT_AP | OUTPUT_STEREO_SPK;
+ } else {
+ if (callalert_mode) {
+ control->gain_status.playback = GS_AP_TO_HEADSET_CALLALERT;
+ cmd_gain[0] = INPUT_AP | OUTPUT_HEADSET | GAIN_CALLALERT;
+ } else {
+ control->gain_status.playback = GS_AP_TO_HEADSET;
+ cmd_gain[0] = INPUT_AP | OUTPUT_HEADSET | GAIN_MODE;
+ }
+ control->path_status.playback = PS_AP_TO_HEADSET;
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET;
+ cmd_path[0] = INPUT_AP | OUTPUT_HEADSET;
+ }
+ } else {
+ if (callalert_mode) {
+ control->gain_status.playback = GS_AP_TO_SPK_CALLALERT;
+ cmd_gain[0] = INPUT_AP | OUTPUT_STEREO_SPK | GAIN_CALLALERT;
+ } else {
+ control->gain_status.playback = GS_AP_TO_SPK;
+ cmd_gain[0] = INPUT_AP | OUTPUT_STEREO_SPK | GAIN_MODE;
+ }
+ control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_AUTO_WITHOUT_MUTE;
+ control->path_status.playback = PS_AP_TO_SPK;
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
+
+ cmd_path[0] = INPUT_AP | OUTPUT_STEREO_SPK;
+ }
+ }
+ break;
+
+ case AVSYS_AUDIO_PATH_EX_RECV:
+ if (control->option.playback & AVSYS_AUDIO_PATH_OPTION_LEGACY_MODE) {
+ avsys_warning(AVAUDIO, "Does not support legacy mode anymore\n");
+ }
+
+ if (control->option.playback & AVSYS_AUDIO_PATH_OPTION_JACK_AUTO) {
+ control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_AUTO_WITH_MUTE;
+ if (control->inserted == AVSYS_AUDIO_INSERTED_NONE) {
+ control->gain_status.playback = GS_AP_TO_RECV;
+ control->path_status.playback = PS_AP_TO_RECV;
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
+ cmd_gain[0] = INPUT_AP | OUTPUT_RECV | GAIN_MODE;
+ cmd_path[0] = INPUT_AP | OUTPUT_RECV;
+ } else {
+ if (callalert_mode) {
+ control->gain_status.playback = GS_AP_TO_HEADSET_CALLALERT;
+ cmd_gain[0] = INPUT_AP | OUTPUT_HEADSET | GAIN_CALLALERT;
+ } else {
+ control->gain_status.playback = GS_AP_TO_HEADSET;
+ cmd_gain[0] = INPUT_AP | OUTPUT_HEADSET | GAIN_MODE;
+ }
+ control->path_status.playback = PS_AP_TO_HEADSET;
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET;
+ cmd_path[0] = INPUT_AP | OUTPUT_HEADSET;
+ }
+ } else {
+ control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_MANUAL;
+ control->gain_status.playback = GS_AP_TO_RECV;
+ control->path_status.playback = PS_AP_TO_RECV;
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
+ cmd_gain[0] = INPUT_AP | OUTPUT_RECV | GAIN_MODE;
+ cmd_path[0] = INPUT_AP | OUTPUT_RECV;
+ }
+ break;
+
+ case AVSYS_AUDIO_PATH_EX_HEADSET:
+ control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_MANUAL;
+ if (callalert_mode) {
+ control->gain_status.playback = GS_AP_TO_HEADSET_CALLALERT;
+ cmd_gain[0] = INPUT_AP | OUTPUT_HEADSET | GAIN_CALLALERT;
+ } else {
+ control->gain_status.playback = GS_AP_TO_HEADSET;
+ cmd_gain[0] = INPUT_AP | OUTPUT_HEADSET | GAIN_MODE;
+ }
+ control->path_status.playback = PS_AP_TO_HEADSET;
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET;
+ cmd_path[0] = INPUT_AP | OUTPUT_HEADSET;
+ break;
+
+ case AVSYS_AUDIO_PATH_EX_HDMI:
+ avsys_warning(AVAUDIO, "Does not support dedicated HDMI sound path\n");
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
+ break;
+
+ case AVSYS_AUDIO_PATH_EX_BTHEADSET:
+ control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_MANUAL;
+ control->gain_status.playback = GS_AP_TO_BT;
+ control->path_status.playback = PS_AP_TO_BT;
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_BTHEADSET;
+ cmd_gain[0] = INPUT_AP | OUTPUT_BT_HEADSET | GAIN_MODE;
+ cmd_path[0] = INPUT_AP | OUTPUT_BT_HEADSET;
+ break;
+ case AVSYS_AUDIO_PATH_EX_HANDSFREE:
+ default: /* DEFAULT PATH CONTROL TO NONE */
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
+ break;
+ }
+
+ //avsys_warning(AVAUDIO,"pg(0x%X), g(0x%X), pp(0x%X), p(0x%X)\n", control->p_gain_status, control->gain_status, control->p_path_status, control->path_status);
+ if ((control->p_path_status.playback != control->path_status.playback) || control->gain_debug_mode == 1) {
+ avsys_warning(AVAUDIO, "Run Alsa Scenario Script\n");
+ RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_gain, 1, ASCN_RESET_PLAYBACK))
+ control->p_gain_status.playback = control->gain_status.playback;
+ RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_path, 2, ASCN_RESET_NONE))
+ control->p_path_status.playback = control->path_status.playback;
+ }
+
+ avsys_info(AVAUDIO, ">> leave");
+ return AVSYS_STATE_SUCCESS;
+}
+
+static int __avsys_audio_path_set_ascn_voicecall(avsys_audio_path_ex_info_t *control)
+{
+ return AVSYS_STATE_SUCCESS;
+}
+
+static int __avsys_audio_path_set_ascn_videocall(avsys_audio_path_ex_info_t *control)
+{
+ int cmd_gain[2] = { 0, 0 };
+ int cmd_path[3] = { 0, 0, 0 };
+ int skip_clear = 0;
+ control->path_fixed = PATH_FIXED_WITH_CALL;
+ switch (control->path.playback) {
+ case AVSYS_AUDIO_PATH_EX_NONE:
+ if (control->option.playback & AVSYS_AUDIO_PATH_OPTION_LEGACY_MODE) {
+ /* Legacy mode does not effect here... */
+ avsys_warning(AVAUDIO, "legacy mode option %s\n", __func__);
+ }
+ control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_MANUAL;
+ if (control->reqgain.playback == control->gain.playback) {
+ avsys_warning(AVAUDIO, "Output block on videocall");
+ } else {
+ avsys_warning(AVAUDIO, "Ignore another path setting request during voicecall");
+ }
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
+ break;
+
+ case AVSYS_AUDIO_PATH_EX_SPK:
+ if (control->reqgain.playback == control->gain.playback) {
+ if (control->option.playback & AVSYS_AUDIO_PATH_OPTION_JACK_AUTO) {
+ control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_AUTO_WITH_MUTE;
+ if (control->inserted != AVSYS_AUDIO_INSERTED_NONE) {
+ control->gain_status.playback = GS_AP_TO_HEADSET;
+ control->path_status.playback = PS_AP_TO_HEADSET;
+ cmd_gain[0] = INPUT_AP | OUTPUT_HEADSET | GAIN_MODE;
+ cmd_path[0] = INPUT_AP | OUTPUT_HEADSET;
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET;
+ } else {
+ control->gain_status.playback = GS_AP_TO_SPK;
+ control->path_status.playback = PS_AP_TO_SPK;
+ cmd_gain[0] = INPUT_AP | OUTPUT_STEREO_SPK | GAIN_MODE;
+ cmd_path[0] = INPUT_AP | OUTPUT_STEREO_SPK;
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
+ }
+ } else { /* ear jack manual */
+ control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_MANUAL;
+ control->gain_status.playback = GS_AP_TO_SPK;
+ control->path_status.playback = PS_AP_TO_SPK;
+ cmd_gain[0] = INPUT_AP | OUTPUT_STEREO_SPK | GAIN_MODE;
+ cmd_path[0] = INPUT_AP | OUTPUT_STEREO_SPK;
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
+ }
+ } else { /* changed by priority */
+ avsys_warning(AVAUDIO, "Sound Path request during VT call ignored.");
+ }
+ break;
+
+ case AVSYS_AUDIO_PATH_EX_RECV:
+ if (control->gain.playback == control->reqgain.playback) {
+ if (control->option.playback & AVSYS_AUDIO_PATH_OPTION_JACK_AUTO) {
+ control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_AUTO_WITH_MUTE;
+ if (control->inserted != AVSYS_AUDIO_INSERTED_NONE) {
+ control->gain_status.playback = GS_AP_TO_HEADSET;
+ control->path_status.playback = PS_AP_TO_HEADSET;
+ cmd_gain[0] = INPUT_AP | OUTPUT_HEADSET | GAIN_MODE;
+ cmd_path[0] = INPUT_AP | OUTPUT_HEADSET;
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET;
+ } else {
+ control->gain_status.playback = GS_AP_TO_RECV;
+ control->path_status.playback = PS_AP_TO_RECV;
+ cmd_gain[0] = INPUT_AP | OUTPUT_RECV | GAIN_MODE;
+ cmd_path[0] = INPUT_AP | OUTPUT_RECV;
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
+ }
+ } else { /* ear jack manual */
+ control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_MANUAL;
+ control->gain_status.playback = GS_AP_TO_RECV;
+ control->path_status.playback = PS_AP_TO_RECV;
+ cmd_gain[0] = INPUT_AP | OUTPUT_RECV | GAIN_MODE;
+ cmd_path[0] = INPUT_AP | OUTPUT_RECV;
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
+ }
+ } else { /* changed by priority */
+ avsys_warning(AVAUDIO, "Sound Path request during VT call ignored.");
+ } /* reqgain, gain */
+ break;
+
+ case AVSYS_AUDIO_PATH_EX_HEADSET:
+ if (control->reqgain.playback == control->gain.playback) {
+ control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_MANUAL;
+ control->gain_status.playback = GS_AP_TO_HEADSET;
+ control->path_status.playback = PS_AP_TO_HEADSET;
+ cmd_gain[0] = INPUT_AP | OUTPUT_HEADSET | GAIN_MODE;
+ cmd_path[0] = INPUT_AP | OUTPUT_HEADSET;
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET;
+ } else {
+ avsys_warning(AVAUDIO, "Sound Path request during VT call ignored.");
+ }
+ break;
+
+ case AVSYS_AUDIO_PATH_EX_BTHEADSET:
+ if (control->reqgain.playback == control->gain.playback) {
+ control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_MANUAL;
+ control->gain_status.playback = GS_AP_TO_BT;
+ control->path_status.playback = PS_AP_TO_BT;
+ cmd_gain[0] = INPUT_AP | OUTPUT_BT_HEADSET | GAIN_MODE;
+ cmd_path[0] = INPUT_AP | OUTPUT_BT_HEADSET;
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_BTHEADSET;
+ } else {
+ avsys_warning(AVAUDIO, "Sound Path request during VT call ignored.");
+ }
+ break;
+
+ case AVSYS_AUDIO_PATH_EX_HANDSFREE:
+ default:
+ if (control->reqgain.playback == control->gain.playback) {
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
+ }
+ break;
+ }
+
+ switch (control->path.capture) {
+ case AVSYS_AUDIO_PATH_EX_NONE:
+ if (control->reqgain.capture == control->gain.capture) {
+ /* Clear modem input */
+ control->path_status.capture &= ~(PS_MAINMIC_TO_AP | PS_SUBMIC_TO_AP | PS_EARMIC_TO_AP | PS_BTMIC_TO_AP);
+ } else {
+ avsys_warning(AVAUDIO, "Ignore another path setting request during VT call (input)\n");
+ }
+ break;
+
+ case AVSYS_AUDIO_PATH_EX_MIC:
+ if (control->option.capture & AVSYS_AUDIO_PATH_OPTION_JACK_AUTO) {
+ if ((control->inserted == AVSYS_AUDIO_INSERTED_4) && (control->path_status.playback & PS_AP_TO_HEADSET)) {
+ control->gain_status.capture |= GS_EARMIC_TO_AP;
+ control->path_status.capture |= PS_EARMIC_TO_AP;
+ cmd_gain[1] = INPUT_EAR_MIC | OUTPUT_AP | GAIN_MODE;
+ cmd_path[1] = INPUT_EAR_MIC | OUTPUT_AP;
+ } else {
+ if (control->option.capture & AVSYS_AUDIO_PATH_OPTION_USE_SUBMIC) {
+ control->gain_status.capture |= GS_SUBMIC_TO_AP;
+ control->path_status.capture |= PS_SUBMIC_TO_AP;
+ cmd_gain[1] = INPUT_SUB_MIC | OUTPUT_AP | GAIN_MODE;
+ cmd_path[1] = INPUT_SUB_MIC | OUTPUT_AP;
+ } else {
+ control->gain_status.capture |= GS_MAINMIC_TO_AP;
+ control->path_status.capture |= PS_MAINMIC_TO_AP;
+ cmd_gain[1] = INPUT_MAIN_MIC | OUTPUT_AP | GAIN_MODE;
+ cmd_path[1] = INPUT_MAIN_MIC | OUTPUT_AP;
+ }
+ }
+ } else {
+ if (control->option.capture & AVSYS_AUDIO_PATH_OPTION_USE_SUBMIC) {
+ control->gain_status.capture |= GS_SUBMIC_TO_AP;
+ control->path_status.capture |= PS_SUBMIC_TO_AP;
+ cmd_gain[1] = INPUT_SUB_MIC | OUTPUT_AP | GAIN_MODE;
+ cmd_path[1] = INPUT_SUB_MIC | OUTPUT_AP;
+ } else {
+ control->gain_status.capture |= GS_MAINMIC_TO_AP;
+ control->path_status.capture |= PS_MAINMIC_TO_AP;
+ cmd_gain[1] = INPUT_MAIN_MIC | OUTPUT_AP | GAIN_MODE;
+ cmd_path[1] = INPUT_MAIN_MIC | OUTPUT_AP;
+ }
+ }
+ break;
+
+ case AVSYS_AUDIO_PATH_EX_HEADSETMIC:
+ control->gain_status.capture |= GS_EARMIC_TO_AP;
+ control->path_status.capture |= PS_EARMIC_TO_AP;
+ cmd_gain[1] = INPUT_EAR_MIC | OUTPUT_AP | GAIN_MODE;
+ cmd_path[1] = INPUT_EAR_MIC | OUTPUT_AP;
+ break;
+
+ case AVSYS_AUDIO_PATH_EX_BTMIC:
+ control->gain_status.capture |= GS_BTMIC_TO_AP;
+ control->path_status.capture |= PS_BTMIC_TO_AP;
+ cmd_gain[1] = INPUT_BT_MIC | OUTPUT_AP | GAIN_MODE;
+ cmd_path[1] = INPUT_BT_MIC | OUTPUT_AP;
+
+ break;
+ case AVSYS_AUDIO_PATH_EX_HANDSFREE:
+ default:
+ break;
+ }
+
+ if((control->p_path_status.playback != control->path_status.playback)
+ || ((control->p_path_status.capture != control->path_status.capture)) || control->gain_debug_mode == 1) {
+ if(!skip_clear) {
+ RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_single_set(ASCN_STR_RESET))
+ }
+ RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_gain, 2, ASCN_RESET_NONE))
+ control->p_gain_status = control->gain_status; /* both playback and capture */
+ RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_path, 2, ASCN_RESET_NONE))
+ control->p_path_status = control->path_status; /* both playback and capture */
+ }
+
+ return AVSYS_STATE_SUCCESS;
+}
+
+
+static int __avsys_audio_path_set_ascn_fmradio(avsys_audio_path_ex_info_t *control)
+{
+ int cmd_gain[2] = { 0, 0 };
+ int cmd_path[3] = { 0, 0, 0 };
+ int skip_clear = 0;
+ int skip_clear_record = 0;
+ int gain_idx = 0;
+ int path_idx = 0;
+ control->path_fixed = PATH_FIXED_WITH_FMRADIO;
+ switch (control->path.playback) {
+ case AVSYS_AUDIO_PATH_EX_NONE:
+ control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_MANUAL;
+ control->gain_status.playback = GS_FMRADIO_TO_SPK;
+ control->path_status.playback = PS_PATH_NONE;
+ cmd_gain[gain_idx++] = INPUT_FMRADIO | OUTPUT_STEREO_SPK | GAIN_MODE;
+ break;
+
+ case AVSYS_AUDIO_PATH_EX_SPK:
+ if (control->option.playback & AVSYS_AUDIO_PATH_OPTION_JACK_AUTO) {
+ control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_AUTO_WITHOUT_MUTE;
+ if (control->reqgain.playback == control->gain.playback) {
+ if (control->inserted != AVSYS_AUDIO_INSERTED_NONE) {
+ control->gain_status.playback = GS_FMRADIO_TO_HEADSET;
+ control->path_status.playback = PS_FMRADIO_TO_HEADSET;
+ cmd_gain[gain_idx++] = INPUT_FMRADIO | OUTPUT_HEADSET | GAIN_MODE;
+ cmd_path[path_idx++] = INPUT_FMRADIO | OUTPUT_HEADSET;
+ cmd_path[path_idx++] = INPUT_AP | OUTPUT_HEADSET;
+ } else {
+ control->gain_status.playback = GS_FMRADIO_TO_SPK;
+ control->path_status.playback = PS_FMRADIO_TO_SPK;
+ cmd_gain[gain_idx++] = INPUT_FMRADIO | OUTPUT_STEREO_SPK | GAIN_MODE;
+ cmd_path[path_idx++] = INPUT_FMRADIO | OUTPUT_STEREO_SPK;
+ cmd_path[path_idx++] = INPUT_AP | OUTPUT_STEREO_SPK;
+ }
+ } else {
+ /* append ap playback sound path */
+ control->path_status.playback = control->p_path_status.playback;
+ if (control->inserted != AVSYS_AUDIO_INSERTED_NONE) {
+ control->path_status.playback |= PS_AP_TO_HEADSET;
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET;
+ cmd_path[path_idx++] = INPUT_AP | OUTPUT_HEADSET;
+ } else {
+ control->path_status.playback |= PS_AP_TO_SPK;
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
+ cmd_path[path_idx++] = INPUT_AP | OUTPUT_STEREO_SPK;
+ }
+ skip_clear = 1;
+ }
+ } else { /* ear jack manual */
+ control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_MANUAL;
+ if (control->reqgain.playback == control->gain.playback) {
+ control->gain_status.playback = GS_FMRADIO_TO_SPK;
+ control->path_status.playback = PS_FMRADIO_TO_SPK;
+ cmd_gain[gain_idx++] = INPUT_FMRADIO | OUTPUT_STEREO_SPK | GAIN_MODE;
+ cmd_path[path_idx++] = INPUT_FMRADIO | OUTPUT_STEREO_SPK;
+ cmd_path[path_idx++] = INPUT_AP | OUTPUT_STEREO_SPK;
+ } else {
+ /* append ap playback sound path */
+ control->path_status.playback = control->p_path_status.playback;
+ control->path_status.playback |= PS_AP_TO_SPK;
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
+ cmd_path[path_idx++] = INPUT_AP | OUTPUT_STEREO_SPK;
+ skip_clear = 1;
+ }
+ }
+ break;
+
+ case AVSYS_AUDIO_PATH_EX_HEADSET:
+ control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_MANUAL;
+ if (control->reqgain.playback == control->gain.playback) {
+ control->gain_status.playback = GS_FMRADIO_TO_HEADSET;
+ control->path_status.playback = PS_FMRADIO_TO_HEADSET;
+ cmd_gain[gain_idx++] = INPUT_FMRADIO | OUTPUT_HEADSET | GAIN_MODE;
+ cmd_path[path_idx++] = INPUT_FMRADIO | OUTPUT_HEADSET;
+ cmd_path[path_idx++] = INPUT_AP | OUTPUT_HEADSET;
+ } else {
+ /* append ap playback */
+ control->path_status.playback = control->p_path_status.playback;
+ control->path_status.playback |= PS_AP_TO_HEADSET;
+ control->lvol_dev_type = AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET;
+ cmd_path[path_idx++] = INPUT_AP | OUTPUT_HEADSET;
+ skip_clear = 1;
+ }
+ break;
+ default:
+ break;
+ }
+
+ switch (control->path.capture) {
+ case AVSYS_AUDIO_PATH_EX_FMINPUT:
+ if (control->reqgain.capture == control->gain.capture) {
+ control->path_status.capture |= PS_FMRADIO_TO_AP;
+ cmd_path[path_idx++] = INPUT_FMRADIO | OUTPUT_AP;
+ if (control->reqgain.capture == control->pregain.capture) {
+ skip_clear_record = 1;
+ }
+ }
+ break;
+ default:
+ break;
+ }
+
+ if((control->p_path_status.playback != control->path_status.playback)
+ || (control->p_path_status.capture != control->path_status.capture) || control->gain_debug_mode == 1) {
+ if (skip_clear_record) {
+ RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_single_set(ASCN_STR_RESET_PLAYBACK))
+ } else if (!skip_clear) {
+ RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_single_set(ASCN_STR_RESET))
+ }
+ RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_gain, gain_idx, ASCN_RESET_NONE))
+ control->p_gain_status = control->gain_status; /* both playback & capture */
+ RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_path, path_idx, ASCN_RESET_NONE))
+ control->p_path_status = control->path_status; /* both playback & capture */
+ }
+
+ return AVSYS_STATE_SUCCESS;
+}
+
+static int __avsys_audio_path_set_ascn_ap_capture(avsys_audio_path_ex_info_t *control)
+{
+ int cmd_gain[2] = { 0, 0 };
+ int cmd_path[3] = { 0, 0, 0 };
+
+ avsys_info(AVAUDIO, "<< path.capture = %d, option = %x, gain.capture = %d, inserted = %d\n",
+ control->path.capture, control->option.capture, control->gain.capture, control->inserted);
+ switch(control->path.capture) {
+ case AVSYS_AUDIO_PATH_EX_MIC:
+ if (control->option.capture & AVSYS_AUDIO_PATH_OPTION_JACK_AUTO) {
+ control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_AUTO_WITH_MUTE;
+ if (control->inserted == AVSYS_AUDIO_INSERTED_4) {
+ control->gain_status.capture = GS_EARMIC_TO_AP;
+ control->path_status.capture = PS_EARMIC_TO_AP;
+ cmd_gain[0] = INPUT_EAR_MIC | OUTPUT_AP | GAIN_MODE;
+ cmd_path[0] = INPUT_EAR_MIC | OUTPUT_AP;
+ } else {
+ if (control->option.capture & AVSYS_AUDIO_PATH_OPTION_USE_SUBMIC) {
+ control->gain_status.capture = GS_SUBMIC_TO_AP;
+ control->path_status.capture = PS_SUBMIC_TO_AP;
+ cmd_gain[0] = INPUT_SUB_MIC | OUTPUT_AP | GAIN_MODE;
+ cmd_path[0] = INPUT_SUB_MIC | OUTPUT_AP;
+ } else if (control->option.capture & AVSYS_AUDIO_PATH_OPTION_USE_STEREOMIC) {
+ control->gain_status.capture = GS_STEREOMIC_TO_AP;
+ control->path_status.capture = PS_STEREOMIC_TO_AP;
+ cmd_gain[0] = INPUT_STEREO_MIC | OUTPUT_AP | GAIN_MODE;
+ cmd_path[0] = INPUT_STEREO_MIC | OUTPUT_AP;
+ } else {
+ control->gain_status.capture = GS_MAINMIC_TO_AP;
+ control->path_status.capture = PS_MAINMIC_TO_AP;
+ cmd_gain[0] = INPUT_MAIN_MIC | OUTPUT_AP | GAIN_MODE;
+ cmd_path[0] = INPUT_MAIN_MIC | OUTPUT_AP;
+ }
+ }
+ } else {
+ control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_AUTO_WITHOUT_MUTE;
+ if (control->option.capture & AVSYS_AUDIO_PATH_OPTION_USE_SUBMIC) {
+ control->gain_status.capture = GS_SUBMIC_TO_AP;
+ control->path_status.capture = PS_SUBMIC_TO_AP;
+ cmd_gain[0] = INPUT_SUB_MIC | OUTPUT_AP | GAIN_MODE;
+ cmd_path[0] = INPUT_SUB_MIC | OUTPUT_AP;
+ } else if (control->option.capture & AVSYS_AUDIO_PATH_OPTION_USE_STEREOMIC) {
+ control->gain_status.capture = GS_STEREOMIC_TO_AP;
+ control->path_status.capture = PS_STEREOMIC_TO_AP;
+ cmd_gain[0] = INPUT_STEREO_MIC | OUTPUT_AP | GAIN_MODE;
+ cmd_path[0] = INPUT_STEREO_MIC | OUTPUT_AP;
+ } else {
+ control->gain_status.capture = GS_MAINMIC_TO_AP;
+ control->path_status.capture = PS_MAINMIC_TO_AP;
+ cmd_gain[0] = INPUT_MAIN_MIC | OUTPUT_AP | GAIN_MODE;
+ cmd_path[0] = INPUT_MAIN_MIC | OUTPUT_AP;
+ }
+ }
+ break;
+
+ case AVSYS_AUDIO_PATH_EX_HEADSETMIC:
+ control->ear_auto = AVSYS_AUDIO_EAR_SWITCH_MANUAL;
+ control->gain_status.capture = GS_EARMIC_TO_AP;
+ control->path_status.capture = PS_EARMIC_TO_AP;
+ cmd_gain[0] = INPUT_EAR_MIC | OUTPUT_AP | GAIN_MODE;
+ cmd_path[0] = INPUT_EAR_MIC | OUTPUT_AP;
+ break;
+
+ default:
+ break;
+ }
+
+ if ((control->p_path_status.capture != control->path_status.capture) || control->gain_debug_mode == 1) {
+ RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_gain, 2, ASCN_RESET_CAPTURE))
+ control->p_gain_status.capture = control->gain_status.capture;
+ RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_bulk_set(cmd_path, 2, ASCN_RESET_NONE))
+ control->p_path_status.capture = control->path_status.capture;
+ }
+
+ avsys_info (AVAUDIO, ">> leave");
+
+ return AVSYS_STATE_SUCCESS;
+}
+
+
+static int __avsys_audio_path_set_hw_controls(avsys_audio_path_ex_info_t *control)
+{
+ avsys_audio_handle_info_t *handle_control = NULL;
+ avsys_audio_handle_info_t **temp = NULL;
+ int ret = AVSYS_STATE_SUCCESS;
+ avsys_info(AVAUDIO, "global mute %d\n", control->mute);
+ avsys_info(AVAUDIO, "path_fixed mute %d\n", control->path_fixed);
+
+ /* update logical volume table - about output device - information for open handles */
+ avsys_info(AVAUDIO, "Control handle informations\n");
+ {
+ avsys_audio_handle_t *ptr = NULL;
+ int handle = -1;
+ int out_device = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
+
+ temp = &handle_control;
+ if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_HANDLE, (void**)temp))) {
+ avsys_error(AVAUDIO, "avsys_audio_get_shm() failed in %s\n",__func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ if (AVSYS_FAIL(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_HANDLE))) {
+ avsys_error(AVAUDIO, "avsys_audio_lock_sync() failed in %s\n",__func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ while (++handle < AVSYS_AUDIO_HANDLE_MAX) {
+ long long int flag = 0x01;
+ flag <<= handle;
+
+ if (handle_control->allocated & flag)
+ {
+ ptr = &(handle_control->handles[handle]);
+
+ if (ptr->mode != AVSYS_AUDIO_MODE_OUTPUT && ptr->mode != AVSYS_AUDIO_MODE_OUTPUT_CLOCK
+ && ptr->mode != AVSYS_AUDIO_MODE_OUTPUT_LOW_LATENCY && ptr->mode != AVSYS_AUDIO_MODE_OUTPUT_AP_CALL) {
+ continue;
+ }
+ ptr->path_off = 0;
+ out_device = control->lvol_dev_type;
+ if (control->path_status.playback == PS_PATH_NONE) {
+ ptr->path_off = 1;
+ avsys_warning(AVAUDIO, "Path off status...set logical volume device type to speaker\n");
+ out_device = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
+ }
+ avsys_audio_logical_volume_update_table(out_device, &ptr->gain_setting);
+ avsys_audio_logical_volume_convert(&ptr->setting_vol, &ptr->working_vol, &ptr->gain_setting);
+ }
+ }
+
+ if(AVSYS_FAIL(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_HANDLE))) {
+ avsys_error(AVAUDIO,"avsys_audio_unlock_sync() failed in %s\n",__func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+ }
+ return AVSYS_STATE_SUCCESS;
+}
+
+static bool __avsys_audio_path_check_cp_audio(int gain)
+{
+ /*If video call uses CP audio, add AVSYS_AUDIO_GAIN_EX_VIDEOCALL to following code. */
+ if (gain == AVSYS_AUDIO_GAIN_EX_VOICECALL)
+ return true;
+ else
+ return false;
+}
+
+int avsys_audio_path_set_volume(int handle)
+{
+ avsys_audio_path_ex_info_t *control = NULL;
+ avsys_audio_path_ex_info_t **temp = NULL;
+ avsys_audio_handle_t *ptr = NULL;
+ int err;
+ int gain_type;
+ int out_device = AVSYS_AUDIO_DEVICE_TYPE_SPK;
+
+ err = avsys_audio_handle_get_ptr(handle, &ptr, HANDLE_PTR_MODE_NORMAL);
+ if (AVSYS_FAIL(err)) {
+ avsys_error(AVAUDIO, "Handle is not allocated\n");
+ avsys_audio_handle_release_ptr(handle, HANDLE_PTR_MODE_NORMAL);
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ }
+
+ temp = &control;
+ avsys_assert(AVSYS_SUCCESS(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp)));
+ avsys_assert(control != NULL);
+ avsys_assert(AVSYS_SUCCESS(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH)));
+
+ if (__avsys_audio_path_check_cp_audio(control->gain.playback))
+ ptr->during_cp_audio = 1;
+ else
+ ptr->during_cp_audio = 0;
+
+ gain_type = ptr->gain_setting.vol_type;
+ out_device = control->lvol_dev_type;
+ if (control->path_status.playback == PS_PATH_NONE) {
+ ptr->path_off = 1;
+ avsys_warning(AVAUDIO, "Path off status...set logical volume device type to speaker\n");
+ out_device = AVSYS_AUDIO_LVOL_DEV_TYPE_SPK;
+ }
+ avsys_assert(AVSYS_SUCCESS(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH)));
+ avsys_warning(AVAUDIO, "set path volume : gain(%d), out_dev(%d)\n", gain_type, out_device);
+ err = avsys_audio_logical_volume_set_table(gain_type, out_device, &ptr->gain_setting);
+ avsys_audio_handle_release_ptr(handle, HANDLE_PTR_MODE_NORMAL);
+ return err;
+}
+
+int avsys_audio_path_set_route_policy(avsys_audio_route_policy_t route)
+{
+ avsys_audio_path_ex_info_t *control = NULL;
+ avsys_audio_path_ex_info_t **temp = NULL;
+ int err = AVSYS_STATE_SUCCESS;
+
+ temp = &control;
+ avsys_assert(AVSYS_SUCCESS(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp)));
+ avsys_assert(control != NULL);
+ avsys_assert(AVSYS_SUCCESS(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH)));
+
+ control->route_policy = route;
+
+ avsys_assert(AVSYS_SUCCESS(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH)));
+ return err;
+}
+
+int avsys_audio_path_get_route_policy(avsys_audio_route_policy_t *route)
+{
+ avsys_audio_path_ex_info_t *control = NULL;
+ avsys_audio_path_ex_info_t **temp = NULL;
+ int err = AVSYS_STATE_SUCCESS;
+
+ if (!route)
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+
+ temp = &control;
+ avsys_assert(AVSYS_SUCCESS(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp)));
+ avsys_assert(control != NULL);
+ avsys_assert(AVSYS_SUCCESS(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH)));
+
+ *route = control->route_policy;
+
+ avsys_assert(AVSYS_SUCCESS(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH)));
+ return err;
+}
+
+int avsys_audio_path_check_loud(bool *loud)
+{
+ avsys_audio_path_ex_info_t *control = NULL;
+ avsys_audio_path_ex_info_t **temp = NULL;
+ int err = AVSYS_STATE_SUCCESS;
+
+ if (!loud)
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+
+ temp = &control;
+ avsys_assert(AVSYS_SUCCESS(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp)));
+ avsys_assert(control != NULL);
+ avsys_assert(AVSYS_SUCCESS(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH)));
+
+ if ((control->path_status.playback & PS_AP_TO_SPK) ||
+ (control->path_status.playback & PS_AP_TO_RECV) ||
+ (control->path_status.playback & PS_FMRADIO_TO_SPK)) {
+ *loud = true;
+ } else {
+ avsys_info(AVAUDIO, "playback path status 0x%x\n", control->path_status.playback);
+ *loud = false;
+ }
+
+ avsys_assert(AVSYS_SUCCESS(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH)));
+ return err;
+}
+
+int avsys_audio_path_check_cp_audio(bool *cpaudio, bool *btpath)
+{
+ avsys_audio_path_ex_info_t *control = NULL;
+ avsys_audio_path_ex_info_t **temp = NULL;
+
+ if (!cpaudio || !btpath)
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+
+ temp = &control;
+ avsys_assert(AVSYS_SUCCESS(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp)));
+ avsys_assert(control != NULL);
+ avsys_assert(AVSYS_SUCCESS(avsys_audio_lock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH)));
+
+ if (__avsys_audio_path_check_cp_audio(control->gain.playback))
+ *cpaudio = true;
+ else
+ *cpaudio = false;
+
+ if (control->path.playback == AVSYS_AUDIO_PATH_EX_BTHEADSET)
+ *btpath = true;
+ else
+ *btpath = false;
+
+ avsys_assert(AVSYS_SUCCESS(avsys_audio_unlock_sync(AVSYS_AUDIO_SYNC_IDEN_PATH)));
+ return AVSYS_STATE_SUCCESS;
+}
+
+int avsys_audio_path_set_single_ascn(char *str)
+{
+ if (!str)
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+
+ RET_IO_CTL_ERR_IF_FAIL(avsys_audio_ascn_single_set(str))
+
+ return AVSYS_STATE_SUCCESS;
+}
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "avsys-audio-shm.h"
+#include "avsys-common.h"
+#include "avsys-error.h"
+#include "avsys-audio-handle.h"
+#include "avsys-audio-path.h"
+#include "avsys-audio-logical-volume.h"
+
+#define SHM_KEY_PATH "/tmp"
+
+typedef struct {
+ avsys_shm_param_t param;
+ void *pdst;
+} _avsys_audio_shm_control_t;
+
+static _avsys_audio_shm_control_t g_presettings[AVSYS_AUDIO_SHM_IDEN_CNT] = {
+ {{SHM_KEY_PATH, AVSYS_KEY_PREFIX_GEN(AVSYS_KEY_PREFIX_AUDIO,AVSYS_AUDIO_SHM_IDEN_HANDLE) + 0x10,sizeof(avsys_audio_handle_info_t)}, NULL},
+ {{SHM_KEY_PATH, AVSYS_KEY_PREFIX_GEN(AVSYS_KEY_PREFIX_AUDIO,AVSYS_AUDIO_SHM_IDEN_PATH) + 0x10,sizeof(avsys_audio_path_ex_info_t)}, NULL},
+ {{SHM_KEY_PATH, AVSYS_KEY_PREFIX_GEN(AVSYS_KEY_PREFIX_AUDIO,AVSYS_AUDIO_SHM_IDEN_LVOLUME) + 0x10,sizeof(avsys_logical_gain_t) * AVSYS_AUDIO_LVOL_GAIN_TYPE_MAX}, NULL},
+};
+
+int avsys_audio_create_shm(const avsys_audio_shm_iden_t iden)
+{
+ if (iden >= AVSYS_AUDIO_SHM_IDEN_CNT || 0 > iden)
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ return avsys_create_shm(&g_presettings[iden].param);
+}
+
+int avsys_audio_remove_shm(const avsys_audio_shm_iden_t iden)
+{
+ if (iden >= AVSYS_AUDIO_SHM_IDEN_CNT || 0 > iden)
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ g_presettings[iden].pdst = NULL;
+ return avsys_remove_shm(&g_presettings[iden].param);
+}
+
+int avsys_audio_get_shm(const avsys_audio_shm_iden_t iden, void **ptr)
+{
+ if (iden >= AVSYS_AUDIO_SHM_IDEN_CNT || 0 > iden)
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+
+ if (!ptr)
+ return AVSYS_STATE_ERR_NULL_POINTER;
+
+ if (!g_presettings[iden].pdst) {
+ g_presettings[iden].pdst = avsys_get_shm(&g_presettings[iden].param);
+ if (!g_presettings[iden].pdst)
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+ *ptr = (void *)g_presettings[iden].pdst;
+ return AVSYS_STATE_SUCCESS;
+}
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <string.h>
+#include <dirent.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "avsys-common.h"
+#include "avsys-audio-sync.h"
+#include "avsys-error.h"
+#include "avsys-debug.h"
+#include "avsys-audio-shm.h"
+#include "avsys-audio-path.h"
+
+static avsys_sync_param_t g_presettings[AVSYS_AUDIO_SYNC_IDEN_CNT] = {
+ {"audio_handle_lock", AVSYS_KEY_PREFIX_GEN(AVSYS_KEY_PREFIX_AUDIO, AVSYS_AUDIO_SYNC_IDEN_HANDLE)},
+ {"audio_path_lock", AVSYS_KEY_PREFIX_GEN(AVSYS_KEY_PREFIX_AUDIO, AVSYS_AUDIO_SYNC_IDEN_PATH)},
+ {"audio_route_policy_lock", AVSYS_KEY_PREFIX_GEN(AVSYS_KEY_PREFIX_AUDIO, AVSYS_AUDIO_SYNC_IDEN_SOUNDPATH)},
+ {"av_volume_sem", AVSYS_KEY_PREFIX_GEN(AVSYS_KEY_PREFIX_AUDIO, AVSYS_AUDIO_SYNC_IDEN_VOLUME)},
+};
+
+int avsys_audio_create_sync(const avsys_audio_sync_iden_t iden)
+{
+ if (iden >= AVSYS_AUDIO_SYNC_IDEN_CNT || 0 > iden)
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ return avsys_create_sync(&g_presettings[iden]);
+}
+
+int avsys_audio_remove_sync(const avsys_audio_sync_iden_t iden)
+{
+ if (iden >= AVSYS_AUDIO_SYNC_IDEN_CNT || 0 > iden)
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ return avsys_remove_sync(&g_presettings[iden]);
+}
+
+int avsys_audio_lock_sync(const avsys_audio_sync_iden_t iden)
+{
+ pid_t pid = -1;
+ int index = 0;
+ int err = AVSYS_STATE_SUCCESS;
+
+ if (iden >= AVSYS_AUDIO_SYNC_IDEN_CNT || 0 > iden) {
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ }
+ //avsys_info(AVAUDIO,"lock[%d]\n",(int)iden);
+
+ err = avsys_lock_sync(&g_presettings[iden]);
+
+ pid = getpid();
+ if ((iden == AVSYS_AUDIO_SYNC_IDEN_PATH) && (err == AVSYS_STATE_SUCCESS)) {
+ avsys_audio_path_ex_info_t *control = NULL;
+ avsys_audio_path_ex_info_t **temp = NULL;
+
+ temp = &control;
+ if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_get_shm() for path failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ do {
+ /* Add mark */
+ if (control->pathlock_pid[index] < 0) { /* find empty slot */
+ control->pathlock_pid[index] = pid;
+ break;
+ }
+ index++;
+ if (index == AVSYS_AUDIO_LOCK_SLOT_MAX) {
+ int i;
+ avsys_critical(AVAUDIO, "path lock pid slot is full. print stored pid before clear all slot\n");
+ /* print and cleanup all stored pid */
+ for (i = 0; i < AVSYS_AUDIO_LOCK_SLOT_MAX; i++) {
+ avsys_critical(AVAUDIO, "path lock pid : %d\n", control->pathlock_pid[i]);
+ control->pathlock_pid[i] = -1;
+ }
+ control->pathlock_pid[0] = pid; /* add current pid */
+ }
+ } while (index < AVSYS_AUDIO_LOCK_SLOT_MAX);
+ } else if ((iden == AVSYS_AUDIO_SYNC_IDEN_HANDLE) && (err == AVSYS_STATE_SUCCESS)) {
+ avsys_audio_handle_info_t *control = NULL;
+ avsys_audio_handle_info_t **temp = NULL;
+
+ temp = &control;
+ if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_HANDLE, (void **)temp))) {
+ avsys_error(AVAUDIO, "avsys_audio_get_shm() for handle failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ do {
+ /* Add mark */
+ if (control->handlelock_pid[index] < 0) { /* find empty slot */
+ control->handlelock_pid[index] = pid;
+ break;
+ }
+ index++;
+ if (index == AVSYS_AUDIO_LOCK_SLOT_MAX) {
+ int i;
+ avsys_critical(AVAUDIO, "handle lock pid slot is full. print stored pid before clear all slot\n");
+ /* print and cleanup all stored pid */
+ for (i = 0; i < AVSYS_AUDIO_LOCK_SLOT_MAX; i++) {
+ avsys_critical(AVAUDIO, "handle lock pid : %d\n", control->handlelock_pid[i]);
+ control->handlelock_pid[i] = -1;
+ }
+ control->handlelock_pid[0] = pid; /*add current pid */
+ }
+ } while (index < AVSYS_AUDIO_LOCK_SLOT_MAX);
+ }
+ return err;
+}
+
+int avsys_audio_unlock_sync(const avsys_audio_sync_iden_t iden)
+{
+ pid_t pid = -1;
+ int index = 0;
+ int err = AVSYS_STATE_SUCCESS;
+
+ if (iden >= AVSYS_AUDIO_SYNC_IDEN_CNT || 0 > iden) {
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ }
+ //avsys_info(AVAUDIO,"unlock[%d]\n",(int)iden);
+
+ err = avsys_unlock_sync(&g_presettings[iden]);
+
+ pid = getpid();
+ if ((iden == AVSYS_AUDIO_SYNC_IDEN_PATH) && (err == AVSYS_STATE_SUCCESS)) {
+ avsys_audio_path_ex_info_t *control = NULL;
+ avsys_audio_path_ex_info_t **temp = NULL;
+
+ temp = &control;
+ if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_PATH, (void **)temp))) {
+ avsys_error_r(AVAUDIO, "avsys_audio_get_shm() failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ do {
+ /* Remove mark */
+ if (control->pathlock_pid[index] == pid) { /* find empty slot */
+ control->pathlock_pid[index] = -1;
+ break;
+ }
+ index++;
+ if (index == AVSYS_AUDIO_LOCK_SLOT_MAX)
+ avsys_error(AVAUDIO, "Can not find pid (%d) in path_lock_pid slot\n", pid);
+ } while (index < AVSYS_AUDIO_LOCK_SLOT_MAX);
+ } else if ((iden == AVSYS_AUDIO_SYNC_IDEN_HANDLE) && (err == AVSYS_STATE_SUCCESS)) {
+ avsys_audio_handle_info_t *control = NULL;
+ avsys_audio_handle_info_t **temp = NULL;
+
+ temp = &control;
+ if (AVSYS_FAIL(avsys_audio_get_shm(AVSYS_AUDIO_SHM_IDEN_HANDLE, (void **)temp))) {
+ avsys_error(AVAUDIO, "avsys_audio_get_shm() for handle failed in %s\n", __func__);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ do {
+ /* Add mark */
+ if (control->handlelock_pid[index] == pid) { /* find empty slot */
+ control->handlelock_pid[index] = -1;
+ break;
+ }
+ index++;
+ if (index == AVSYS_AUDIO_LOCK_SLOT_MAX)
+ avsys_error(AVAUDIO, "Can not find pid (%d) in handlelock_pid slot\n", pid);
+ } while (index < AVSYS_AUDIO_LOCK_SLOT_MAX);
+ }
+
+ return err;
+}
+
+/* find pid information in proc filesystem */
+/* if pid exist, return AVSYS_STATE_SUCCESS */
+/* if pid does not exist, return AVSYS_STATE_ERR_ALLOCATION */
+int avsys_check_process(int check_pid)
+{
+ DIR *dir = NULL;
+ char check_path[128] = "";
+ int exist = AVSYS_STATE_SUCCESS;
+
+ memset(check_path, '\0', sizeof(check_path));
+ snprintf(check_path, sizeof(check_path) - 1, "/proc/%d", check_pid);
+
+ dir = opendir(check_path);
+ if (dir == NULL) {
+ switch (errno) {
+ case ENOENT:
+ avsys_error(AVAUDIO, "pid %d does not exist anymore\n", check_pid);
+ exist = AVSYS_STATE_ERR_ALLOCATION;
+ break;
+ case EACCES:
+ avsys_error(AVAUDIO, "Permission denied\n");
+ break;
+ case EMFILE:
+ avsys_error(AVAUDIO, "Too many file descriptors in use by process\n");
+ break;
+ case ENFILE:
+ avsys_error(AVAUDIO, "Too many files are currently open in the system\n");
+ break;
+ default:
+ avsys_error(AVAUDIO, "Other error : %d\n", errno);
+ break;
+ }
+ } else {
+ avsys_warning(AVAUDIO, "pid : %d still alive\n", check_pid);
+ if (-1 == closedir(dir)) {
+ avsys_error(AVAUDIO, "[%s] closedir failed with errno : %d\n", __func__, errno);
+ }
+ }
+ return exist;
+}
+
+int avsys_audio_dump_sync(void)
+{
+ pid_t pid = -1;
+ int index = 0;
+ int err = AVSYS_STATE_SUCCESS;
+ int i = 0;
+ int sem_value = 0;
+
+ fprintf(stdout, "Dump sync : Start\n");
+ for (i = 0; i < AVSYS_AUDIO_SYNC_IDEN_CNT; i++) {
+ err = avsys_dump_sync(&g_presettings[i]);
+ }
+ fprintf(stdout, "Dump sync : End\n");
+ return err;
+}
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <pthread.h>
+#include <time.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <unistd.h>
+#include <sys/syscall.h>
+#include <signal.h>
+#include <string.h>
+#include <fcntl.h>
+
+#include "avsys-types.h"
+#include "avsys-error.h"
+#include "avsys-debug.h"
+#include "avsys-audio.h"
+#include "avsys-audio-logical-volume.h"
+#include "avsys-common.h"
+
+#include "avsys-audio-path.h"
+#include "avsys-audio-alsa.h"
+
+#include "avsys-audio-pasimple.h"
+#include "avsys-audio-pactrl.h"
+
+/**
+ * Internal functions definition
+ */
+#define FADEUP_CALC_BIAS (1)
+
+static int __avsys_audio_set_info(avsys_audio_handle_t *p, avsys_audio_param_t *param);
+
+void __init_module(void);
+void __fini_module(void);
+
+#define AVSYS_GET_HANDLE_PTR(MODE) do { \
+ err = avsys_audio_handle_get_ptr((int)handle, &p, MODE); \
+ if (AVSYS_FAIL(err)) { \
+ return err; \
+ } \
+} while (0)
+
+#define AVSYS_RELEASE_HANDLE_PTR(MODE) do { \
+ if (AVSYS_FAIL(avsys_audio_handle_release_ptr((int)handle, MODE))) { \
+ avsys_error(AVAUDIO, "audio handle release failed\n"); \
+ return AVSYS_STATE_ERR_INTERNAL; \
+ } \
+} while (0)
+
+/**
+ * Internal global variable
+ */
+
+/****************************************************************************
+ *
+ * Interface
+ *
+ ***************************************************************************/
+EXPORT_API
+int avsys_audio_open(avsys_audio_param_t *param, avsys_handle_t *phandle, int *size)
+{
+ int handle = -1;
+ avsys_audio_handle_t *p = NULL;
+ int err = AVSYS_STATE_ERR_UNKNOWN;
+
+ avsys_info(AVAUDIO, "%s\n", __func__);
+
+ if (param == NULL || phandle == NULL) {
+ avsys_error(AVAUDIO, "param or phandle is null\n");
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ }
+
+ if (param->channels > 2 || param->channels < 1) {
+ return AVSYS_STATE_ERR_INVALID_CHANNEL;
+ }
+
+ if (param->mode < AVSYS_AUDIO_MODE_OUTPUT || param->mode >= AVSYS_AUDIO_MODE_NUM) {
+ return AVSYS_STATE_ERR_INVALID_MODE;
+ }
+
+ if (param->format < AVSYS_AUDIO_FORMAT_MIN || param->format > AVSYS_AUDIO_FORMAT_MAX) {
+ return AVSYS_STATE_ERR_INVALID_FORMAT;
+ }
+
+ err = avsys_audio_handle_rejuvenation();
+ if (AVSYS_FAIL(err)) {
+ avsys_error(AVAUDIO, "Unused handle cleanup before handle allocation failed in %s\n", __func__);
+ goto error;
+ }
+ err = avsys_audio_handle_alloc(&handle);
+ if (AVSYS_STATE_ERR_RANGE_OVER == err) {
+ avsys_error(AVAUDIO, "audio handle is fully allocated..try cleanup\n");
+ err = avsys_audio_handle_rejuvenation();
+ if (AVSYS_FAIL(err)) {
+ avsys_error(AVAUDIO, "Unused handle cleanup failed in %s\n", __func__);
+ goto error;
+ }
+ avsys_error(AVAUDIO, "one more try...to allocate audio handle\n");
+ err = avsys_audio_handle_alloc(&handle);
+ if (AVSYS_FAIL(err)) {
+ avsys_error(AVAUDIO, "handle alloc failed 1 in %s\n", __func__);
+ goto error;
+ }
+ } else if ((AVSYS_FAIL(err)) && (err != AVSYS_STATE_ERR_RANGE_OVER)) {
+ avsys_error(AVAUDIO, "handle alloc failed 2 in %s\n", __func__);
+ goto error;
+ }
+
+ err = avsys_audio_handle_get_ptr(handle, &p, HANDLE_PTR_MODE_NORMAL);
+ if (AVSYS_FAIL(err)) {
+ goto error;
+ }
+
+ /* set information to handle */
+ err = __avsys_audio_set_info(p, param);
+ if (AVSYS_FAIL(err)) {
+ goto error;
+ }
+
+ if (p->mode == AVSYS_AUDIO_MODE_OUTPUT || p->mode == AVSYS_AUDIO_MODE_OUTPUT_CLOCK ||
+ p->mode == AVSYS_AUDIO_MODE_OUTPUT_LOW_LATENCY || p->mode == AVSYS_AUDIO_MODE_OUTPUT_AP_CALL || p->mode == AVSYS_AUDIO_MODE_OUTPUT_VIDEO) {
+ /* set volume table */
+ err = avsys_audio_path_set_volume(handle);
+ if (AVSYS_FAIL(err)) {
+ goto error;
+ }
+
+ /* update volume by type */
+ err = avsys_audio_handle_update_volume(p, p->gain_setting.vol_type);
+ if (AVSYS_FAIL(err)) {
+ goto error;
+ }
+ err = avsys_audio_handle_update_priority(handle, param->priority, param->bluetooth, AVSYS_AUDIO_SET_PRIORITY);
+ if (AVSYS_FAIL(err)) {
+ goto error;
+ }
+ }
+
+ /* open device */
+ err = avsys_audio_pasimple_open_device(p->mode, p->format, p->channels, p->samplerate, p, param->bluetooth);
+ if (AVSYS_FAIL(err)) {
+ goto error;
+ }
+ switch (p->mode) {
+ case AVSYS_AUDIO_MODE_OUTPUT:
+ case AVSYS_AUDIO_MODE_OUTPUT_CLOCK:
+ case AVSYS_AUDIO_MODE_OUTPUT_LOW_LATENCY:
+ case AVSYS_AUDIO_MODE_OUTPUT_VIDEO:
+ case AVSYS_AUDIO_MODE_OUTPUT_AP_CALL:
+ if (AVSYS_FAIL(avsys_audio_pasimple_set_volume(p, p->working_vol.level[AVSYS_AUDIO_CHANNEL_LEFT]))) {
+ avsys_error(AVAUDIO, "can not set volume in %s\n", __func__);
+ }
+ break;
+ default:
+ break;
+ }
+
+ *phandle = (avsys_handle_t) handle;
+ /* set recommended buffer size */
+ if (size != NULL)
+ *size = p->period;
+ else
+ avsys_warning(AVAUDIO, "Size is null\n");
+
+ err = avsys_audio_handle_release_ptr(handle, HANDLE_PTR_MODE_NORMAL);
+ if (AVSYS_FAIL(err)) {
+ goto error;
+ }
+
+ return AVSYS_STATE_SUCCESS;
+
+error:
+ if (p) {
+ avsys_audio_handle_release_ptr(handle, HANDLE_PTR_MODE_NORMAL);
+ }
+
+ if (handle != -1) {
+ if (AVSYS_FAIL(avsys_audio_handle_free(handle))) {
+ avsys_error(AVAUDIO, "Can not free handle %d\n", handle);
+ }
+ }
+
+ avsys_error(AVAUDIO, "failed to open : RESION %x\n", err);
+
+ *phandle = (avsys_handle_t)-1;
+
+ return err;
+}
+
+EXPORT_API
+int avsys_audio_close(avsys_handle_t handle)
+{
+ avsys_audio_handle_t *p = NULL;
+ int err = AVSYS_STATE_ERR_UNKNOWN;
+ bool cp_audio = false;
+ bool bt_path = false;
+
+ avsys_info(AVAUDIO, "%s, handle=[%d]\n", __func__, (int)handle);
+
+ AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
+
+ if (AVSYS_FAIL(avsys_audio_handle_update_priority((int)handle, p->priority, AVSYS_AUDIO_HANDLE_ROUTE_FOLLOWING_POLICY, AVSYS_AUDIO_UNSET_PRIORITY))) {
+ avsys_error(AVAUDIO, "unset priority of handle %d error: %x\n", handle, err);
+ }
+
+ err = avsys_audio_pasimple_close_device(p);
+ if (AVSYS_FAIL(err)) {
+ avsys_error_r(AVAUDIO, "audio device close error : %x\n", err);
+ }
+
+ if (AVSYS_FAIL(avsys_audio_path_check_cp_audio(&cp_audio, &bt_path))) {
+ avsys_error(AVAUDIO, "Can not check cp audio status\n");
+ }
+
+ if (p->during_cp_audio && cp_audio && bt_path) {
+ /* set cp bt path again */
+ avsys_audio_path_set_single_ascn("cp_to_bt");
+ }
+
+ AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
+
+ avsys_audio_handle_free((int)handle);
+
+ return err;
+}
+
+EXPORT_API
+int avsys_audio_ampon(void)
+{
+ avsys_info(AVAUDIO, "%s\n", __func__);
+ return avsys_audio_path_ex_set_amp(AVSYS_AUDIO_AMP_ON);
+}
+
+EXPORT_API
+int avsys_audio_ampoff(void)
+{
+ avsys_info(AVAUDIO, "%s\n", __func__);
+ return avsys_audio_path_ex_set_amp(AVSYS_AUDIO_AMP_OFF);
+}
+
+
+EXPORT_API
+int avsys_audio_ext_device_ampon(avsysaudio_ext_device_t device_type)
+{
+ avsys_info(AVAUDIO, "%s\n", __func__);
+ return avsys_audio_handle_ext_dev_set_mute(device_type, AVSYS_AUDIO_UNMUTE);
+}
+
+EXPORT_API
+int avsys_audio_ext_device_ampoff(avsysaudio_ext_device_t device_type)
+{
+ avsys_info(AVAUDIO, "%s\n", __func__);
+ return avsys_audio_handle_ext_dev_set_mute(device_type, AVSYS_AUDIO_MUTE);
+}
+
+EXPORT_API
+int avsys_audio_set_ext_device_status(avsysaudio_ext_device_t device_type, int onoff)
+{
+ avsys_info(AVAUDIO, "%s\n", __func__);
+ return avsys_audio_handle_ext_dev_status_update(device_type, onoff);
+}
+
+EXPORT_API
+int avsys_audio_get_ext_device_status(avsysaudio_ext_device_t device_type, int *onoff)
+{
+ avsys_info(AVAUDIO, "%s\n", __func__);
+ return avsys_audio_handle_ext_dev_status(device_type, onoff);
+}
+
+EXPORT_API
+int avsys_audio_flush(avsys_handle_t handle)
+{
+ int err = AVSYS_STATE_SUCCESS;
+ avsys_audio_handle_t *p = NULL;
+ avsys_info(AVAUDIO, "%s\n", __func__);
+
+ AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
+
+ err = avsys_audio_pasimple_reset(p);
+
+ AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
+
+ return err;
+}
+
+EXPORT_API
+int avsys_audio_drain(avsys_handle_t handle)
+{
+ int err = AVSYS_STATE_SUCCESS;
+ avsys_audio_handle_t *p = NULL;
+ avsys_info(AVAUDIO, "%s\n", __func__);
+
+ AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
+
+ err = avsys_audio_pasimple_drain(p);
+
+ AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
+
+ return err;
+}
+
+EXPORT_API
+int avsys_audio_read(avsys_handle_t handle, void *buf, int size)
+{
+ int err = AVSYS_STATE_SUCCESS;
+ avsys_audio_handle_t *p = NULL;
+
+ avsys_info(AVAUDIO, "%s\n", __func__);
+
+ if (buf == NULL) {
+ avsys_error(AVAUDIO, "input buffer pointer is null\n");
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ }
+
+ AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_FAST);
+
+ if (p->mode != AVSYS_AUDIO_MODE_INPUT && p->mode != AVSYS_AUDIO_MODE_INPUT_LOW_LATENCY &&
+ p->mode != AVSYS_AUDIO_MODE_INPUT_HIGH_LATENCY && p->mode != AVSYS_AUDIO_MODE_INPUT_AP_CALL) {
+ avsys_error(AVAUDIO, "opened output mode\n");
+ return AVSYS_STATE_ERR_INVALID_MODE;
+ }
+
+ err = avsys_audio_pasimple_read(p, buf, size);
+
+ AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_FAST);
+
+ return err;
+}
+
+EXPORT_API
+int avsys_audio_write(avsys_handle_t handle, void *buf, int size)
+{
+ int err = AVSYS_STATE_SUCCESS;
+ avsys_audio_handle_t *p = NULL;
+
+ avsys_info(AVAUDIO, "%s\n", __func__);
+
+ if (buf == NULL) {
+ avsys_error(AVAUDIO, "buf is null\n");
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ }
+
+ AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_FAST);
+
+ if (p->mode != AVSYS_AUDIO_MODE_OUTPUT && p->mode != AVSYS_AUDIO_MODE_OUTPUT_CLOCK &&
+ p->mode != AVSYS_AUDIO_MODE_OUTPUT_LOW_LATENCY && p->mode != AVSYS_AUDIO_MODE_OUTPUT_AP_CALL && p->mode != AVSYS_AUDIO_MODE_OUTPUT_VIDEO) {
+ avsys_error(AVAUDIO, "opened input mode\n");
+ avsys_audio_handle_release_ptr((int)handle, HANDLE_PTR_MODE_FAST);
+ return AVSYS_STATE_ERR_INVALID_MODE;
+ }
+
+ if (p->fadeup_vol > 1) {
+ if (p->fadeup_multiplier == 0) {
+ avsys_audio_volume_t fade_volume;
+ fade_volume.level[AVSYS_AUDIO_CHANNEL_LEFT] = p->setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT] - (p->fadeup_vol - FADEUP_CALC_BIAS);
+ fade_volume.level[AVSYS_AUDIO_CHANNEL_RIGHT] = p->setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT] - (p->fadeup_vol - FADEUP_CALC_BIAS);
+
+ if (fade_volume.level[AVSYS_AUDIO_CHANNEL_LEFT] < 0) {
+ fade_volume.level[AVSYS_AUDIO_CHANNEL_LEFT] = 0;
+ }
+ if (fade_volume.level[AVSYS_AUDIO_CHANNEL_RIGHT] < 0) {
+ fade_volume.level[AVSYS_AUDIO_CHANNEL_RIGHT] = 0;
+ }
+
+ avsys_info(AVAUDIO, "fade_volume : %d (%d-(%d)+%d) p->fadeup_m = %d, p->msec_per_period = %d\n",
+ fade_volume.level[AVSYS_AUDIO_CHANNEL_LEFT],p->setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT],p->fadeup_vol,FADEUP_CALC_BIAS,
+ p->fadeup_multiplier, p->msec_per_period
+ );
+
+ avsys_audio_logical_volume_convert(&fade_volume, &p->working_vol, &p->gain_setting);
+ avsys_audio_pasimple_set_volume(p, p->working_vol.level[AVSYS_AUDIO_CHANNEL_LEFT]);
+ p->fadeup_vol--;
+ if (p->msec_per_period > 50)
+ p->fadeup_multiplier = 0;
+ else
+ p->fadeup_multiplier = FADE_UP_MULTIPLIER;
+ } else {
+ p->fadeup_multiplier--;
+ }
+ } else if (p->fadeup_vol <= -1) {
+ if (p->fadeup_multiplier == 0) {
+ int fadedown_vol = 0;
+ avsys_audio_volume_t fade_volume;
+
+ fadedown_vol = (-1) * (p->fadeup_vol) - FADEUP_CALC_BIAS;
+ fade_volume.level[AVSYS_AUDIO_CHANNEL_LEFT] = fadedown_vol;
+ fade_volume.level[AVSYS_AUDIO_CHANNEL_RIGHT] = fadedown_vol;
+
+ if (fade_volume.level[AVSYS_AUDIO_CHANNEL_LEFT] < 0) {
+ fade_volume.level[AVSYS_AUDIO_CHANNEL_LEFT] = 0;
+ }
+ if (fade_volume.level[AVSYS_AUDIO_CHANNEL_RIGHT] < 0) {
+ fade_volume.level[AVSYS_AUDIO_CHANNEL_RIGHT] = 0;
+ }
+
+ avsys_info(AVAUDIO, "fade_volume : %d (%d-%d) p->fadeup_m = %d, p->msec_per_period = %d\n",
+ fade_volume.level[AVSYS_AUDIO_CHANNEL_LEFT],p->fadeup_vol,FADEUP_CALC_BIAS,
+ p->fadeup_multiplier, p->msec_per_period);
+
+ avsys_audio_logical_volume_convert(&fade_volume, &p->working_vol, &p->gain_setting);
+ avsys_audio_pasimple_set_volume(p, p->working_vol.level[AVSYS_AUDIO_CHANNEL_LEFT]);
+ if (p->fadeup_vol < -1) {
+ p->fadeup_vol++;
+ } else if (p->fadeup_vol == -1) {
+ p->mute = AVSYS_AUDIO_MUTE;
+ }
+ if (p->msec_per_period > 50)
+ p->fadeup_multiplier = 0;
+ else
+ p->fadeup_multiplier = FADE_DOWN_MULTIPLIER;
+ } else {
+ p->fadeup_multiplier--;
+ }
+ }
+ err = avsys_audio_pasimple_write(p, buf, size);
+
+ AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_FAST);
+
+ return err;
+}
+
+EXPORT_API
+int avsys_audio_set_volume_fadeup(avsys_handle_t handle)
+{
+ int err = AVSYS_STATE_SUCCESS;
+ avsys_audio_handle_t *p = NULL;
+
+ avsys_warning(AVAUDIO, "%s\n", __func__);
+
+ AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
+
+ if (p->setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT] >= p->setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT]) {
+ p->fadeup_vol = p->setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT]; /* + FADEUP_CALC_BIAS */
+ } else {
+ p->fadeup_vol = p->setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT]; /* + FADEUP_CALC_BIAS; */
+ }
+ p->fadeup_multiplier = 0;
+
+ AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
+
+ return err;
+}
+
+EXPORT_API
+int avsys_audio_set_mute_fadedown(avsys_handle_t handle)
+{
+ int err = AVSYS_STATE_SUCCESS;
+ avsys_audio_handle_t *p = NULL;
+
+ avsys_warning(AVAUDIO, "%s\n", __func__);
+
+ AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
+
+ if (p->setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT] >= p->setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT]) {
+ p->fadeup_vol = (-1) * p->setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT];
+ } else {
+ p->fadeup_vol = (-1) * p->setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT];
+ }
+ p->fadeup_multiplier = 0;
+
+ AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
+
+ return err;
+}
+
+/* Tuning part */
+EXPORT_API
+int avsys_audio_set_volume_table(int gain_type, int dev_type, int step, int lv, int rv)
+{
+ int ret = avsys_audio_logical_volume_set_to_table(gain_type, dev_type, step, lv, rv);
+ avsys_audio_handle_t *ptr = NULL;
+ int handle = -1;
+
+ if (AVSYS_FAIL(ret)) {
+ return ret;
+ }
+
+ while(++handle < AVSYS_AUDIO_HANDLE_MAX) {
+ ptr = NULL;
+
+ if (AVSYS_SUCCESS(avsys_audio_handle_get_ptr(handle, &ptr, HANDLE_PTR_MODE_NORMAL))) {
+ avsys_audio_logical_volume_convert(&ptr->setting_vol, &ptr->working_vol, &ptr->gain_setting);
+ avsys_audio_handle_release_ptr(handle, HANDLE_PTR_MODE_NORMAL);
+ }
+ }
+ return AVSYS_STATE_SUCCESS;
+}
+
+EXPORT_API
+int avsys_audio_get_volume_table(int gain_type, int dev_type, int step, int *lv, int *rv)
+{
+ return avsys_audio_logical_volume_get_from_table(gain_type, dev_type, step, lv, rv);
+}
+
+EXPORT_API
+int avsys_audio_get_volume_max_ex(int volume_type, int *max_step)
+{
+ int volume_table = 0;
+ if (max_step == NULL) {
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ }
+
+ volume_table = volume_type;
+
+ return avsys_audio_logical_volume_get_max(volume_table, AVSYS_AUDIO_LVOL_DEV_TYPE_SPK, max_step);
+}
+
+EXPORT_API
+int avsys_audio_set_mute(avsys_handle_t handle, int mute)
+{
+ avsys_info(AVAUDIO, "%s\n", __func__);
+
+ if (mute > AVSYS_AUDIO_MUTE || mute < AVSYS_AUDIO_UNMUTE) {
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ }
+
+ if (AVSYS_FAIL(avsys_audio_handle_set_mute((int)handle, mute))) {
+ avsys_error(AVAUDIO, "failed to set handle mute\n");
+ }
+
+ return AVSYS_STATE_SUCCESS;
+}
+
+EXPORT_API
+int avsys_audio_get_mute(avsys_handle_t handle, int *pmute)
+{
+ int err = AVSYS_STATE_SUCCESS;
+ avsys_audio_handle_t *p = NULL;
+
+ avsys_info(AVAUDIO, "%s\n", __func__);
+
+ if (pmute == NULL) {
+ avsys_error(AVAUDIO, "pvolume is null\n");
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ }
+
+ AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
+
+ *pmute = p->mute;
+
+ AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
+
+ return AVSYS_STATE_SUCCESS;
+}
+
+/*
+ * Option : AVSYS_AUDIO_PATH_OPTION_LEGACY_MODE support NowPlus style sound path function
+ * Option : AVSYS_AUDIO_PATH_OPTION_DUAL_OUT will effect only when out is speaker.
+ * Option : AVSYS_AUDIO_PATH_OPTION_JACK_AUTO will effect only when out is speaker or receiver.
+ * Option : AVSYS_AUDIO_PATH_OPTION_FORCED is avail only for shutdown animation
+ *
+ * Limitation : Only FORCED option can be used same time with other options (exclude LEGACY_MODE)
+ */
+EXPORT_API
+int avsys_audio_set_path_ex(int gain, int out, int in, int option)
+{
+ if (AVSYS_AUDIO_GAIN_EX_KEYTONE > gain || AVSYS_AUDIO_GAIN_EX_MAX <= gain ||
+ AVSYS_AUDIO_PATH_EX_NONE > out || AVSYS_AUDIO_PATH_EX_OUTMAX <= out ||
+ AVSYS_AUDIO_PATH_EX_NONE > in || AVSYS_AUDIO_PATH_EX_INMAX <= in) {
+ avsys_error(AVAUDIO, "Your input parameter is invalid. Please check\n");
+ avsys_error(AVAUDIO, " gain %d, out %d, in %d\n", gain, out, in);
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ }
+
+ return avsys_audio_path_ex_set_path(gain, out, in, option);
+}
+EXPORT_API
+int avsys_audio_get_path_ex(int *gain, int *out, int *in, int *option)
+{
+ if (!gain || !out || !in || !option) {
+ avsys_warning(AVAUDIO, "Your input parameter is NULL pointer. Please check.\n");
+ avsys_warning(AVAUDIO, " gain %p, out %p, in %p, option %p\n", gain, out, in, option);
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ }
+ return avsys_audio_path_ex_get_path(gain, out, in, option);
+}
+
+EXPORT_API
+int avsys_audio_set_global_mute(int mute)
+{
+ int err = AVSYS_STATE_SUCCESS;
+
+ avsys_info(AVAUDIO, "%s : mute=%d\n", __func__, mute);
+
+ if (mute < AVSYS_AUDIO_UNMUTE && mute > AVSYS_AUDIO_MUTE_NOLOCK) {
+ err = AVSYS_STATE_ERR_INVALID_PARAMETER;
+ } else {
+ err = avsys_audio_path_ex_set_mute(mute);
+ }
+ return err;
+}
+
+EXPORT_API
+int avsys_audio_get_global_mute(int *pmute)
+{
+ int err = AVSYS_STATE_SUCCESS;
+
+ avsys_info(AVAUDIO, "%s\n", __func__);
+ if (pmute == NULL) {
+ err = AVSYS_STATE_ERR_NULL_POINTER;
+ } else {
+ err = avsys_audio_path_ex_get_mute(pmute);
+ }
+ return err;
+}
+
+/**
+ * Internal functions implementation
+ */
+
+static int __avsys_audio_set_info(avsys_audio_handle_t *p, avsys_audio_param_t *param)
+{
+ avsys_info(AVAUDIO, "%s\n", __func__);
+
+ avsys_info(AVAUDIO, "=============================================\n");
+ avsys_info(AVAUDIO, " Input Parameters (Basic Information)\n");
+ avsys_info(AVAUDIO, "=============================================\n");
+ avsys_info(AVAUDIO, " Op Mode = %d (0:out, 1:input)\n", param->mode);
+ avsys_info(AVAUDIO, " format = %d (0: 8bits, 1:16bits, 2:32bits)\n", param->format);
+ avsys_info(AVAUDIO, " channel = %d\n", param->channels);
+ avsys_info(AVAUDIO, " samplerate = %d\n", param->samplerate);
+ avsys_info(AVAUDIO, " route = %d (0: default, 1: handset)\n", param->bluetooth);
+ avsys_info(AVAUDIO, " Vol type = %d\n", param->vol_type);
+ avsys_info(AVAUDIO, "=============================================\n");
+
+ p->mode = param->mode;
+ p->channels = param->channels;
+ p->samplerate = param->samplerate;
+ p->format = param->format;
+ p->priority = param->priority;
+
+ if ((param->vol_type < 0) || (param->vol_type >= AVSYS_AUDIO_VOLUME_TYPE_MAX)) {
+ avsys_error(AVAUDIO, "[%s] Invalid volume type %d. use default system type\n", __func__, param->vol_type);
+ p->gain_setting.vol_type = AVSYS_AUDIO_VOLUME_TYPE_SYSTEM;
+ } else {
+ p->gain_setting.vol_type = param->vol_type;
+ }
+
+ /* trivial volume value */
+ p->setting_vol.level[AVSYS_AUDIO_CHANNEL_LEFT] = 0;
+ p->setting_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT] = 0;
+ p->working_vol.level[AVSYS_AUDIO_CHANNEL_LEFT] = 0;
+ p->working_vol.level[AVSYS_AUDIO_CHANNEL_RIGHT] = 0;
+ p->fadeup_vol = 0;
+
+ return AVSYS_STATE_SUCCESS;
+}
+
+EXPORT_API
+int avsys_audio_earjack_manager_init(int *earjack_type, int *waitfd)
+{
+ return avsys_audio_path_earjack_init(earjack_type, waitfd);
+}
+
+EXPORT_API
+int avsys_audio_earjack_manager_wait(int waitfd, int *current_earjack_type, int *new_earjack_type, int *need_mute)
+{
+ return avsys_audio_path_earjack_wait(waitfd, current_earjack_type, new_earjack_type, need_mute);
+}
+
+EXPORT_API
+int avsys_audio_earjack_manager_process(int new_earjack_type)
+{
+ return avsys_audio_path_earjack_process(new_earjack_type);
+}
+
+EXPORT_API
+int avsys_audio_earjack_manager_deinit(int waitfd)
+{
+ return avsys_audio_path_earjack_deinit(waitfd);
+}
+
+EXPORT_API
+int avsys_audio_earjack_manager_unlock(void)
+{
+ return avsys_audio_path_earjack_unlock();
+}
+
+EXPORT_API
+int avsys_audio_set_route_policy(avsys_audio_route_policy_t route)
+{
+ return avsys_audio_path_set_route_policy(route);
+}
+
+EXPORT_API
+int avsys_audio_get_route_policy(avsys_audio_route_policy_t *route)
+{
+ if (route == NULL)
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ return avsys_audio_path_get_route_policy(route);
+}
+
+EXPORT_API
+int avsys_audio_get_current_playing_volume_type(int *volume_type)
+{
+ if (volume_type == NULL)
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ return avsys_audio_handle_current_playing_volume_type(volume_type);
+}
+
+static inline int __avsys_audio_validate_volume(const int type, const int value)
+{
+ if (value < 0)
+ return -1;
+ switch (type) {
+ case AVSYS_AUDIO_VOLUME_TYPE_ALARM:
+ case AVSYS_AUDIO_VOLUME_TYPE_CALL:
+ if (value >= LVOLUME_MAX_BASIC) {
+ return -1;
+ }
+ break;
+ case AVSYS_AUDIO_VOLUME_TYPE_RINGTONE:
+ case AVSYS_AUDIO_VOLUME_TYPE_NOTIFICATION:
+ case AVSYS_AUDIO_VOLUME_TYPE_SYSTEM:
+ case AVSYS_AUDIO_VOLUME_TYPE_MEDIA:
+ case AVSYS_AUDIO_VOLUME_TYPE_MEDIA_HL:
+ case AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_JAVA:
+ if (value >= LVOLUME_MAX_MULTIMEDIA) {
+ return -1;
+ }
+ break;
+ case AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_ANDROID:
+ if (value >= LVOLUME_MAX_SINGLE) {
+ return -1;
+ }
+ break;
+ default:
+ return -1;
+ break;
+ }
+ return 0;
+}
+
+EXPORT_API
+int avsys_audio_set_volume_by_type(const int type, const int value)
+{
+ if (type < 0 || type >= AVSYS_AUDIO_VOLUME_TYPE_MAX)
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ if (0 > __avsys_audio_validate_volume(type, value))
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+ return avsys_audio_handle_update_volume_by_type(type, value);
+}
+
+EXPORT_API
+int avsys_audio_set_primary_volume(const int pid, const int type)
+{
+ return avsys_audio_handle_set_primary_volume_type(pid, type, AVSYS_AUDIO_PRIMARY_VOLUME_SET);
+}
+
+EXPORT_API
+int avsys_audio_clear_primary_volume(const int pid)
+{
+ return avsys_audio_handle_set_primary_volume_type(pid, 0, AVSYS_AUDIO_PRIMARY_VOLUME_CLEAR);
+}
+
+EXPORT_API
+int avsys_audio_hibernation_reset(int *vol)
+{
+ int err = AVSYS_STATE_SUCCESS;
+ err = avsys_audio_path_ex_reset(1);
+ if (AVSYS_FAIL(err)) {
+ avsys_error(AVAUDIO, "avsys_audio_path_ex_reset(forced) failed 0x%x\n", err);
+ return err;
+ }
+
+ err = avsys_audio_handle_reset(vol);
+ if (AVSYS_FAIL(err)) {
+ avsys_error(AVAUDIO, "avsys_audio_handle_reset() failed 0x%x\n", err);
+ return err;
+ }
+ return err;
+}
+
+EXPORT_API
+int avsys_audio_delay(avsys_handle_t handle, int *delay)
+{
+ int err = AVSYS_STATE_SUCCESS;
+ int frame_delay = 0;
+ avsys_audio_handle_t *p = NULL;
+
+ AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
+
+ err = avsys_audio_pasimple_delay(p, &frame_delay);
+ if (AVSYS_SUCCESS(err)) {
+ *delay = frame_delay;
+ }
+
+ AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
+
+ return err;
+}
+
+EXPORT_API
+int avsys_audio_reset(avsys_handle_t handle)
+{
+ int err = AVSYS_STATE_SUCCESS;
+ avsys_audio_handle_t *p = NULL;
+
+ AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
+
+ err = avsys_audio_pasimple_reset(p);
+ if (AVSYS_FAIL(err)) {
+ avsys_error(AVAUDIO, "avsys_audio_reset() failed, 0x%X\n", err);
+ }
+
+ AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
+
+ return err;
+
+}
+
+EXPORT_API
+int avsys_audio_get_period_buffer_time(avsys_handle_t handle, unsigned int *period_time, unsigned int *buffer_time)
+{
+ int err = AVSYS_STATE_SUCCESS;
+ avsys_audio_handle_t *p = NULL;
+ unsigned int p_time = 0, b_time=0;
+
+ AVSYS_GET_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
+
+ err = avsys_audio_pasimple_get_period_buffer_time(p, &p_time, &b_time);
+ if(AVSYS_FAIL(err)) {
+ avsys_error(AVAUDIO, "avsys_audio_get_period_buffer_time() failed, 0x%X\n",err);
+ }
+ else
+ {
+ *period_time = p_time;
+ *buffer_time = b_time;
+ avsys_info(AVAUDIO,"period time : %u, buffer_time : %u\n", p_time, b_time);
+ }
+
+ AVSYS_RELEASE_HANDLE_PTR(HANDLE_PTR_MODE_NORMAL);
+
+ return err;
+}
+
+EXPORT_API
+int avsys_audio_get_playing_device_info(avsys_audio_playing_devcie_t *dev)
+{
+ int err = AVSYS_STATE_SUCCESS;
+ int sink_info = 0;
+ bool alsa_loud = false;
+
+ if (!dev)
+ return AVSYS_STATE_ERR_INVALID_PARAMETER;
+
+ err = avsys_audio_pa_ctrl_get_default_sink(&sink_info);
+ if (AVSYS_FAIL(err))
+ return err;
+
+ switch (sink_info) {
+ case AVSYS_AUDIO_PA_CTL_SINK_UNKNOWN:
+ avsys_error_r(AVAUDIO, "Unexpected sink information\n");
+ err = AVSYS_STATE_ERR_UNAVAILABLE_DEVICE;
+ break;
+ case AVSYS_AUDIO_PA_CTL_SINK_ALSA:
+ err = avsys_audio_path_check_loud(&alsa_loud);
+ if (AVSYS_FAIL(err))
+ break;
+ if (alsa_loud == true)
+ *dev = AVSYS_AUDIO_ROUTE_DEVICE_HANDSET;
+ else
+ *dev = AVSYS_AUDIO_ROUTE_DEVICE_EARPHONE;
+ break;
+ case AVSYS_AUDIO_PA_CTL_SINK_BLUEZ:
+ *dev = AVSYS_AUDIO_ROUTE_DEVICE_BLUETOOTH;
+ break;
+ }
+
+ return err;
+}
+
+EXPORT_API
+int avsys_audio_get_capture_status(int *on_capture)
+{
+ return avsys_audio_handle_current_capture_status(on_capture);
+}
+
+__attribute__ ((constructor))
+void __init_module(void)
+{
+}
+
+__attribute__ ((destructor))
+void __fini_module(void)
+{
+}
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "avsys-common.h"
+#include "avsys-debug.h"
+#include "avsys-error.h"
+
+#include <stdio.h>
+#include <memory.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <pwd.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <time.h>
+
+#define RETRY_EINTR
+#include <fcntl.h>
+#include <semaphore.h>
+
+void * avsys_malloc(size_t size)
+{
+ char *allocated;
+ allocated = (char*) malloc(size + 12);
+
+ if(!allocated) {
+ return NULL;
+ }
+ memset(allocated, 0, size+8);
+ memcpy(allocated, AVSYS_MAGIC_START, 4);
+ (*(int*)(allocated+4)) = size;
+ memcpy(allocated+size+8, AVSYS_MAGIC_END, 4);
+
+ return (void*)(allocated + 8);
+}
+
+void avsys_free(void *ptr)
+{
+ char *allocated = (char*)ptr;
+ if(allocated) {
+ if(avsys_mem_check(allocated)) {
+ free(allocated-8);
+ }
+ }
+}
+
+int avsys_create_shm(const avsys_shm_param_t* param)
+{
+ int shmid = -1;
+ int *segptr = NULL;
+ key_t key;
+
+ if (!param) {
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ }
+ if (param->size < 1 || param->key_path == NULL || access(param->key_path, R_OK) != 0) {
+ return AVSYS_STATE_ERR_INVALID_VALUE;
+ }
+
+ key = ftok(param->key_path, param->key_prefix);
+
+ if ((shmid = shmget(key, param->size, IPC_CREAT|IPC_EXCL|0666)) == -1) {
+ if (errno == EEXIST) {
+ avsys_error(AVAUDIO,"Already initialized.\n");
+ if ((shmid = shmget(key, param->size, 0)) == -1) {
+ avsys_error(AVAUDIO, "Initialization fail.\n");
+ } else {
+ segptr = shmat(shmid, 0, 0);
+ avsys_assert_r(segptr != NULL);
+ }
+ } else {
+ if(errno == EACCES)
+ avsys_error_r(AVAUDIO, "Require ROOT permission.\n");
+ else if(errno == ENOMEM)
+ avsys_critical_r(AVAUDIO, "System memory is empty.\n");
+ else if(errno == ENOSPC)
+ avsys_critical_r(AVAUDIO, "Resource is empty.\n");
+ }
+ } else {
+ shmctl(shmid, SHM_LOCK, 0);
+ segptr = shmat(shmid, 0, 0);
+ avsys_assert_r(segptr != NULL);
+ memset((void*)segptr, 0, param->size);
+ }
+
+ if (shmid != -1) {
+ return AVSYS_STATE_SUCCESS;
+ } else {
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+}
+
+int avsys_remove_shm(const avsys_shm_param_t* param)
+{
+ int shmid = -1;
+ key_t key;
+
+ if (!param) {
+ return AVSYS_STATE_ERR_NULL_POINTER;
+ }
+ if (param->size < 1 || param->key_path == NULL || access(param->key_path, R_OK) != 0) {
+ return AVSYS_STATE_ERR_INVALID_VALUE;
+ }
+
+ key = ftok(param->key_path, param->key_prefix);
+
+ if ((shmid = shmget(key, param->size, 0)) == -1) {
+ if(errno == ENOENT)
+ avsys_error_r(AVAUDIO, "Not initialized.\n");
+ else if(errno == EACCES)
+ avsys_error_r(AVAUDIO, "Require ROOT permission.\n");
+ else if(errno == ENOSPC)
+ avsys_critical_r(AVAUDIO, "Resource is empty.\n");
+ } else {
+ avsys_assert_r(shmctl(shmid, IPC_RMID, 0) == 0);
+ }
+
+ if (shmid != -1) {
+ return AVSYS_STATE_SUCCESS;
+ } else {
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+}
+
+void* avsys_get_shm(const avsys_shm_param_t* param)
+{
+ int shmid = -1;
+ void *ptr = NULL;
+ key_t key;
+
+ if (!param) {
+ return NULL;
+ }
+ if (param->size < 1 || param->key_path == NULL || access(param->key_path, R_OK) != 0) {
+ return NULL;
+ }
+
+ key = ftok(param->key_path, param->key_prefix);
+
+ if ((shmid = shmget(key, param->size, 0)) == -1) {
+ if(errno == ENOENT)
+ avsys_error_r(AVAUDIO, "Not initialized.\n");
+ else if(errno == EACCES)
+ avsys_error_r(AVAUDIO, "Require ROOT permission.\n");
+ else if(errno == ENOSPC)
+ avsys_critical_r(AVAUDIO, "Resource is empty.\n");
+ return NULL;
+ }
+
+ ptr = shmat(shmid, 0, 0);
+ if(ptr == (void*)-1) {
+ if(errno == EACCES)
+ avsys_error_r(AVAUDIO,"no permission\n");
+ else if(errno == EINVAL)
+ avsys_error_r(AVAUDIO,"invalid shmid\n");
+ else if(errno == ENOMEM)
+ avsys_error_r(AVAUDIO,"can not allocate memory\n");
+ else
+ avsys_error_r(AVAUDIO,"shmat() failed %d\n", errno);
+ ptr = NULL;
+ }
+ return ptr;
+}
+
+int avsys_create_sync(const avsys_sync_param_t *param)
+{
+ sem_t *sem = NULL;
+ sem = sem_open(param->key_path, O_CREAT, 0666, 1);
+ if (sem == SEM_FAILED) {
+ switch(errno)
+ {
+ case EACCES:
+ avsys_error(AVAUDIO,
+ "The semaphore already exist, but caller does not have permission %s\n",param->key_path);
+ break;
+ case ENOMEM:
+ avsys_error(AVAUDIO,"Insufficient memory in %s (%d)\n",__func__,__LINE__);
+ break;
+ case ENFILE:
+ avsys_error(AVAUDIO,"Too many open files in system %s (%d)\n",__func__,__LINE__);
+ break;
+ default:
+ avsys_critical(AVAUDIO, "Semaphore create fail! (name:%s, errno %d)\n", param->key_path, errno);
+ break;
+ }
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+ return AVSYS_STATE_SUCCESS;
+}
+
+int avsys_remove_sync(const avsys_sync_param_t *param)
+{
+ int err = 0;
+
+ err = sem_unlink(param->key_path);
+ if (err == -1) {
+ avsys_critical(AVAUDIO, "Semaphore destroy Fail! (name:%s, errno %d)\n", param->key_path, errno);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ return AVSYS_STATE_SUCCESS;
+}
+
+int avsys_lock_sync(const avsys_sync_param_t *param)
+{
+ sem_t *sem = NULL;
+ int ret;
+ int err = AVSYS_STATE_SUCCESS;
+ struct timespec wait_time;
+
+ sem = sem_open(param->key_path, O_CREAT, 0666, 1);
+ if (sem == SEM_FAILED) {
+ avsys_critical(AVAUDIO, "Semaphore open Fail! (name:%s, errno %d)\n", param->key_path, errno);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+retry_lock:
+ wait_time.tv_sec = (long int)(time(NULL)) + LOCK_TIMEOUT_SEC;
+ wait_time.tv_nsec = 0;
+ ret = sem_timedwait(sem, &wait_time);
+ if(ret == -1) {
+ switch(errno)
+ {
+ case EINTR:
+ avsys_critical(AVAUDIO, "Lock RETRY LOCK\n");
+ goto retry_lock;
+ break;
+ case EINVAL:
+ avsys_critical(AVAUDIO, "Invalid semaphore\n");
+ err = AVSYS_STATE_ERR_INTERNAL;
+ break;
+ case EAGAIN:
+ avsys_critical(AVAUDIO, "EAGAIN\n");
+ err = AVSYS_STATE_ERR_INTERNAL;
+ break;
+ case ETIMEDOUT:
+ avsys_critical(AVAUDIO, "sem_wait leached %d seconds timeout.\n", LOCK_TIMEOUT_SEC);
+ {
+ /* Recovery of sem_wait lock....in abnormal condition */
+ int sem_value = -1;
+ if (0 == sem_getvalue(sem, &sem_value)) {
+ avsys_critical(AVAUDIO,"%s sem value is %d\n",param->key_path, sem_value);
+ if (sem_value == 0) {
+ ret = sem_post(sem);
+ if (ret == -1) {
+ avsys_critical(AVAUDIO,"sem_post error %s : %d\n", param->key_path, sem_value);
+ } else {
+ avsys_critical_r(AVAUDIO,"lock recovery success...try lock again\n");
+ goto retry_lock;
+ }
+ } else {
+ avsys_critical(AVAUDIO,"sem value is not 0. but failed sem_timedwait so retry.. : %s\n",param->key_path);
+ usleep(5);
+ goto retry_lock;
+ }
+ } else {
+ avsys_critical(AVAUDIO,"sem_getvalue failed : %s\n",param->key_path);
+ }
+ }
+ err = AVSYS_STATE_ERR_INTERNAL;
+ break;
+ }
+ }
+ sem_close(sem);
+ return err;
+}
+
+int avsys_unlock_sync(const avsys_sync_param_t *param)
+{
+ sem_t *sem = NULL;
+ int ret;
+ int err = AVSYS_STATE_SUCCESS;
+
+ sem = sem_open(param->key_path, O_CREAT, 0666, 1);
+ if (sem == SEM_FAILED) {
+ avsys_critical(AVAUDIO, "Semaphore open Fail! (name:%s, errno %d)\n", param->key_path, errno);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ ret = sem_post(sem);
+ if (ret == -1) {
+ avsys_critical(AVAUDIO, "UNLOCK FAIL\n");
+ err = AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ sem_close(sem);
+ return err;
+}
+
+int avsys_check_root_privilege()
+{
+ uid_t uid;
+ uid = getuid();
+ if(0 != uid) {
+ /* code from man page */
+ struct passwd pwd;
+ struct passwd *result;
+ char *buf;
+ size_t bufsize;
+ int s = 0;
+
+ bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
+ if (bufsize == -1) /* Value was indeterminate */
+ bufsize = 16384; /* Should be more than enough */
+
+ buf = malloc(bufsize);
+ if (buf == NULL) {
+ perror("malloc");
+ } else {
+ s= getpwuid_r (uid, &pwd, buf, bufsize, &result);
+ if (result == NULL) {
+ if (s == 0)
+ printf("Not found\n");
+ else {
+ errno = s;
+ perror("getpwnam_r");
+ }
+ } else {
+ avsys_error_r(AVAUDIO,"super user privilege check failed (%s)\n", pwd.pw_name);
+ }
+ free (buf);
+ }
+ return AVSYS_STATE_ERR_PRIVILEGE;
+ }
+ return AVSYS_STATE_SUCCESS;
+}
+
+int avsys_dump_sync (const avsys_sync_param_t *param)
+{
+ int err = AVSYS_STATE_SUCCESS;
+
+ sem_t *sem = NULL;
+ int ret;
+ int sem_value = -1;
+
+ sem = sem_open(param->key_path, O_CREAT, 0666, 1);
+ if (sem == SEM_FAILED) {
+ avsys_critical(AVAUDIO, "Semaphore open Fail! (name:%s, errno %d)\n", param->key_path, errno);
+ return AVSYS_STATE_ERR_INTERNAL;
+ }
+
+ if(0 == sem_getvalue(sem, &sem_value)) {
+ fprintf (stdout, " * [%d] sem value for [%s]\n", sem_value, param->key_path);
+ } else {
+ avsys_critical(AVAUDIO,"sem_getvalue failed : %s\n",param->key_path);
+ }
+
+ sem_close(sem);
+ return err;
+}
--- /dev/null
+AC_PREREQ(2.52)
+
+AC_INIT([avsystem], [1.0])
+AM_INIT_AUTOMAKE([-Wall -Werror foreign])
+AC_CONFIG_HEADERS([config.h:config.hin])
+
+AC_CONFIG_MACRO_DIR([m4])
+
+# Checks for programs.
+AC_PROG_CC
+AC_C_CONST
+dnl AC_FUNC_MALLOC
+AC_FUNC_MMAP
+AC_FUNC_REALLOC
+AC_FUNC_SELECT_ARGTYPES
+AC_FUNC_STAT
+AC_FUNC_VPRINTF
+AC_HEADER_STDBOOL
+AC_HEADER_STDC
+AC_HEADER_TIME
+AC_PROG_GCC_TRADITIONAL
+AC_PROG_LIBTOOL
+
+AC_ARG_ENABLE(sdk, AC_HELP_STRING([--enable-sdk], [sdk build]),
+ [
+ case "${enableval}" in
+ yes) IS_SDK=yes ;;
+ no) IS_SDK=no ;;
+ *) AC_MSG_ERROR(bad value ${enableval} for --enable-sdk) ;;
+ esac
+ ],
+ [IS_SDK=no])
+AM_CONDITIONAL([IS_SDK], [test "x$IS_SDK" = "xyes"])
+
+AC_ARG_ENABLE(audiotest, AC_HELP_STRING([--enable-audiotest], [build audio test program]),
+ [
+ case "${enableval}" in
+ yes) WITH_AUDIOTEST=yes ;;
+ no) WITH_AUDIOTEST=no ;;
+ *) AC_MSG_ERROR(bad value ${enableval} for --enable-audiotest) ;;
+ esac
+ ],
+ [WITH_AUDIOTEST=no])
+AM_CONDITIONAL([WITH_AUDIOTEST], [test "x$WITH_AUDIOTEST" = "xyes"])
+
+# Checks for libraries.
+PKG_CHECK_MODULES(ALSA, alsa >= 1.0.15)
+AC_SUBST(ALSA_CFLAGS)
+AC_SUBST(ALSA_LIBS)
+
+PKG_CHECK_MODULES(EXIF, libexif)
+AC_SUBST(EXIF_CFLAGS)
+AC_SUBST(EXIF_LIBS)
+
+PKG_CHECK_MODULES(MMTA, mm-ta)
+AC_SUBST(MMTA_CFLAGS)
+AC_SUBST(MMTA_LIBS)
+
+PKG_CHECK_MODULES(MMLOG, mm-log)
+AC_SUBST(MMLOG_CFLAGS)
+AC_SUBST(MMLOG_LIBS)
+
+PKG_CHECK_MODULES(PASIMPLE, libpulse-simple)
+AC_SUBST(PASIMPLE_CFLAGS)
+AC_SUBST(PASIMPLE_LIBS)
+PKG_CHECK_MODULES(PA, libpulse)
+AC_SUBST(PA_CFLAGS)
+AC_SUBST(PA_LIBS)
+
+PKG_CHECK_MODULES(ASCN, libascenario)
+AC_SUBST(ASCN_CFLAGS)
+AC_SUBST(ASCN_LIBS)
+
+# Checks for header files.
+AC_HEADER_STDC
+AC_CHECK_HEADERS([fcntl.h memory.h stdlib.h string.h sys/time.h unistd.h errno.h sys/types.h sys/stat.h])
+
+# Checks for typedefs, structures, and compiler characteristics.
+AC_C_CONST
+AC_TYPE_PID_T
+AC_TYPE_SIZE_T
+
+# Checks for library functions.
+AC_FUNC_ALLOCA
+AC_FUNC_FORK
+AC_FUNC_MALLOC
+AC_FUNC_MEMCMP
+AC_FUNC_SELECT_ARGTYPES
+AC_TYPE_SIGNAL
+AC_CHECK_FUNCS([memset select])
+
+AC_CONFIG_FILES([
+Makefile
+pkgconfig-arm/Makefile
+pkgconfig-arm/avsystem.pc
+pkgconfig-arm/avsysaudio.pc
+pkgconfig-i386/Makefile
+pkgconfig-i386/avsystem.pc
+pkgconfig-i386/avsysaudio.pc
+init/Makefile
+])
+AC_OUTPUT
--- /dev/null
+avsystem (0.4.13-1) unstable; urgency=low
+
+ * Initial release
+ * Git: slp/pkgs/a/avsystem
+ * Tag: avsystem_0.4.13-1
+
+ -- Hyunseok Lee <hs7388.lee@samsung.com> Wed, 08 Feb 2012 09:56:41 +0900
\ No newline at end of file
--- /dev/null
+Source: avsystem
+Priority: optional
+Maintainer: Seungbae Shin <seungbae.shin@samsung.com>, Jeongmo Yang <jm80.yang@samsung.com>, JongHyuk Choi <jhchoi.choi@samsung.com>
+Uploaders: YoungHwan Ahn <younghwan_.an@samsung.com>
+Build-Depends: debhelper (>= 5), autotools-dev, libasound2-dev, libascenario-dev, libmm-log-dev, libexif-dev, iniparser-dev, libmm-ta-dev, libpulse-dev
+Standards-Version: 3.7.2
+Section: libs
+
+Package: libavsystem-dev
+XB-Public-Package: no
+Section: libdevel
+Architecture: any
+Depends: libavsystem-0 (= ${Source-Version}), libavsystem-sdk-dev, libasound2-dev, libpulse-dev
+Description: avsystem library development package for sdk build
+
+Package: libavsystem-sdk-dev
+Section: libdevel
+Architecture: any
+Depends: libavsystem-0 (= ${Source-Version}), libasound2-sdk-dev, libascenario-dev, libmm-log-sdk-dev, libexif-dev, libmm-ta-sdk-dev, libpulse-dev
+Description: avsystem library development package for sdk release
+
+Package: libavsystem-0
+Section: libs
+Architecture: any
+Depends: ${shlibs:Depends}, ${misc:Depends}
+Description: avsystem multimedia library package
+ avsystem provide low level sound / camera / video control method
+
+Package: libavsystem-0-dbg
+Section: debug
+Architecture: any
+Depends: ${misc:Depends}, libavsystem-0 (= ${Source-Version})
+Description: avsystem library debug package (unstripped)
--- /dev/null
+Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+
+Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
--- /dev/null
+usr/bin
+usr/sbin
--- /dev/null
+# if your module, creates shared libraries
+@PREFIX@/lib/*.so*
+@PREFIX@/bin/*
+/etc/rc.d/*
+
--- /dev/null
+# if your module creates shared libraries
+@PREFIX@/include/*
+
--- /dev/null
+# if your module creates shared libraries
+@PREFIX@/lib/*.la
+@PREFIX@/lib/*.a
+@PREFIX@/lib/pkgconfig/*
+
--- /dev/null
+#!/usr/bin/make -f
+# -*- makefile -*-
+# Sample debian/rules that uses debhelper.
+# This file was originally written by Joey Hess and Craig Small.
+# As a special exception, when this file is copied by dh-make into a
+# dh-make output file, you may use that output file without restriction.
+# This special exception was added by Craig Small in version 0.37 of dh-make.
+
+# Uncomment this to turn on verbose mode.
+#export DH_VERBOSE=1
+
+
+# These are used for cross-compiling and for saving the configure script
+# from having to guess our platform (since we know it already)
+DEB_BUILD_GNU_TYPE ?= $(shell dpkg-architecture -qDEB_BUILD_GNU_TYPE)
+DEB_HOST_GNU_TYPE ?= $(shell dpkg-architecture -qDEB_HOST_GNU_TYPE)
+DEB_HOST_ARCH ?= $(shell dpkg-architecture -qDEB_HOST_ARCH)
+DEB_HOST_ARCH_OS ?= $(shell dpkg-architecture -qDEB_HOST_GNU_OS)
+
+CFLAGS ?= -Wall -g
+LDFLAGS ?=
+PREFIX ?= /usr
+DATADIR ?= /opt
+
+ifneq (,$(findstring noopt,$(DEB_BUILD_OPTIONS)))
+ CFLAGS += -O0 -fPIC
+else
+ CFLAGS += -O2 -fPIC
+endif
+
+# architecture is not arm
+ifneq (, $(findstring arm, $(DEB_HOST_ARCH)))
+ # do something here for arm architecture
+ OPTION=
+else
+ # do something here
+ OPTION= --enable-sdk
+endif
+
+LDFLAGS += -Wl,--rpath=$(PREFIX)/lib -Wl,--hash-style=both -Wl,--as-needed
+
+configure: configure.ac
+ dh_buildinfo generate cat
+ ./autogen.sh
+
+config.status: configure
+ dh_testdir
+ # Add here commands to configure the package.
+ CFLAGS="$(CFLAGS) -DGST_EXT_TIME_ANALYSIS" LDFLAGS="$(LDFLAGS)" ./configure --prefix=$(PREFIX) $(OPTION)
+
+build: build-stamp
+
+build-stamp: config.status
+ dh_testdir
+
+ # Add here commands to compile the package.
+ $(MAKE)
+ #docbook-to-man debian/ncurses.sgml > ncurses.1
+
+ for f in `find $(CURDIR)/debian/ -name "*.in"`; do \
+ cat $$f > $${f%.in}; \
+ sed -i -e "s#@PREFIX@#$(PREFIX)#g" $${f%.in}; \
+ sed -i -e "s#@DATADIR@#$(DATADIR)#g" $${f%.in}; \
+ done
+
+ touch $@
+
+clean:
+ dh_testdir
+ dh_testroot
+ rm -f build-stamp
+
+ # Add here commands to clean up after the build process.
+ -$(MAKE) distclean
+ifneq "$(wildcard /usr/share/misc/config.sub)" ""
+ cp -f /usr/share/misc/config.sub config.sub
+endif
+ifneq "$(wildcard /usr/share/misc/config.guess)" ""
+ cp -f /usr/share/misc/config.guess config.guess
+endif
+
+ for f in `find $(CURDIR)/debian/ -name "*.in"`; do \
+ rm -f $${f%.in}; \
+ done
+
+ dh_clean
+
+install: build
+ dh_testdir
+ dh_testroot
+ dh_clean -k
+ dh_installdirs
+
+ # Add here commands to install the package into debian/ncurses.
+ $(MAKE) DESTDIR=$(CURDIR)/debian/tmp install
+ mkdir -p $(CURDIR)/debian/tmp/etc/rc.d/rc3.d/
+ ln -s ../init.d/snd_init $(CURDIR)/debian/tmp/etc/rc.d/rc3.d/S30snd_init
+ mkdir -p $(CURDIR)/debian/tmp/etc/rc.d/rc4.d/
+ ln -s ../init.d/snd_init $(CURDIR)/debian/tmp/etc/rc.d/rc4.d/S30snd_init
+
+# Build architecture-independent files here.
+binary-indep: build install
+# We have nothing to do by default.
+
+# Build architecture-dependent files here.
+binary-arch: build install
+ dh_testdir
+ dh_testroot
+ dh_installchangelogs
+ dh_installdocs
+ dh_buildinfo install
+ dh_installexamples
+ dh_install --list-missing --sourcedir=debian/tmp
+# dh_installmenu
+# dh_installdebconf
+# dh_installlogrotate
+# dh_installemacsen
+# dh_installpam
+# dh_installmime
+# dh_python
+# dh_installinit
+# dh_installcron
+# dh_installinfo
+ dh_installman
+ dh_link
+ dh_strip --dbg-package=libavsystem-0-dbg
+ dh_compress
+ dh_fixperms
+# dh_perl
+ dh_makeshlibs
+ dh_installdeb
+ dh_shlibdeps
+ dh_gencontrol
+ dh_md5sums
+ dh_builddeb
+
+binary: binary-indep binary-arch
+.PHONY: build clean binary-indep binary-arch binary install
--- /dev/null
+#! /bin/sh
+# depcomp - compile a program generating dependencies as side-effects
+
+scriptversion=2007-03-29.01
+
+# Copyright (C) 1999, 2000, 2003, 2004, 2005, 2006, 2007 Free Software
+# Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+# 02110-1301, USA.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# Originally written by Alexandre Oliva <oliva@dcc.unicamp.br>.
+
+case $1 in
+ '')
+ echo "$0: No command. Try \`$0 --help' for more information." 1>&2
+ exit 1;
+ ;;
+ -h | --h*)
+ cat <<\EOF
+Usage: depcomp [--help] [--version] PROGRAM [ARGS]
+
+Run PROGRAMS ARGS to compile a file, generating dependencies
+as side-effects.
+
+Environment variables:
+ depmode Dependency tracking mode.
+ source Source file read by `PROGRAMS ARGS'.
+ object Object file output by `PROGRAMS ARGS'.
+ DEPDIR directory where to store dependencies.
+ depfile Dependency file to output.
+ tmpdepfile Temporary file to use when outputing dependencies.
+ libtool Whether libtool is used (yes/no).
+
+Report bugs to <bug-automake@gnu.org>.
+EOF
+ exit $?
+ ;;
+ -v | --v*)
+ echo "depcomp $scriptversion"
+ exit $?
+ ;;
+esac
+
+if test -z "$depmode" || test -z "$source" || test -z "$object"; then
+ echo "depcomp: Variables source, object and depmode must be set" 1>&2
+ exit 1
+fi
+
+# Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po.
+depfile=${depfile-`echo "$object" |
+ sed 's|[^\\/]*$|'${DEPDIR-.deps}'/&|;s|\.\([^.]*\)$|.P\1|;s|Pobj$|Po|'`}
+tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`}
+
+rm -f "$tmpdepfile"
+
+# Some modes work just like other modes, but use different flags. We
+# parameterize here, but still list the modes in the big case below,
+# to make depend.m4 easier to write. Note that we *cannot* use a case
+# here, because this file can only contain one case statement.
+if test "$depmode" = hp; then
+ # HP compiler uses -M and no extra arg.
+ gccflag=-M
+ depmode=gcc
+fi
+
+if test "$depmode" = dashXmstdout; then
+ # This is just like dashmstdout with a different argument.
+ dashmflag=-xM
+ depmode=dashmstdout
+fi
+
+case "$depmode" in
+gcc3)
+## gcc 3 implements dependency tracking that does exactly what
+## we want. Yay! Note: for some reason libtool 1.4 doesn't like
+## it if -MD -MP comes after the -MF stuff. Hmm.
+## Unfortunately, FreeBSD c89 acceptance of flags depends upon
+## the command line argument order; so add the flags where they
+## appear in depend2.am. Note that the slowdown incurred here
+## affects only configure: in makefiles, %FASTDEP% shortcuts this.
+ for arg
+ do
+ case $arg in
+ -c) set fnord "$@" -MT "$object" -MD -MP -MF "$tmpdepfile" "$arg" ;;
+ *) set fnord "$@" "$arg" ;;
+ esac
+ shift # fnord
+ shift # $arg
+ done
+ "$@"
+ stat=$?
+ if test $stat -eq 0; then :
+ else
+ rm -f "$tmpdepfile"
+ exit $stat
+ fi
+ mv "$tmpdepfile" "$depfile"
+ ;;
+
+gcc)
+## There are various ways to get dependency output from gcc. Here's
+## why we pick this rather obscure method:
+## - Don't want to use -MD because we'd like the dependencies to end
+## up in a subdir. Having to rename by hand is ugly.
+## (We might end up doing this anyway to support other compilers.)
+## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like
+## -MM, not -M (despite what the docs say).
+## - Using -M directly means running the compiler twice (even worse
+## than renaming).
+ if test -z "$gccflag"; then
+ gccflag=-MD,
+ fi
+ "$@" -Wp,"$gccflag$tmpdepfile"
+ stat=$?
+ if test $stat -eq 0; then :
+ else
+ rm -f "$tmpdepfile"
+ exit $stat
+ fi
+ rm -f "$depfile"
+ echo "$object : \\" > "$depfile"
+ alpha=ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
+## The second -e expression handles DOS-style file names with drive letters.
+ sed -e 's/^[^:]*: / /' \
+ -e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile"
+## This next piece of magic avoids the `deleted header file' problem.
+## The problem is that when a header file which appears in a .P file
+## is deleted, the dependency causes make to die (because there is
+## typically no way to rebuild the header). We avoid this by adding
+## dummy dependencies for each header file. Too bad gcc doesn't do
+## this for us directly.
+ tr ' ' '
+' < "$tmpdepfile" |
+## Some versions of gcc put a space before the `:'. On the theory
+## that the space means something, we add a space to the output as
+## well.
+## Some versions of the HPUX 10.20 sed can't process this invocation
+## correctly. Breaking it into two sed invocations is a workaround.
+ sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
+ rm -f "$tmpdepfile"
+ ;;
+
+hp)
+ # This case exists only to let depend.m4 do its work. It works by
+ # looking at the text of this script. This case will never be run,
+ # since it is checked for above.
+ exit 1
+ ;;
+
+sgi)
+ if test "$libtool" = yes; then
+ "$@" "-Wp,-MDupdate,$tmpdepfile"
+ else
+ "$@" -MDupdate "$tmpdepfile"
+ fi
+ stat=$?
+ if test $stat -eq 0; then :
+ else
+ rm -f "$tmpdepfile"
+ exit $stat
+ fi
+ rm -f "$depfile"
+
+ if test -f "$tmpdepfile"; then # yes, the sourcefile depend on other files
+ echo "$object : \\" > "$depfile"
+
+ # Clip off the initial element (the dependent). Don't try to be
+ # clever and replace this with sed code, as IRIX sed won't handle
+ # lines with more than a fixed number of characters (4096 in
+ # IRIX 6.2 sed, 8192 in IRIX 6.5). We also remove comment lines;
+ # the IRIX cc adds comments like `#:fec' to the end of the
+ # dependency line.
+ tr ' ' '
+' < "$tmpdepfile" \
+ | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' | \
+ tr '
+' ' ' >> $depfile
+ echo >> $depfile
+
+ # The second pass generates a dummy entry for each header file.
+ tr ' ' '
+' < "$tmpdepfile" \
+ | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \
+ >> $depfile
+ else
+ # The sourcefile does not contain any dependencies, so just
+ # store a dummy comment line, to avoid errors with the Makefile
+ # "include basename.Plo" scheme.
+ echo "#dummy" > "$depfile"
+ fi
+ rm -f "$tmpdepfile"
+ ;;
+
+aix)
+ # The C for AIX Compiler uses -M and outputs the dependencies
+ # in a .u file. In older versions, this file always lives in the
+ # current directory. Also, the AIX compiler puts `$object:' at the
+ # start of each line; $object doesn't have directory information.
+ # Version 6 uses the directory in both cases.
+ dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
+ test "x$dir" = "x$object" && dir=
+ base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
+ if test "$libtool" = yes; then
+ tmpdepfile1=$dir$base.u
+ tmpdepfile2=$base.u
+ tmpdepfile3=$dir.libs/$base.u
+ "$@" -Wc,-M
+ else
+ tmpdepfile1=$dir$base.u
+ tmpdepfile2=$dir$base.u
+ tmpdepfile3=$dir$base.u
+ "$@" -M
+ fi
+ stat=$?
+
+ if test $stat -eq 0; then :
+ else
+ rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+ exit $stat
+ fi
+
+ for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+ do
+ test -f "$tmpdepfile" && break
+ done
+ if test -f "$tmpdepfile"; then
+ # Each line is of the form `foo.o: dependent.h'.
+ # Do two passes, one to just change these to
+ # `$object: dependent.h' and one to simply `dependent.h:'.
+ sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile"
+ # That's a tab and a space in the [].
+ sed -e 's,^.*\.[a-z]*:[ ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
+ else
+ # The sourcefile does not contain any dependencies, so just
+ # store a dummy comment line, to avoid errors with the Makefile
+ # "include basename.Plo" scheme.
+ echo "#dummy" > "$depfile"
+ fi
+ rm -f "$tmpdepfile"
+ ;;
+
+icc)
+ # Intel's C compiler understands `-MD -MF file'. However on
+ # icc -MD -MF foo.d -c -o sub/foo.o sub/foo.c
+ # ICC 7.0 will fill foo.d with something like
+ # foo.o: sub/foo.c
+ # foo.o: sub/foo.h
+ # which is wrong. We want:
+ # sub/foo.o: sub/foo.c
+ # sub/foo.o: sub/foo.h
+ # sub/foo.c:
+ # sub/foo.h:
+ # ICC 7.1 will output
+ # foo.o: sub/foo.c sub/foo.h
+ # and will wrap long lines using \ :
+ # foo.o: sub/foo.c ... \
+ # sub/foo.h ... \
+ # ...
+
+ "$@" -MD -MF "$tmpdepfile"
+ stat=$?
+ if test $stat -eq 0; then :
+ else
+ rm -f "$tmpdepfile"
+ exit $stat
+ fi
+ rm -f "$depfile"
+ # Each line is of the form `foo.o: dependent.h',
+ # or `foo.o: dep1.h dep2.h \', or ` dep3.h dep4.h \'.
+ # Do two passes, one to just change these to
+ # `$object: dependent.h' and one to simply `dependent.h:'.
+ sed "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile"
+ # Some versions of the HPUX 10.20 sed can't process this invocation
+ # correctly. Breaking it into two sed invocations is a workaround.
+ sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" |
+ sed -e 's/$/ :/' >> "$depfile"
+ rm -f "$tmpdepfile"
+ ;;
+
+hp2)
+ # The "hp" stanza above does not work with aCC (C++) and HP's ia64
+ # compilers, which have integrated preprocessors. The correct option
+ # to use with these is +Maked; it writes dependencies to a file named
+ # 'foo.d', which lands next to the object file, wherever that
+ # happens to be.
+ # Much of this is similar to the tru64 case; see comments there.
+ dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
+ test "x$dir" = "x$object" && dir=
+ base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
+ if test "$libtool" = yes; then
+ tmpdepfile1=$dir$base.d
+ tmpdepfile2=$dir.libs/$base.d
+ "$@" -Wc,+Maked
+ else
+ tmpdepfile1=$dir$base.d
+ tmpdepfile2=$dir$base.d
+ "$@" +Maked
+ fi
+ stat=$?
+ if test $stat -eq 0; then :
+ else
+ rm -f "$tmpdepfile1" "$tmpdepfile2"
+ exit $stat
+ fi
+
+ for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2"
+ do
+ test -f "$tmpdepfile" && break
+ done
+ if test -f "$tmpdepfile"; then
+ sed -e "s,^.*\.[a-z]*:,$object:," "$tmpdepfile" > "$depfile"
+ # Add `dependent.h:' lines.
+ sed -ne '2,${; s/^ *//; s/ \\*$//; s/$/:/; p;}' "$tmpdepfile" >> "$depfile"
+ else
+ echo "#dummy" > "$depfile"
+ fi
+ rm -f "$tmpdepfile" "$tmpdepfile2"
+ ;;
+
+tru64)
+ # The Tru64 compiler uses -MD to generate dependencies as a side
+ # effect. `cc -MD -o foo.o ...' puts the dependencies into `foo.o.d'.
+ # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put
+ # dependencies in `foo.d' instead, so we check for that too.
+ # Subdirectories are respected.
+ dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
+ test "x$dir" = "x$object" && dir=
+ base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
+
+ if test "$libtool" = yes; then
+ # With Tru64 cc, shared objects can also be used to make a
+ # static library. This mechanism is used in libtool 1.4 series to
+ # handle both shared and static libraries in a single compilation.
+ # With libtool 1.4, dependencies were output in $dir.libs/$base.lo.d.
+ #
+ # With libtool 1.5 this exception was removed, and libtool now
+ # generates 2 separate objects for the 2 libraries. These two
+ # compilations output dependencies in $dir.libs/$base.o.d and
+ # in $dir$base.o.d. We have to check for both files, because
+ # one of the two compilations can be disabled. We should prefer
+ # $dir$base.o.d over $dir.libs/$base.o.d because the latter is
+ # automatically cleaned when .libs/ is deleted, while ignoring
+ # the former would cause a distcleancheck panic.
+ tmpdepfile1=$dir.libs/$base.lo.d # libtool 1.4
+ tmpdepfile2=$dir$base.o.d # libtool 1.5
+ tmpdepfile3=$dir.libs/$base.o.d # libtool 1.5
+ tmpdepfile4=$dir.libs/$base.d # Compaq CCC V6.2-504
+ "$@" -Wc,-MD
+ else
+ tmpdepfile1=$dir$base.o.d
+ tmpdepfile2=$dir$base.d
+ tmpdepfile3=$dir$base.d
+ tmpdepfile4=$dir$base.d
+ "$@" -MD
+ fi
+
+ stat=$?
+ if test $stat -eq 0; then :
+ else
+ rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"
+ exit $stat
+ fi
+
+ for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"
+ do
+ test -f "$tmpdepfile" && break
+ done
+ if test -f "$tmpdepfile"; then
+ sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile"
+ # That's a tab and a space in the [].
+ sed -e 's,^.*\.[a-z]*:[ ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
+ else
+ echo "#dummy" > "$depfile"
+ fi
+ rm -f "$tmpdepfile"
+ ;;
+
+#nosideeffect)
+ # This comment above is used by automake to tell side-effect
+ # dependency tracking mechanisms from slower ones.
+
+dashmstdout)
+ # Important note: in order to support this mode, a compiler *must*
+ # always write the preprocessed file to stdout, regardless of -o.
+ "$@" || exit $?
+
+ # Remove the call to Libtool.
+ if test "$libtool" = yes; then
+ while test $1 != '--mode=compile'; do
+ shift
+ done
+ shift
+ fi
+
+ # Remove `-o $object'.
+ IFS=" "
+ for arg
+ do
+ case $arg in
+ -o)
+ shift
+ ;;
+ $object)
+ shift
+ ;;
+ *)
+ set fnord "$@" "$arg"
+ shift # fnord
+ shift # $arg
+ ;;
+ esac
+ done
+
+ test -z "$dashmflag" && dashmflag=-M
+ # Require at least two characters before searching for `:'
+ # in the target name. This is to cope with DOS-style filenames:
+ # a dependency such as `c:/foo/bar' could be seen as target `c' otherwise.
+ "$@" $dashmflag |
+ sed 's:^[ ]*[^: ][^:][^:]*\:[ ]*:'"$object"'\: :' > "$tmpdepfile"
+ rm -f "$depfile"
+ cat < "$tmpdepfile" > "$depfile"
+ tr ' ' '
+' < "$tmpdepfile" | \
+## Some versions of the HPUX 10.20 sed can't process this invocation
+## correctly. Breaking it into two sed invocations is a workaround.
+ sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
+ rm -f "$tmpdepfile"
+ ;;
+
+dashXmstdout)
+ # This case only exists to satisfy depend.m4. It is never actually
+ # run, as this mode is specially recognized in the preamble.
+ exit 1
+ ;;
+
+makedepend)
+ "$@" || exit $?
+ # Remove any Libtool call
+ if test "$libtool" = yes; then
+ while test $1 != '--mode=compile'; do
+ shift
+ done
+ shift
+ fi
+ # X makedepend
+ shift
+ cleared=no
+ for arg in "$@"; do
+ case $cleared in
+ no)
+ set ""; shift
+ cleared=yes ;;
+ esac
+ case "$arg" in
+ -D*|-I*)
+ set fnord "$@" "$arg"; shift ;;
+ # Strip any option that makedepend may not understand. Remove
+ # the object too, otherwise makedepend will parse it as a source file.
+ -*|$object)
+ ;;
+ *)
+ set fnord "$@" "$arg"; shift ;;
+ esac
+ done
+ obj_suffix="`echo $object | sed 's/^.*\././'`"
+ touch "$tmpdepfile"
+ ${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@"
+ rm -f "$depfile"
+ cat < "$tmpdepfile" > "$depfile"
+ sed '1,2d' "$tmpdepfile" | tr ' ' '
+' | \
+## Some versions of the HPUX 10.20 sed can't process this invocation
+## correctly. Breaking it into two sed invocations is a workaround.
+ sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
+ rm -f "$tmpdepfile" "$tmpdepfile".bak
+ ;;
+
+cpp)
+ # Important note: in order to support this mode, a compiler *must*
+ # always write the preprocessed file to stdout.
+ "$@" || exit $?
+
+ # Remove the call to Libtool.
+ if test "$libtool" = yes; then
+ while test $1 != '--mode=compile'; do
+ shift
+ done
+ shift
+ fi
+
+ # Remove `-o $object'.
+ IFS=" "
+ for arg
+ do
+ case $arg in
+ -o)
+ shift
+ ;;
+ $object)
+ shift
+ ;;
+ *)
+ set fnord "$@" "$arg"
+ shift # fnord
+ shift # $arg
+ ;;
+ esac
+ done
+
+ "$@" -E |
+ sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
+ -e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' |
+ sed '$ s: \\$::' > "$tmpdepfile"
+ rm -f "$depfile"
+ echo "$object : \\" > "$depfile"
+ cat < "$tmpdepfile" >> "$depfile"
+ sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile"
+ rm -f "$tmpdepfile"
+ ;;
+
+msvisualcpp)
+ # Important note: in order to support this mode, a compiler *must*
+ # always write the preprocessed file to stdout, regardless of -o,
+ # because we must use -o when running libtool.
+ "$@" || exit $?
+ IFS=" "
+ for arg
+ do
+ case "$arg" in
+ "-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI")
+ set fnord "$@"
+ shift
+ shift
+ ;;
+ *)
+ set fnord "$@" "$arg"
+ shift
+ shift
+ ;;
+ esac
+ done
+ "$@" -E |
+ sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::echo "`cygpath -u \\"\1\\"`":p' | sort | uniq > "$tmpdepfile"
+ rm -f "$depfile"
+ echo "$object : \\" > "$depfile"
+ . "$tmpdepfile" | sed 's% %\\ %g' | sed -n '/^\(.*\)$/ s:: \1 \\:p' >> "$depfile"
+ echo " " >> "$depfile"
+ . "$tmpdepfile" | sed 's% %\\ %g' | sed -n '/^\(.*\)$/ s::\1\::p' >> "$depfile"
+ rm -f "$tmpdepfile"
+ ;;
+
+none)
+ exec "$@"
+ ;;
+
+*)
+ echo "Unknown depmode $depmode" 1>&2
+ exit 1
+ ;;
+esac
+
+exit 0
+
+# Local Variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-end: "$"
+# End:
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __AVSYS_AUDIO_ALSA_H__
+#define __AVSYS_AUDIO_ALSA_H__
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+#include <avsys-audio-handle.h>
+
+enum AIF_device_type_t {
+ AIF2_CAPTURE,
+ AIF2_PLAYBACK,
+ AIF3_CAPTURE,
+ AIF3_PLAYBACK,
+ AIF_DEVICE_MAX,
+};
+
+typedef struct {
+ void *alsa_handle;
+ int type;
+} avsys_audio_alsa_aif_handle_t;;
+
+int avsys_audio_alsa_open_AIF_device(const int AIF_type, avsys_audio_alsa_aif_handle_t *handle);
+int avsys_audio_alsa_close_AIF_device(avsys_audio_alsa_aif_handle_t* handle);
+int avsys_audio_alsa_set_AIF_params(avsys_audio_alsa_aif_handle_t *handle);
+
+#ifdef __cplusplus
+ }
+#endif
+
+#endif /* __AVSYS_AUDIO_H__ */
--- /dev/null
+/*\r
+ * avsystem\r
+ *\r
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.\r
+ *\r
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>\r
+ *\r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ *\r
+ */\r
+\r
+#ifndef __AVSYS_AUDIO_ASCENARIO_H__
+#define __AVSYS_AUDIO_ASCENARIO_H__
+\r
+typedef enum {\r
+ ASCN_RESET_NONE = 0,\r
+ ASCN_RESET_ALL,\r
+ ASCN_RESET_PLAYBACK,\r
+ ASCN_RESET_CAPTURE,\r
+ ASCN_RESET_MODEM,\r
+}AscnResetType;\r
+
+#define ASCN_STR_RESET "reset"
+#define ASCN_STR_RESET_PLAYBACK "reset_playback"
+#define ASCN_STR_RESET_CAPTURE "reset_capture"
+#define ASCN_STR_PLAYBACK_MUTE "mute_playback"
+#define ASCN_STR_PLAYBACK_UNMUTE "unmute_playback"
+#define ASCN_CODEC_DISABLE_ON_SUSPEND "codec_disable_on_suspend"
+
+#define IN 0
+#define OUT 16
+
+#define INPUT_CH_0 ((1 << (0 + IN))) /* Main Mic. 0x00000001 */
+#define INPUT_CH_1 ((1 << (1 + IN))) /* Sub Mic. 0x00000002 */
+#define INPUT_CH_2 ((1 << (2 + IN))) /* Stereo Mic. , 0x00000004 */
+#define INPUT_CH_3 ((1 << (3 + IN))) /* Ear Mic. , 0x00000008 */
+#define INPUT_CH_4 ((1 << (4 + IN))) /* BT Mic. 0x00000010 */
+#define INPUT_CH_5 ((1 << (5 + IN))) /* AP 0x00000020 */
+#define INPUT_CH_6 ((1 << (6 + IN))) /* CP 0x00000040 */
+#define INPUT_CH_7 ((1 << (7 + IN))) /* FM Radio 0x00000080 */
+#define INPUT_CH_8 ((1 << (8 + IN))) /* Reserved */
+#define INPUT_CH_9 ((1 << (9 + IN))) /* Reserved */
+
+#define OUTPUT_CH_0 ((1 << (0 + OUT))) /* Headset (Earphone) 0x00010000 */
+#define OUTPUT_CH_1 ((1 << (1 + OUT))) /* Left Speaker , 0x00020000 */
+#define OUTPUT_CH_2 ((1 << (2 + OUT))) /* Right Speaker , 0x00040000 */
+#define OUTPUT_CH_3 ((1 << (3 + OUT))) /* Stereo Speaker , 0x00080000 */
+#define OUTPUT_CH_4 ((1 << (4 + OUT))) /* Receiver (Mono) , 0x00100000 */
+#define OUTPUT_CH_5 ((1 << (5 + OUT))) /* BT Headset 0x00200000 */
+#define OUTPUT_CH_6 ((1 << (6 + OUT))) /* CP 0x00400000 */
+#define OUTPUT_CH_7 ((1 << (7 + OUT))) /* AP 0x00800000 */
+#define OUTPUT_CH_8 ((1 << (8 + OUT))) /* Gain */
+#define OUTPUT_CH_9 ((1 << (9 + OUT))) /* Video call gain */
+#define OUTPUT_CH_10 ((1 << (10 + OUT))) /* Video call gain */
+#define OUTPUT_CH_11 ((1 << (11 + OUT))) /* Reserved */
+#define OUTPUT_CH_12 ((1 << (12 + OUT))) /* Reserved */
+#define OUTPUT_CH_13 ((1 << (13 + OUT))) /* Call alert Gain */
+
+#define INPUT_MAIN_MIC (INPUT_CH_0)
+#define INPUT_SUB_MIC (INPUT_CH_1)
+#define INPUT_STEREO_MIC (INPUT_CH_2)
+#define INPUT_EAR_MIC (INPUT_CH_3)
+#define INPUT_BT_MIC (INPUT_CH_4)
+#define INPUT_AP (INPUT_CH_5)
+#define INPUT_CP (INPUT_CH_6)
+#define INPUT_FMRADIO (INPUT_CH_7)
+
+#define OUTPUT_HEADSET (OUTPUT_CH_0)
+#define OUTPUT_LEFT_SPK (OUTPUT_CH_1)
+#define OUTPUT_RIGHT_SPK (OUTPUT_CH_2)
+#define OUTPUT_STEREO_SPK (OUTPUT_CH_3)
+#define OUTPUT_RECV (OUTPUT_CH_4)
+#define OUTPUT_BT_HEADSET (OUTPUT_CH_5)
+#define OUTPUT_CP (OUTPUT_CH_6)
+#define OUTPUT_AP (OUTPUT_CH_7)
+
+#define GAIN_MODE (OUTPUT_CH_8)
+#define GAIN_VIDEO_CALL (OUTPUT_CH_9)
+#define GAIN_VOICE_CALL (OUTPUT_CH_10)
+#define GAIN_CALLALERT (OUTPUT_CH_13)
+\r
+/* function prototype */\r
+int avsys_audio_ascn_bulk_set(int * bulk, int bulk_cnt, AscnResetType clear);\r
+int avsys_audio_ascn_single_set(char * str);\r
+\r
+#endif /* __AVSYS_AUDIO_ASCENARIO_H__ */
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __AVSYS_AUDIO_HANDLE_H__
+#define __AVSYS_AUDIO_HANDLE_H__
+
+#include <pthread.h>
+#include "avsys-audio-logical-volume.h"
+
+#define AVSYS_AUDIO_HANDLE_MAX 64 /* this is related with allocated bit size in avsys_audio_handle_info_t*/
+#define AVSYS_AUDIO_LOCK_SLOT_MAX 4
+
+enum {
+ AVSYS_AUDIO_PRIMARY_VOLUME_CLEAR = 0,
+ AVSYS_AUDIO_PRIMARY_VOLUME_SET
+};
+
+enum {
+ AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_0 = 0, /**< normal */
+ AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_1, /**< solo */
+ AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_2, /**< solo with transition effect */
+ AVSYS_AUDIO_HANDLE_PRIORITY_TYPE_MAX,
+};
+
+enum {
+ AVSYS_AUDIO_HANDLE_EXT_DEV_NONE = 0x00000000,
+ AVSYS_AUDIO_HANDLE_EXT_DEV_FMRADIO = 0x00000001,
+};
+
+typedef struct {
+ /* common base */
+ int mode;
+ int channels;
+ int mute;
+ int format;
+ int samplerate;
+ int period;
+ int msec_per_period;
+ int pid;
+ int tid;
+ int priority;
+
+ /* logical volume */
+ avsys_audio_volume_setting_t gain_setting;
+ avsys_audio_volume_t setting_vol;
+ avsys_audio_volume_t working_vol;
+ int fadeup_vol;
+ int fadeup_multiplier;
+ char dirty_volume;
+
+ /* routing information */
+ char during_cp_audio;/* if this value set 1, this handle created during cp audio status (means call) */
+ char path_off;
+ int stream_index;
+ int handle_route;
+
+ /* backend specific */
+ void *device;
+} avsys_audio_handle_t;
+
+typedef struct {
+ long long int allocated;
+ int handle_amp; /* 1 for unmute, 0 for mute per each handle*/
+ int ext_device_amp;
+ int ext_device_status;
+ int volume_value[AVSYS_AUDIO_VOLUME_TYPE_MAX];
+ int primary_volume_type;
+ pid_t primary_volume_pid;
+ char handle_priority[AVSYS_AUDIO_HANDLE_MAX];
+ pid_t handlelock_pid[AVSYS_AUDIO_LOCK_SLOT_MAX];
+ avsys_audio_handle_t handles[AVSYS_AUDIO_HANDLE_MAX];
+} avsys_audio_handle_info_t;
+
+enum {
+ HANDLE_PTR_MODE_NORMAL,
+ HANDLE_PTR_MODE_FAST,
+ HANDLE_PTR_MODE_NUM,
+};
+
+int avsys_audio_handle_init(void);
+int avsys_audio_handle_fini(void);
+int avsys_audio_handle_reset(int *);
+int avsys_audio_handle_dump(void);
+int avsys_audio_handle_rejuvenation(void);
+int avsys_audio_handle_alloc(int *handle);
+int avsys_audio_handle_free(int handle);
+int avsys_audio_handle_get_ptr(int handle, avsys_audio_handle_t **ptr, const int mode);
+int avsys_audio_handle_release_ptr(int handle, const int mode);
+int avsys_audio_handle_set_mute(int handle, int mute);
+int avsys_audio_handle_ext_dev_set_mute(avsysaudio_ext_device_t device_type, int mute);
+int avsys_audio_handle_ext_dev_status(avsysaudio_ext_device_t device_type, int *onoff);
+int avsys_audio_handle_ext_dev_status_update(avsysaudio_ext_device_t device_type, int onoff);
+int avsys_audio_handle_current_playing_volume_type(int *type);
+int avsys_audio_handle_update_volume(avsys_audio_handle_t *p, const int vol_type);
+int avsys_audio_handle_update_volume_by_type(const int volume_type, const int volume_value);
+int avsys_audio_handle_set_primary_volume_type(const int pid, const int type, const int command);
+int avsys_audio_handle_update_priority(int handle, int priority, int handle_route, int cmd);
+int avsys_audio_handle_current_capture_status(int *on_capture);
+#endif /* __AVSYS_AUDIO_HANDLE_H__ */
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __AVSYS_AUDIO_LOGICAL_VOLUME_H__
+#define __AVSYS_AUDIO_LOGICAL_VOLUME_H__
+
+#include "avsys-audio.h"
+
+#define LVOLUME_MAX_MULTIMEDIA 16 /**< same with AVSYS_AUDIO_VOLUME_MAX_MULTIMEDIA */
+#define LVOLUME_MAX_BASIC 8 /**< same with AVSYS_AUDIO_VOLUME_MAX_BASIC */
+#define LVOLUME_MAX_SINGLE 1 /**< same with AVSYS_AUDIO_VOLUME_MAX_SINGLE */
+
+#define FADE_UP_MULTIPLIER 1//2
+#define FADE_DOWN_MULTIPLIER 1
+
+#define VOLUME_FILE_PATH "/opt/system/volume.txt"
+
+enum
+{
+ AVSYS_AUDIO_LVOL_GAIN_TYPE_0 = 0, /* system */
+ AVSYS_AUDIO_LVOL_GAIN_TYPE_1, /* notification */
+ AVSYS_AUDIO_LVOL_GAIN_TYPE_2, /* alarm */
+ AVSYS_AUDIO_LVOL_GAIN_TYPE_3, /* ringtone */
+ AVSYS_AUDIO_LVOL_GAIN_TYPE_4, /* media */
+ AVSYS_AUDIO_LVOL_GAIN_TYPE_5, /* call */
+ AVSYS_AUDIO_LVOL_GAIN_TYPE_6, /* android */
+ AVSYS_AUDIO_LVOL_GAIN_TYPE_7, /* java */
+ AVSYS_AUDIO_LVOL_GAIN_TYPE_8, /* music (media2) */
+ AVSYS_AUDIO_LVOL_GAIN_TYPE_MAX,
+};
+
+enum
+{
+ AVSYS_AUDIO_LVOL_DEV_TYPE_SPK,
+ AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET,
+ AVSYS_AUDIO_LVOL_DEV_TYPE_BTHEADSET,
+ AVSYS_AUDIO_LVOL_DEV_TYPE_MAX,
+};
+
+
+typedef struct {
+ int max_len;
+ avsys_audio_volume_t gain[LVOLUME_MAX_MULTIMEDIA];
+} avsys_a_logical_volume_t;
+
+
+typedef struct {
+ int type;
+ avsys_a_logical_volume_t devices[AVSYS_AUDIO_LVOL_DEV_TYPE_MAX];
+} avsys_logical_gain_t;
+
+typedef struct {
+ int vol_type;
+ int dev_type;
+ int max_len;
+ avsys_audio_volume_t *table;
+} avsys_audio_volume_setting_t;
+
+int avsys_audio_logical_volume_get_max(int vol_type, int dev_type, int *max);
+int avsys_audio_logical_volume_set_table(int vol_type, int dev_type, avsys_audio_volume_setting_t *setting);
+int avsys_audio_logical_volume_update_table(int dev_type, avsys_audio_volume_setting_t *setting);
+int avsys_audio_logical_volume_convert(avsys_audio_volume_t *level, avsys_audio_volume_t *converted, avsys_audio_volume_setting_t *setting);
+/* Tuning */
+int avsys_audio_logical_volume_init(void);
+int avsys_audio_logical_volume_set_to_table(int gain_type, int dev_type, int step, int lv, int rv);
+int avsys_audio_logical_volume_get_from_table(int gain_type, int dev_type, int step, int *lv, int *rv);
+int avsys_audio_load_volume_from_file(void);
+
+#endif /* __AVSYS_AUDIO_LOGICAL_VOLUME_H__ */
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __AVSYS_AUDIO_PACTRL_H__
+#define __AVSYS_AUDIO_PACTRL_H__
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+#include <avsys-audio-handle.h>
+#include <pulse/pulseaudio.h>
+#include <pulse/thread-mainloop.h>
+#include <pulse/error.h>
+#include <pulse/gccmacro.h>
+#include <pulse/proplist.h>
+
+/*
+ * Enums
+ */
+enum {
+ AVSYS_AUDIO_PA_CTL_SINK_UNKNOWN = 0x0000,
+ AVSYS_AUDIO_PA_CTL_SINK_ALSA = 0x0001,
+ AVSYS_AUDIO_PA_CTL_SINK_BLUEZ = 0x0002,
+};
+/*
+ * Defines
+ */
+#define ALSA_SINK 0
+#define BLUEZ_SINK 16
+
+#define _EXIST 1
+#define _DEACTIVE 2
+#define _ACTIVE 3
+
+#define ALSA_SINK_EXIST ((1 << (_EXIST + ALSA_SINK)))
+#define ALSA_SINK_DEACTIVE ((1 << (_DEACTIVE + ALSA_SINK)))
+#define ALSA_SINK_ACTIVE ((1 << (_ACTIVE + ALSA_SINK)))
+
+#define BULEZ_SINK_EXIST ((1 << (_EXIST + BLUEZ_SINK)))
+#define BULEZ_SINK_DEACTIVE ((1 << (_DEACTIVE + BLUEZ_SINK)))
+#define BULEZ_SINK_ACTIVE ((1 << (_ACTIVE + BLUEZ_SINK)))
+
+/*
+ * Function Prorotypes
+ */
+int avsys_audio_pa_ctrl_volume_by_index(unsigned int idx, int volume, int ch);
+int avsys_audio_pa_ctrl_mute_by_index(unsigned int idx, int mute);
+int avsys_audio_pa_ctrl_get_default_sink(int *sink);
+
+#ifdef __cplusplus
+ }
+#endif
+
+#endif /* __AVSYS_AUDIO_PACTRL_H__ */
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __AVSYS_AUDIO_PASIMPLE_H__
+#define __AVSYS_AUDIO_PASIMPLE_H__
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+#include <avsys-audio-handle.h>
+#include <pulse/simple.h>
+#include <pulse/error.h>
+#include <pulse/gccmacro.h>
+#include <pulse/proplist.h>
+
+typedef struct {
+ void *pasimple_handle;
+ unsigned int samplesize;
+ unsigned int period_frames;
+ unsigned int buffer_frames;
+ unsigned int mode;
+ unsigned int periods_per_buffer;
+} avsys_audio_pasimple_handle_t;
+
+int avsys_audio_pasimple_open_device(const int mode, const unsigned int format, const unsigned int channel, const unsigned int samplerate, avsys_audio_handle_t *handle,int policy);
+int avsys_audio_pasimple_close_device(avsys_audio_handle_t *handle);
+int avsys_audio_pasimple_write(avsys_audio_handle_t *handle, const void *buf, int size);
+int avsys_audio_pasimple_read(avsys_audio_handle_t *handle, void *buf, int size);
+int avsys_audio_pasimple_reset(avsys_audio_handle_t *handle);
+int avsys_audio_pasimple_drain(avsys_audio_handle_t *handle);
+int avsys_audio_pasimple_delay(avsys_audio_handle_t *handle, int *delay_frames);
+int avsys_audio_pasimple_set_volume(avsys_audio_handle_t *handle, int volume);
+int avsys_audio_pasimple_get_period_buffer_time(avsys_audio_handle_t *handle, unsigned int *period_time, unsigned int *buffer_time);
+
+#ifdef __cplusplus
+ }
+#endif
+
+#endif /* __AVSYS_AUDIO_PASIMPLE_H__ */
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __AVSYS_AUDIO_PATH_H__
+#define __AVSYS_AUDIO_PATH_H__
+
+#include "avsys-audio.h"
+#include "avsys-audio-handle.h"
+
+#include <sys/types.h>
+#include <stdbool.h>
+
+enum {
+ AVSYS_AUDIO_INSERTED_NONE = 0,
+ AVSYS_AUDIO_INSERTED_3,
+ AVSYS_AUDIO_INSERTED_4,
+ AVSYS_AUDIO_INSERTED_AV
+};
+
+enum avsys_audio_playback_gain{
+ AVSYS_AUDIO_PLAYBACK_GAIN_AP = 0,
+ AVSYS_AUDIO_PLAYBACK_GAIN_FMRADIO,
+ AVSYS_AUDIO_PLAYBACK_GAIN_VOICECALL,
+ AVSYS_AUDIO_PLAYBACK_GAIN_VIDEOCALL,
+ AVSYS_AUDIO_PLAYBACK_GAIN_CALLALERT,
+ AVSYS_AUDIO_PLAYBACK_GAIN_MAX
+};
+
+enum avsys_audio_capture_gain{
+ AVSYS_AUDIO_CAPTURE_GAIN_AP = 0,
+ AVSYS_AUDIO_CAPTURE_GAIN_FMRADIO,
+ AVSYS_AUDIO_CAPTURE_GAIN_VOICECALL,
+ AVSYS_AUDIO_CAPTURE_GAIN_VIDEOCALL,
+ AVSYS_AUDIO_CAPTURE_GAIN_MAX
+};
+
+enum avsys_audio_ear_ctrl {
+ AVSYS_AUDIO_EAR_SWITCH_MANUAL,
+ AVSYS_AUDIO_EAR_SWITCH_AUTO_WITH_MUTE,
+ AVSYS_AUDIO_EAR_SWITCH_AUTO_WITHOUT_MUTE,
+};
+
+struct avsys_audio_jack_event {
+ struct timeval time;
+ unsigned short type;
+ unsigned short code;
+ int value;
+};
+
+#define PATH_MASK_MAX 23
+#define GAIN_MASK_MAX 30
+/* sound path status bit */
+#define PS_PATH_NONE (0)
+#define PS_AP_TO_SPK (1 << 0)
+#define PS_AP_TO_HEADSET (1 << 1)
+#define PS_AP_TO_RECV (1 << 2)
+#define PS_AP_TO_HDMI (1 << 3)
+#define PS_AP_TO_BT (1 << 4)
+#define PS_AP_TO_MODEM (1 << 5)
+#define PS_MODEM_TO_SPK (1 << 6)
+#define PS_MODEM_TO_HEADSET (1 << 7)
+#define PS_MODEM_TO_RECV (1 << 8)
+#define PS_MODEM_TO_BT (1 << 9)
+#define PS_MODEM_TO_AP (1 << 10)
+#define PS_FMRADIO_TO_SPK (1 << 11)
+#define PS_FMRADIO_TO_HEADSET (1 << 12)
+#define PS_MAINMIC_TO_AP (1 << 13)
+#define PS_MAINMIC_TO_MODEM (1 << 14)
+#define PS_SUBMIC_TO_AP (1 << 15)
+#define PS_SUBMIC_TO_MODEM (1 << 16)
+#define PS_STEREOMIC_TO_AP (1 << 17)
+#define PS_EARMIC_TO_AP (1 << 18)
+#define PS_EARMIC_TO_MODEM (1 << 19)
+#define PS_BTMIC_TO_AP (1 << 20)
+#define PS_BTMIC_TO_MODEM (1 << 21)
+#define PS_FMRADIO_TO_AP (1 << 22)
+#define PS_CODEC_DISABLE_ON_SUSPEND (1 << 23)
+#define PS_CP_TO_AP (1 << PATH_MASK_MAX)
+
+
+/* hw gain status enum */
+#define GS_GAIN_NONE (0)
+#define GS_AP_TO_SPK (1 << 0)
+#define GS_AP_TO_SPK_CALLALERT (1 << 1)
+#define GS_AP_TO_HEADSET (1 << 2)
+#define GS_AP_TO_HEADSET_CALLALERT (1 << 3)
+#define GS_AP_TO_RECV (1 << 4)
+#define GS_AP_TO_HDMI (1 << 5)
+#define GS_AP_TO_BT (1 << 6)
+#define GS_AP_TO_MODEM (1 << 7)
+#define GS_MODEM_TO_SPK_VOICE (1 << 8)
+#define GS_MODEM_TO_HEADSET_VOICE (1 << 9)
+#define GS_MODEM_TO_RECV_VOICE (1 << 10)
+#define GS_MODEM_TO_BT_VOICE (1 << 11)
+#define GS_MODEM_TO_AP_VOICE (1 << 12)
+#define GS_MODEM_TO_SPK_VIDEO (1 << 13)
+#define GS_MODEM_TO_HEADSET_VIDEO (1 << 14)
+#define GS_MODEM_TO_RECV_VIDEO (1 << 15)
+#define GS_MODEM_TO_BT_VIDEO (1 << 16)
+#define GS_MODEM_TO_AP_VIDEO (1 << 17)
+#define GS_FMRADIO_TO_SPK (1 << 18)
+#define GS_FMRADIO_TO_HEADSET (1 << 19)
+#define GS_MAINMIC_TO_AP (1 << 20)
+#define GS_MAINMIC_TO_MODEM_VOICE (1 << 21)
+#define GS_SUBMIC_TO_AP (1 << 22)
+#define GS_SUBMIC_TO_MODEM_VOICE (1 << 23)
+#define GS_STEREOMIC_TO_AP (1 << 24)
+#define GS_EARMIC_TO_AP (1 << 25)
+#define GS_EARMIC_TO_MODEM_VOICE (1 << 26)
+#define GS_BTMIC_TO_AP (1 << 27)
+#define GS_BTMIC_TO_MODEM_VOICE (1 << 28)
+#define GS_FMRADIO_TO_AP (1 << 29)
+#define GS_CP_TO_AP (1 << GAIN_MASK_MAX)
+
+#define TYPE_EVENT_SWITCH 0x05
+#define CODE_HEADPHONE_INSERT 0x02
+#define CODE_MICROPHONE_INSERT 0x04
+#define CODE_LINEOUT_INSERT 0x06
+#define CODE_JACK_PHYSICAL_INSERT 0x07
+
+#define PATH_FIXED_NONE (0x00000000)
+#define PATH_FIXED_WITH_FMRADIO (1 << PATH_FIXED_TYPE_FMRADIO) /* 0x00000001 */
+#define PATH_FIXED_WITH_CALL (1 << PATH_FIXED_TYPE_CALL) /* 0x00000002 */
+
+enum avsys_audio_amp_t {
+ AVSYS_AUDIO_AMP_OFF = 0, /**< AMP OFF in pda out */
+ AVSYS_AUDIO_AMP_ON, /**< AMP ON in pda out */
+ AVSYS_AUDIO_AMP_OFF_ALL,
+};
+
+enum path_fixed_type_t {
+ PATH_FIXED_TYPE_FMRADIO = 0,
+ PATH_FIXED_TYPE_CALL,
+ PATH_FIXED_TYPE_MAX,
+};
+
+struct audio_route_info_t {
+ int playback;
+ int capture;
+};
+
+typedef struct audio_route_info_t gain_info_t;
+typedef struct audio_route_info_t path_info_t;
+typedef struct audio_route_info_t option_info_t;
+typedef struct audio_route_info_t gain_status_t;
+typedef struct audio_route_info_t path_status_t;
+
+typedef struct {
+ gain_info_t gain;
+ path_info_t path;
+
+ gain_info_t backup_gain;
+ path_info_t backup_path;
+
+ gain_info_t pregain;
+ gain_info_t reqgain;
+
+ option_info_t option;
+
+ /* path fixed information */
+ int path_fixed;
+ pid_t path_fixed_pid[PATH_FIXED_TYPE_MAX];
+
+ /* hw mute */
+ int mute;
+
+ /* For earphone control */
+ int inserted;
+ int ear_auto;
+
+ /* for alsa scenario, aquila */
+ gain_status_t gain_status;
+ path_status_t path_status;
+
+ gain_status_t p_gain_status;
+ path_status_t p_path_status;
+
+ int lvol_dev_type;
+ int gain_debug_mode;
+
+ /* For Lock debugging */
+ pid_t pathlock_pid[AVSYS_AUDIO_LOCK_SLOT_MAX];
+
+ /* system route policy */
+ avsys_audio_route_policy_t route_policy;
+ int a2dp_status;
+ int earpiece_on;
+} avsys_audio_path_ex_info_t;
+
+int avsys_audio_path_ex_init(void);
+int avsys_audio_path_ex_fini(void);
+int avsys_audio_path_ex_reset(int forced);
+int avsys_audio_path_ex_dump(void);
+int avsys_audio_path_ex_set_path(int gain, int out, int in, int option);
+int avsys_audio_path_ex_get_path(int *gain, int *out, int *in, int *option);
+int avsys_audio_path_manage_earjack(void);
+int avsys_audio_path_ex_set_amp(const int onoff);
+int avsys_audio_path_ex_set_mute(const int mute);
+int avsys_audio_path_ex_get_mute(int *mute);
+int avsys_audio_path_set_volume(int handle);
+
+int avsys_audio_path_earjack_init(int *init_type, int *outfd);
+int avsys_audio_path_earjack_wait(int fd, int *current_type, int *new_type, int *is_auto_mute);
+int avsys_audio_path_earjack_process(int new_type);
+int avsys_audio_path_earjack_deinit(int fd);
+int avsys_audio_path_earjack_unlock(void);
+
+int avsys_audio_path_set_route_policy(avsys_audio_route_policy_t route);
+int avsys_audio_path_get_route_policy(avsys_audio_route_policy_t *route);
+int avsys_audio_path_check_loud(bool *loud);
+int avsys_audio_path_check_cp_audio(bool *cpaudio, bool *btpath);
+int avsys_audio_path_set_single_ascn(char *str);
+
+#endif /* __AVSYS_AUDIO_PATH_H__ */
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __AVSYS_AUDIO_SHM_H__
+#define __AVSYS_AUDIO_SHM_H__
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+typedef enum {
+ AVSYS_AUDIO_SHM_IDEN_HANDLE,
+ AVSYS_AUDIO_SHM_IDEN_PATH,
+ AVSYS_AUDIO_SHM_IDEN_LVOLUME,
+ AVSYS_AUDIO_SHM_IDEN_CNT
+} avsys_audio_shm_iden_t;
+
+int avsys_audio_create_shm(const avsys_audio_shm_iden_t iden);
+int avsys_audio_remove_shm(const avsys_audio_shm_iden_t iden);
+int avsys_audio_get_shm(const avsys_audio_shm_iden_t iden, void **ptr);
+
+#ifdef __cplusplus
+ }
+#endif
+
+#endif /* __AVSYS_AUDIO_SHM_H__ */
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __AVSYS_AUDIO_SYNC_H__
+#define __AVSYS_AUDIO_SYNC_H__
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+typedef enum {
+ AVSYS_AUDIO_SYNC_IDEN_HANDLE,
+ AVSYS_AUDIO_SYNC_IDEN_PATH,
+ AVSYS_AUDIO_SYNC_IDEN_SOUNDPATH,
+ AVSYS_AUDIO_SYNC_IDEN_VOLUME,
+ AVSYS_AUDIO_SYNC_IDEN_CNT
+} avsys_audio_sync_iden_t;
+
+int avsys_audio_create_sync(const avsys_audio_sync_iden_t iden);
+int avsys_audio_remove_sync(const avsys_audio_sync_iden_t iden);
+int avsys_audio_lock_sync(const avsys_audio_sync_iden_t iden);
+int avsys_audio_unlock_sync(const avsys_audio_sync_iden_t iden);
+int avsys_check_process(int check_pid);
+
+#ifdef __cplusplus
+ }
+#endif
+
+#endif /* __AVSYS_AUDIO_SYNC_H__ */
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __AVSYS_AUDIO_H__
+#define __AVSYS_AUDIO_H__
+
+#include "avsys-types.h"
+#include "avsys-error.h"
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+/**
+ @addtogroup AVSYSTEM
+ @{
+
+ @par
+ This part describes the interface with audio input/output.
+ */
+
+#define AVSYS_AUDIO_VOLUME_MAX_MULTIMEDIA 16
+#define AVSYS_AUDIO_VOLUME_MAX_BASIC 8
+#define AVSYS_AUDIO_VOLUME_MAX_SINGLE 1
+
+/**
+ * Enumerations for audio mode
+ */
+enum avsys_audio_mode_t {
+ AVSYS_AUDIO_MODE_OUTPUT, /**< Output mode of handle */
+ AVSYS_AUDIO_MODE_OUTPUT_CLOCK, /**< Output mode of gst audio only mode */
+ AVSYS_AUDIO_MODE_OUTPUT_VIDEO, /**< Output mode of gst video mode */
+ AVSYS_AUDIO_MODE_OUTPUT_LOW_LATENCY, /**< Output mode for low latency play mode. typically for game */
+ AVSYS_AUDIO_MODE_INPUT, /**< Input mode of handle */
+ AVSYS_AUDIO_MODE_INPUT_HIGH_LATENCY, /**< Input mode for high latency capture mode. */
+ AVSYS_AUDIO_MODE_INPUT_LOW_LATENCY, /**< Input mode for low latency capture mode. typically for VoIP */
+ AVSYS_AUDIO_MODE_CALL_OUT, /**< for voice call establish */
+ AVSYS_AUDIO_MODE_CALL_IN, /**< for voice call establish */
+ AVSYS_AUDIO_MODE_OUTPUT_AP_CALL, /**< for VT call on thin modem */
+ AVSYS_AUDIO_MODE_INPUT_AP_CALL, /**< for VT call on thin modem */
+ AVSYS_AUDIO_MODE_NUM, /**< Number of mode */
+};
+
+/**
+ * Enumerations for audio format
+ */
+enum avsys_audio_format_t {
+ AVSYS_AUDIO_FORMAT_UNKNOWN = -1, /**< Invalid audio format */
+ AVSYS_AUDIO_FORMAT_8BIT, /**< Unsigned 8Bit */
+ AVSYS_AUDIO_FORMAT_16BIT, /**< Signed 16bit Little Endian */
+ AVSYS_AUDIO_FORMAT_MIN = AVSYS_AUDIO_FORMAT_8BIT, /**< Minimum value 8-bit integer per sample */
+ AVSYS_AUDIO_FORMAT_MAX = AVSYS_AUDIO_FORMAT_16BIT, /**< Maximum value 16-bit integer per sample */
+};
+
+
+/*
+ * Enums for volume types
+ */
+enum avsys_audio_volume_type_t {
+ AVSYS_AUDIO_VOLUME_TYPE_SYSTEM,
+ AVSYS_AUDIO_VOLUME_TYPE_NOTIFICATION,
+ AVSYS_AUDIO_VOLUME_TYPE_ALARM,
+ AVSYS_AUDIO_VOLUME_TYPE_RINGTONE,
+ AVSYS_AUDIO_VOLUME_TYPE_MEDIA,
+ AVSYS_AUDIO_VOLUME_TYPE_CALL,
+ AVSYS_AUDIO_VOLUME_TYPE_FIXED,
+ AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_JAVA,
+ AVSYS_AUDIO_VOLUME_TYPE_MEDIA_HL,
+ AVSYS_AUDIO_VOLUME_TYPE_NUM,
+ AVSYS_AUDIO_VOLUME_TYPE_MAX = AVSYS_AUDIO_VOLUME_TYPE_NUM,
+ AVSYS_AUDIO_VOLUME_TYPE_EXT_SYSTEM_ANDROID = AVSYS_AUDIO_VOLUME_TYPE_FIXED,
+};
+
+enum avsys_audio_priority_t {
+ AVSYS_AUDIO_PRIORITY_0 = 0, /*< deprecated. use AVSYS_AUDIO_PRIORITY_NORMAL or AVSYS_AUDIO_PRIORITY_SOLO instead */
+ AVSYS_AUDIO_PRIORITY_NORMAL = AVSYS_AUDIO_PRIORITY_0,
+ AVSYS_AUDIO_PRIORITY_SOLO,
+ AVSYS_AUDIO_PRIORITY_SOLO_WITH_TRANSITION_EFFECT,
+ AVSYS_AUDIO_PRIORITY_MAX,
+};
+
+enum avsys_audio_device_t {
+ AVSYS_AUDIO_DEVICE_TYPE_SPK = 0,
+ AVSYS_AUDIO_DEVICE_TYPE_RECV,
+ AVSYS_AUDIO_DEVICE_TYPE_HEADSET,
+ AVSYS_AUDIO_DEVICE_TYPE_HANDSFREE,
+ AVSYS_AUDIO_DEVICE_TYPE_BT,
+ AVSYS_AUDIO_DEVICE_TYPE_NUM,
+ AVSYS_AUDIO_DEVICE_TYPE_MAX = AVSYS_AUDIO_DEVICE_TYPE_NUM,
+};
+
+/**
+ * Enumerations for audio channel
+ */
+enum avsys_audio_channel_t {
+ AVSYS_AUDIO_CHANNEL_LEFT, /**< front-left channel */
+ AVSYS_AUDIO_CHANNEL_RIGHT, /**< front-righth channel */
+ AVSYS_AUDIO_CHANNEL_NUM, /**< Number of channels */
+};
+
+/**
+ * Enumerations for audio mute condition
+ */
+enum avsys_audio_mute_t {
+ AVSYS_AUDIO_UNMUTE = 0, /**< Unmute state */
+ AVSYS_AUDIO_MUTE, /**< Mute state */
+ AVSYS_AUDIO_UNMUTE_NOLOCK, /** < Unmute without lock */
+ AVSYS_AUDIO_MUTE_NOLOCK, /** < Mute without lock */
+};
+
+/**
+ * Enumerations for priority command
+ */
+enum avsys_audio_priority_cmd_t {
+ AVSYS_AUDIO_SET_PRIORITY = 0, /**< Command set priority */
+ AVSYS_AUDIO_UNSET_PRIORITY, /**< Command unset priority */
+};
+
+/**
+ * Structure for sound device parameters.
+ */
+typedef struct {
+ int mode; /**< Open mode (In/Out) */
+ int priority; /**< Priority of sound handle */
+ int channels; /**< Number of channels */
+ int samplerate; /**< Sampling rate */
+ int format; /**< Sampling format */
+ int bluetooth; /**< Handle route information. refer. avsys_audio_handle_route_t */
+ int vol_type; /**< volume type */
+ int allow_mix;
+} avsys_audio_param_t;
+
+
+/**
+ * Structure for volume information.
+ */
+typedef struct {
+ int level[AVSYS_AUDIO_CHANNEL_NUM]; /**< Array of volume level for each channel */
+} avsys_audio_volume_t;
+
+/* NEW PATH DEFINE */
+ /**
+ *
+ */
+enum avsys_audio_path_ex {
+ AVSYS_AUDIO_PATH_EX_NONE = 0,
+ AVSYS_AUDIO_PATH_EX_SPK,
+ AVSYS_AUDIO_PATH_EX_RECV,
+ AVSYS_AUDIO_PATH_EX_HEADSET,
+ AVSYS_AUDIO_PATH_EX_BTHEADSET,
+ AVSYS_AUDIO_PATH_EX_A2DP,
+ AVSYS_AUDIO_PATH_EX_HANDSFREE,
+ AVSYS_AUDIO_PATH_EX_HDMI,
+ AVSYS_AUDIO_PATH_EX_OUTMAX,
+ AVSYS_AUDIO_PATH_EX_MIC = 1,
+ AVSYS_AUDIO_PATH_EX_HEADSETMIC,
+ AVSYS_AUDIO_PATH_EX_BTMIC,
+ AVSYS_AUDIO_PATH_EX_FMINPUT,
+ AVSYS_AUDIO_PATH_EX_HANDSFREEMIC,
+ AVSYS_AUDIO_PATH_EX_INMAX,
+};
+
+enum avsys_audio_gain_ex {
+ AVSYS_AUDIO_GAIN_EX_KEYTONE = 0,
+ AVSYS_AUDIO_GAIN_EX_RINGTONE,
+ AVSYS_AUDIO_GAIN_EX_ALARMTONE,
+ AVSYS_AUDIO_GAIN_EX_CALLTONE,
+ AVSYS_AUDIO_GAIN_EX_AUDIOPLAYER,
+ AVSYS_AUDIO_GAIN_EX_VIDEOPLAYER,
+ AVSYS_AUDIO_GAIN_EX_VOICECALL,
+ AVSYS_AUDIO_GAIN_EX_VIDEOCALL,
+ AVSYS_AUDIO_GAIN_EX_FMRADIO,
+ AVSYS_AUDIO_GAIN_EX_VOICEREC,
+ AVSYS_AUDIO_GAIN_EX_CAMCORDER,
+ AVSYS_AUDIO_GAIN_EX_CAMERA,
+ AVSYS_AUDIO_GAIN_EX_GAME,
+ AVSYS_AUDIO_GAIN_EX_MAX,
+ AVSYS_AUDIO_GAIN_EX_PDA_PLAYBACK = AVSYS_AUDIO_GAIN_EX_KEYTONE,
+};
+
+typedef enum {
+ AVSYS_AUDIO_EXT_DEVICE_FMRADIO = 0,
+ AVSYS_AUDIO_EXT_DEVICE_NUM
+}avsysaudio_ext_device_t;
+
+
+typedef enum {
+ AVSYS_AUDIO_ROUTE_POLICY_DEFAULT,
+ AVSYS_AUDIO_ROUTE_POLICY_IGNORE_A2DP,
+ AVSYS_AUDIO_ROUTE_POLICY_HANDSET_ONLY,
+ AVSYS_AUDIO_ROUTE_POLICY_MAX,
+}avsys_audio_route_policy_t; /* system global configuration */
+
+enum avsys_audio_handle_route_t{
+ AVSYS_AUDIO_HANDLE_ROUTE_FOLLOWING_POLICY,
+ AVSYS_AUDIO_HANDLE_ROUTE_HANDSET_ONLY,
+}; /* custom routing per handle */
+
+typedef enum {
+ AVSYS_AUDIO_ROUTE_DEVICE_UNKNOWN = -1,
+ AVSYS_AUDIO_ROUTE_DEVICE_HANDSET,
+ AVSYS_AUDIO_ROUTE_DEVICE_BLUETOOTH,
+ AVSYS_AUDIO_ROUTE_DEVICE_EARPHONE,
+ AVSYS_AUDIO_ROUTE_DEVICE_NUM,
+}avsys_audio_playing_devcie_t;/* routing device */
+
+/* path option */
+#define AVSYS_AUDIO_PATH_OPTION_NONE 0x00000000 /*!< Sound path option none */
+#define AVSYS_AUDIO_PATH_OPTION_JACK_AUTO 0x00000001 /*!< Sound path auto change between SPK/Recv and headset */
+#define AVSYS_AUDIO_PATH_OPTION_DUAL_OUT 0x00000002 /*!< SPK or Recv with headset sound path. used for Ringtone or Alarm */
+#define AVSYS_AUDIO_PATH_OPTION_LEFT_SPK_ONLY 0x00000004 /*!< AP playback left speaker only */
+#define AVSYS_AUDIO_PATH_OPTION_RIGHT_SPK_ONLY 0x00000008 /*!< AP playback right speaker only */
+#define AVSYS_AUDIO_PATH_OPTION_VOICECALL_REC 0x00000010 /*!< Voice call recording path option */
+#define AVSYS_AUDIO_PATH_OPTION_USE_SUBMIC 0x00000020 /*!< Use sub-mic when call or recording */
+#define AVSYS_AUDIO_PATH_OPTION_USE_STEREOMIC 0x00000040 /*!< Use stereo mic when recording */
+#define AVSYS_AUDIO_PATH_OPTION_FORCED 0x01000000 /*!< Forced sound path setting. only for booting animation */
+#define AVSYS_AUDIO_PATH_OPTION_LEGACY_MODE 0x10000000 /*!< Now Plus Style */
+
+
+/**
+ * This function make instance for audio system, and retreives handle.
+ *
+ * @param param [in] Parameters of audio system.
+ * @param phandle [out] Handle of audio system.
+ * @param size [out] Recomended buffer size.
+ *
+ * @return This function returns AVSYS_STATE_SUCCESS on success, or negative
+ * value with error code.
+ * on failure.
+ * @remark
+ * @see
+ */
+int avsys_audio_open(avsys_audio_param_t *param, avsys_handle_t *phandle, int *size);
+
+/**
+ * This function is to close sound handle and release allocated resources.
+ *
+ * @param handle [in] Handle of audio system
+ *
+ * @return This function returns AVSYS_STATE_SUCCESS on success, or negative
+ * value with error code.
+ * @remark
+ * @see
+ */
+int avsys_audio_close(avsys_handle_t handle);
+
+/**
+ * This function is to stop playback stream immediately. this drops all buffer remaining data.
+ *
+ * @param handle [in] Playback handle of audio system
+ *
+ * @return This function returns AVSYS_STATE_SUCCESS on success, or negative
+ * value with error code.
+ * @remark
+ * @see
+ */
+int avsys_audio_flush(avsys_handle_t handle);
+
+/**
+ * This function is to stop playback stream after all remaining buffer data played.
+ *
+ * @param handle [in] Playback handle of audio system
+ *
+ * @return This function returns AVSYS_STATE_SUCCESS on success, or negative
+ * value with error code.
+ * @remark
+ * @see
+ */
+int avsys_audio_drain(avsys_handle_t handle);
+
+/**
+ * This function is turn on speaker amp.
+ *
+ *
+ * @return This function returns AVSYS_STATE_SUCCESS on success, or negative
+ * value with error code.
+ * @remark
+ * @see
+ */
+int avsys_audio_ampon(void) __attribute__((deprecated));
+
+/**
+ * This function is turn off speaker amp.
+ *
+ * @return This function returns AVSYS_STATE_SUCCESS on success, or negative
+ * value with error code.
+ * @remark
+ * @see
+ */
+int avsys_audio_ampoff(void) __attribute__((deprecated));
+
+/**
+ * This function is to read pcm data from sound handle.
+ *
+ * @param handle [in] Handle of audio system
+ * @param buf [in] Buffer of audio data to read
+ * @param size [in] Size of buffer
+ *
+ * @return This function returns number of bytes read, or negative value with
+ * error code on failure.
+ * @remark
+ * @see
+ */
+int avsys_audio_read(avsys_handle_t handle, void *buf, int size);
+
+/**
+ * This function is to write audio data to sound handle.
+ *
+ * @param handle [in] Handle of audio system
+ * @param buf [in] Buffer of audio data to write
+ * @param size [in] Size of buffer
+ *
+ * @return This function returns number of bytes written, or negative value
+ * with error code on failure.
+ * @remark
+ * @see
+ */
+int avsys_audio_write(avsys_handle_t handle, void *buf, int size);
+
+int avsys_audio_set_volume_table(int gain_type, int dev_type, int step, int lv, int rv);
+int avsys_audio_get_volume_table(int gain_type, int dev_type, int step, int *lv, int *rv);
+
+int avsys_audio_set_volume_fadeup(avsys_handle_t handle);
+
+/**
+ * This function is to get volume max.
+ *
+ * @param vol_type [in] Type of volume table
+ * @param max [out] number of volume steps
+ *
+ * @return This function returns AVSYS_STATE_SUCCESS on success, or negative
+ * value with error code.
+ * @remark
+ * @see
+ */
+int avsys_audio_get_volume_max_ex(int volume_table, int *max_step);
+
+/**
+ * This function is to set relative mute of sound handle.
+ *
+ * @param handle [in] Handle of audio system
+ * @param mute [in] Mute information to set
+ *
+ * @return This function returns AVSYS_STATE_SUCCESS on success, or negative
+ * value with error code.
+ * @remark
+ * mute is AVSYS_AUDIO_MUTE : mute
+ * mute is AVSYS_AUDIO_UNMUTE : unmute
+ * @see
+ */
+int avsys_audio_set_mute(avsys_handle_t handle, int mute);
+
+
+/**
+ * This function is to set mute of sound handle with fade out effect.
+ *
+ * @param handle [in] Handle of audio system
+ *
+ * @return This function returns AVSYS_STATE_SUCCESS on success, or negative
+ * value with error code.
+ * @remark
+ * @see
+ */
+int avsys_audio_set_mute_fadedown(avsys_handle_t handle);
+
+/**
+ * This function is to get relative mute of sound handle.
+ *
+ * @param handle [in] Handle of audio system
+ * @param pmute [out] Pointer to mute information to retrieve
+ *
+ * @return This function returns AVSYS_STATE_SUCCESS on success, or negative
+ * value with error code.
+ * @remark
+ * pmute is AVSYS_AUDIO_MUTE : mute
+ * pmute is AVSYS_AUDIO_UNMUTE : unmute
+ * @see avsys_audio_mute_t
+ */
+int avsys_audio_get_mute(avsys_handle_t handle, int* pmute);
+
+
+/**
+ * This function is to set amp on external device
+ *
+ * @param device [in] External audio device type
+ *
+ * @return This function returns AVSYS_STATE_SUCCESS on success, or negative
+ * value with error code.
+ * @remark
+ * mute is AVSYS_AUDIO_MUTE : mute
+ * mute is AVSYS_AUDIO_UNMUTE : unmute
+ * @see avsysaudio_ext_device_t
+ */
+int avsys_audio_ext_device_ampon(avsysaudio_ext_device_t device);
+
+/**
+ * This function is to set amp off external device
+ *
+ * @param device [in] External audio device type
+ *
+ * @return This function returns AVSYS_STATE_SUCCESS on success, or negative
+ * value with error code.
+ * @remark
+ * pmute is AVSYS_AUDIO_MUTE : mute
+ * pmute is AVSYS_AUDIO_UNMUTE : unmute
+ * @see avsysaudio_ext_device_t
+ */
+int avsys_audio_ext_device_ampoff(avsysaudio_ext_device_t device);
+
+/**
+ * This function is to set status of external device
+ *
+ * @param device [in] External audio device type
+ * @param onoff [in] 1 for on , 0 for off
+ *
+ * @return This function returns AVSYS_STATE_SUCCESS on success, or negative
+ * value with error code.
+ * @remark
+ * @see avsysaudio_ext_device_t
+ */
+int avsys_audio_set_ext_device_status(avsysaudio_ext_device_t device_type, int onoff);
+
+/**
+ * This function is to get status of external device
+ *
+ * @param device [in] External audio device type
+ * @param onoff [out] 1 for on , 0 for off
+ *
+ * @return This function returns AVSYS_STATE_SUCCESS on success, or negative
+ * value with error code.
+ * @remark
+ * @see avsys_audio_set_ext_device_status
+ */
+int avsys_audio_get_ext_device_status(avsysaudio_ext_device_t device_type, int *onoff);
+/**
+ * This function is to set sound path of sound device.
+ *
+ * @param path [in] value of sound gain
+ * @param output [in] value of output device
+ * @param input [in] value of input device
+ * @param option [in] value of sound path option
+ *
+ * @return This function returns AVSYS_STATE_SUCCESS on success, or negative
+ * value with error code.
+ * AVSYS_STATE_ERR_RANGE_OVER : input path value is invalid range
+ * AVSYS_STATE_ERR_INTERNAL : internal device error
+ * @remark
+ * @see
+ */
+int avsys_audio_set_path_ex(int gain, int out, int in, int option);
+
+/**
+ * This function is to get sound path of sound device.
+ *
+ * @param path [out] value of sound gain
+ * @param output [out] value of output device
+ * @param input [out] value of input device
+ * @param option [out] value of sound path option
+ *
+ * @return This function returns AVSYS_STATE_SUCCESS on success, or negative
+ * value with error code.
+ * AVSYS_STATE_ERR_INTERNAL : internal device error
+ * @remark
+ * @see
+ */
+int avsys_audio_get_path_ex(int *gain, int *out, int *in, int *option);
+
+/**
+ * This function is to set relative global mute of sound device.
+ *
+ * @param mute [in] Global mute information to retreive
+ *
+ * @return This function returns AVSYS_STATE_SUCCESS on success, or negative
+ * value with error code.
+ * @remark
+ * mute is avsys_audio_mute_disable : unmute
+ * mute is avsys_audio_mute_enable : mute
+ * others : ignore
+ * @see avsys_audio_mute_t
+ */
+int avsys_audio_set_global_mute(int mute);
+
+/**
+ * This function is to get relative global mute of sound device.
+ *
+ * @param pmute [out] Pointer to global mute information to retreive
+ *
+ * @return This function returns AVSYS_STATE_SUCCESS on success, or negative
+ * value with error code.
+ * @remark
+ * *pbmute is avsys_audio_mute_disable or avsys_audio_mute_enable
+ * @see
+ */
+int avsys_audio_get_global_mute(int* pmute);
+
+/**
+ * This function is to get number of remaining audio frames in hw buffer.
+ *
+ * @param handle [in] handle to get delay frames
+ * @param frame_delay [out] value of number of remaining audio frames
+ *
+ * @return This function returns AVSYS_STATE_SUCCESS on success, or negative
+ * value with error code.
+ * @remark
+ * @see
+ */
+int avsys_audio_delay(avsys_handle_t handle, int *frame_delay);
+
+/**
+ * This function is to reset audio stream. (drops all remaining audio frames in device buffer)
+ *
+ * @param handle [in] handle to reset
+ *
+ * @return This function returns AVSYS_STATE_SUCCESS on success, or negative
+ * value with error code.
+ * @remark
+ * @see
+ */
+int avsys_audio_reset(avsys_handle_t handle);
+
+/**
+ * This function is to get period time and buffer time of audio stream.
+ *
+ * @param handle [in] handle to get period & buffer time
+ * @param period_time [out] value of period time in microsecond.
+ * @param buffer_time [out] value of buffer time in microsecond.
+ *
+ * @return This function returns AVSYS_STATE_SUCCESS on success, or negative
+ * value with error code.
+ * @remark
+ * @see
+ */
+int avsys_audio_get_period_buffer_time(avsys_handle_t handle, unsigned int *period_time, unsigned int *buffer_time);
+
+/**
+ * This function is to get playback audio device information of system.
+ *
+ * @param dev [out] current playback device type
+ *
+ * @return This function returns AVSYS_STATE_SUCCESS on success, or negative
+ * value with error code.
+ * @remark
+ * @see avsys_audio_playing_devcie_t
+ */
+int avsys_audio_get_playing_device_info(avsys_audio_playing_devcie_t *dev);
+
+/**
+ * This function is to get audio capturing status of system.
+ *
+ * @param on_capture [out] capture status.
+ * zero if there is no capture instance.
+ * positive value if there is capture instance
+ *
+ * @return This function returns AVSYS_STATE_SUCCESS on success, or negative
+ * value with error code.
+ * @remark
+ * @see
+ */
+int avsys_audio_get_capture_status(int *on_capture);
+
+int avsys_audio_earjack_manager_init(int *earjack_type, int *waitfd);
+int avsys_audio_earjack_manager_wait(int waitfd, int *current_earjack_type, int *new_earjack_type, int *need_mute);
+int avsys_audio_earjack_manager_process(int new_earjack_type);
+int avsys_audio_earjack_manager_deinit(int waitfd);
+int avsys_audio_earjack_manager_unlock(void);
+
+int avsys_audio_set_route_policy(avsys_audio_route_policy_t route);
+int avsys_audio_get_route_policy(avsys_audio_route_policy_t *route);
+int avsys_audio_get_current_playing_volume_type(int *volume_type);
+int avsys_audio_set_volume_by_type(const int volume_type, const int volume_value);
+int avsys_audio_set_primary_volume(const int pid, const int type);
+int avsys_audio_clear_primary_volume(const int pid);
+int avsys_audio_hibernation_reset(int *vol);
+/**
+ @}
+ */
+
+#ifdef __cplusplus
+ }
+#endif
+
+#endif /* __AVSYS_AUDIO_H__ */
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __AVSYS_COMMON_H__
+#define __AVSYS_COMMON_H__
+
+#include <stdlib.h>
+#include <sys/syscall.h>
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+#define EXPORT_API __attribute__((__visibility__("default")))
+
+#define AVSYS_MAGIC_START "TSVA"
+#define AVSYS_MAGIC_END "NEVA"
+
+#define AVSYS_KEY_PREFIX_AUDIO 0x10
+#define AVSYS_KEY_PREFIX_GEN(X,Y) ((X) + (Y))
+
+typedef struct {
+ char *key_path;
+ int key_prefix;
+ int size;
+} avsys_shm_param_t;
+
+typedef struct {
+ char *key_path;
+ int key_prefix;
+} avsys_sync_param_t;
+
+
+#define LOCK_TIMEOUT_SEC 6
+
+/* get thread id : Not implemented 'gettid' at system libs. */
+#define avsys_gettid() (long int)syscall(__NR_gettid)
+
+/* memory */
+void * avsys_malloc(size_t size);
+void avsys_free(void *ptr);
+#define avsys_mem_check(ptr) ( (memcmp(AVSYS_MAGIC_START, ((char*)(ptr))-8, 4) == 0) && \
+ (memcmp(AVSYS_MAGIC_END, ((char*)(ptr))+(*((int*)((ptr)-4))), 4) == 0) )
+
+/* shared memory */
+int avsys_create_shm(const avsys_shm_param_t* param);
+int avsys_remove_shm(const avsys_shm_param_t* param);
+void* avsys_get_shm(const avsys_shm_param_t* param);
+
+/* Sync object */
+int avsys_create_sync(const avsys_sync_param_t *param);
+int avsys_remove_sync(const avsys_sync_param_t *param);
+int avsys_lock_sync(const avsys_sync_param_t *param);
+int avsys_unlock_sync(const avsys_sync_param_t *param);
+
+/* Privilege */
+int avsys_check_root_privilege(void);
+
+#ifdef __cplusplus
+ }
+#endif
+
+#endif /* __AVSYS_COMMON_H__ */
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/**
+ * This file defines the debug function of AV System.
+ *
+ * @file avsys_debug.h
+ * @version 0.1
+ */
+
+#ifndef __AVSYS_DEBUG_H__
+#define __AVSYS_DEBUG_H__
+
+#ifdef __USE_LOGMANAGER__
+#include <stdio.h>
+#include <mm_log.h>
+#define AVAUDIO LOG_AVAUDIO
+#define AVVIDEO LOG_AVVIDEO
+#define AVCAMERA LOG_AVCAMERA
+#else
+#define AVAUDIO
+#define AVVIDEO
+#define AVCAMERA
+#endif
+
+#ifdef __DEBUG_MODE__
+#ifdef __USE_LOGMANAGER__
+
+#define avsys_info_r(owner, msg, args...) log_print_rel( owner, LOG_CLASS_INFO, "[%05d:%s] "msg, __LINE__, __func__, ##args )
+#define avsys_warning_r(owner, msg, args...) log_print_rel( owner, LOG_CLASS_WARNING, "[%05d:%s] "msg, __LINE__, __func__, ##args )
+#define avsys_error_r(owner, msg, args...) log_print_rel( owner, LOG_CLASS_ERR, "[%05d:%s] "msg, __LINE__, __func__, ##args )
+#define avsys_critical_r(owner, msg, args...) log_print_rel( owner, LOG_CLASS_CRITICAL, "[%05d:%s] "msg, __LINE__, __func__, ##args )
+#define avsys_assert_r(condition) log_assert_rel(( condition ))
+
+#define avsys_info(owner, msg, args...) log_print_dbg( owner, LOG_CLASS_INFO, "[%05d:%s] "msg, __LINE__, __func__, ##args )
+#define avsys_warning(owner, msg, args...) log_print_dbg( owner, LOG_CLASS_WARNING, "[%05d:%s] "msg, __LINE__, __func__, ##args )
+#define avsys_error(owner, msg, args...) log_print_dbg( owner, LOG_CLASS_ERR, "[%05d:%s] "msg, __LINE__, __func__, ##args )
+#define avsys_critical(owner, msg, args...) log_print_dbg( owner, LOG_CLASS_CRITICAL, "[%05d:%s] "msg, __LINE__, __func__, ##args )
+#define avsys_assert(condition) log_assert_dbg( (condition) )
+
+#else /* __USE_LOGMANAGER__ */
+
+#define avsys_info_r(owner, msg, args...) fprintf(stderr, msg, ##args)
+#define avsys_warning_r(owner, msg, args...) fprintf(stderr, msg, ##args)
+#define avsys_error_r(owner, msg, args...) fprintf(stderr, msg, ##args)
+#define avsys_critical_r(owner, msg, args...) fprintf(stderr, msg, ##args)
+#define avsys_assert_r(condition) (condition)
+
+#define avsys_info(owner, msg, args...) fprintf(stderr, msg, ##args)
+#define avsys_warning(owner, msg, args...) fprintf(stderr, msg, ##args)
+#define avsys_error(owner, msg, args...) fprintf(stderr, msg, ##args)
+#define avsys_critical(owner, msg, args...) fprintf(stderr, msg, ##args)
+#define avsys_assert(condition) (condition)
+
+#endif /* __USE_LOGMANAGER__ */
+
+#else /* __DEBUG_MODE__ */
+
+#define avsys_info_r(owner, msg, args...)
+#define avsys_warning_r(owner, msg, args...)
+#define avsys_error_r(owner, msg, args...)
+#define avsys_critical_r(owner, msg, args...)
+#define avsys_assert_r(condition) (condition)
+
+#define avsys_info(owner, msg, args...)
+#define avsys_warning(owner, msg, args...)
+#define avsys_error(owner, msg, args...)
+#define avsys_critical(owner, msg, args...)
+#define avsys_assert(condition) (condition)
+
+#endif /* __DEBUG_MODE__ */
+
+#endif /* __AVSYS_DEBUG_H__ */
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __AVSYS_ERROR_H__
+#define __AVSYS_ERROR_H__
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+/**
+ * AVSYS CLASS
+ */
+#define AVSYS_STATE_SUCCESS (0x00000000) /**< No Error */
+#define AVSYS_STATE_ERROR (0x80000000) /**< Error Class */
+#define AVSYS_STATE_WARING (0x70000000) /**< Waring Class */
+
+/*
+ * Detail enumeration
+ */
+enum {
+ AVSYS_IN_UNKNOWN = 0,
+ AVSYS_IN_PARAMETER,
+ AVSYS_IN_HANDLE,
+ AVSYS_IN_POINTER,
+ AVSYS_IN_VALUE,
+ AVSYS_IN_OVERRUN,
+ AVSYS_IN_UNDERRUN,
+ AVSYS_IN_RANGE_OVER,
+ AVSYS_IN_RANGE_UNDER,
+ AVSYS_IN_MODE,
+ AVSYS_IN_FORMAT,
+ AVSYS_IN_CHANNEL,
+ AVSYS_IN_SAMPLERATE,
+ AVSYS_IN_LAYER,
+ AVSYS_IN_ROTATE,
+ AVSYS_IN_ALLOC,
+ AVSYS_IN_INTERNAL,
+ /*Extra state for camera*/
+ AVSYS_IN_IO_CONTROL,
+ AVSYS_IN_DEVICE,
+ AVSYS_IN_WAIT_RES,
+ AVSYS_IN_SUPPORT,
+ AVSYS_IN_STATE,
+ AVSYS_IN_PRIVILEGE,
+};
+
+/*
+ * AVSYS_WARING
+ */
+#define AVSYS_STATE_WAR_INVALID_PARAMETER (AVSYS_STATE_WARING | AVSYS_IN_PARAMETER)
+#define AVSYS_STATE_WAR_INVALID_HANDLE (AVSYS_STATE_WARING | AVSYS_IN_HANDLE)
+#define AVSYS_STATE_WAR_INVALID_VALUE (AVSYS_STATE_WARING | AVSYS_IN_VALUE)
+#define AVSYS_STATE_WAR_INVALID_MODE (AVSYS_STATE_WARING | AVSYS_IN_MODE)
+#define AVSYS_STATE_WAR_INVALID_FORMAT (AVSYS_STATE_WARING | AVSYS_IN_FORMAT)
+#define AVSYS_STATE_WAR_INVALID_CHANNEL (AVSYS_STATE_WARING | AVSYS_IN_CHANNEL)
+#define AVSYS_STATE_WAR_INVALID_SAMPLERATE (AVSYS_STATE_WARING | AVSYS_IN_SAMPLERATE)
+#define AVSYS_STATE_WAR_INVALID_LAYER (AVSYS_STATE_WARING | AVSYS_IN_LAYER)
+#define AVSYS_STATE_WAR_INVALID_ROTATE (AVSYS_STATE_WARING | AVSYS_IN_ROTATE)
+#define AVSYS_STATE_WAR_NULL_POINTER (AVSYS_STATE_WARING | AVSYS_IN_POINTER)
+#define AVSYS_STATE_WAR_UNDERRUN (AVSYS_STATE_WARING | AVSYS_IN_UNDERRUN)
+#define AVSYS_STATE_WAR_OVERRUN (AVSYS_STATE_WARING | AVSYS_IN_OVERRUN)
+#define AVSYS_STATE_WAR_RANGE_OVER (AVSYS_STATE_WARING | AVSYS_IN_RANGE_OVER)
+#define AVSYS_STATE_WAR_RANGE_UNDER (AVSYS_STATE_WARING | AVSYS_IN_RANGE_UNDER)
+#define AVSYS_STATE_WAR_ALLOCATION (AVSYS_STATE_WARING | AVSYS_IN_ALLOC)
+#define AVSYS_STATE_WAR_INTERNAL (AVSYS_STATE_WARING | AVSYS_IN_INTERNAL)
+/*Extra warning for camera*/
+#define AVSYS_STATE_WAR_IO_CONTROL (AVSYS_STATE_WARING | AVSYS_IN_IO_CONTROL)
+#define AVSYS_STATE_WAR_UNAVAILABLE_DEVICE (AVSYS_STATE_WARING | AVSYS_IN_DEVICE)
+#define AVSYS_STATE_WAR_DEVICE_WAIT_TIMEOUT (AVSYS_STATE_WARING | AVSYS_IN_WAIT_RES)
+#define AVSYS_STATE_WAR_DEVICE_NOT_SUPPORT (AVSYS_STATE_WARING | AVSYS_IN_SUPPORT)
+#define AVSYS_STATE_WAR_INVALID_STATE_TRANSITION (AVSYS_STATE_WARING | AVSYS_IN_STATE)
+
+/**
+ * AVSYS_ERROR
+ */
+#define AVSYS_STATE_ERR_INVALID_PARAMETER (AVSYS_STATE_ERROR | AVSYS_IN_PARAMETER)
+#define AVSYS_STATE_ERR_INVALID_HANDLE (AVSYS_STATE_ERROR | AVSYS_IN_HANDLE)
+#define AVSYS_STATE_ERR_INVALID_VALUE (AVSYS_STATE_ERROR | AVSYS_IN_VALUE)
+#define AVSYS_STATE_ERR_INVALID_MODE (AVSYS_STATE_ERROR | AVSYS_IN_MODE)
+#define AVSYS_STATE_ERR_INVALID_FORMAT (AVSYS_STATE_ERROR | AVSYS_IN_FORMAT)
+#define AVSYS_STATE_ERR_INVALID_CHANNEL (AVSYS_STATE_ERROR | AVSYS_IN_CHANNEL)
+#define AVSYS_STATE_ERR_INVALID_SAMPLERATE (AVSYS_STATE_ERROR | AVSYS_IN_SAMPLERATE)
+#define AVSYS_STATE_ERR_INVALID_LAYER (AVSYS_STATE_ERROR | AVSYS_IN_LAYER)
+#define AVSYS_STATE_ERR_INVALID_ROTATE (AVSYS_STATE_ERROR | AVSYS_IN_ROTATE)
+#define AVSYS_STATE_ERR_NULL_POINTER (AVSYS_STATE_ERROR | AVSYS_IN_POINTER)
+#define AVSYS_STATE_ERR_UNDERRUN (AVSYS_STATE_ERROR | AVSYS_IN_UNDERRUN)
+#define AVSYS_STATE_ERR_OVERRUN (AVSYS_STATE_ERROR | AVSYS_IN_OVERRUN)
+#define AVSYS_STATE_ERR_RANGE_OVER (AVSYS_STATE_ERROR | AVSYS_IN_RANGE_OVER)
+#define AVSYS_STATE_ERR_RANGE_UNDER (AVSYS_STATE_ERROR | AVSYS_IN_RANGE_UNDER)
+#define AVSYS_STATE_ERR_ALLOCATION (AVSYS_STATE_ERROR | AVSYS_IN_ALLOC)
+#define AVSYS_STATE_ERR_INTERNAL (AVSYS_STATE_ERROR | AVSYS_IN_INTERNAL)
+#define AVSYS_STATE_ERR_UNKNOWN (AVSYS_STATE_ERROR | AVSYS_IN_UNKNOWN) /**< unknown error */
+/*Extra warning for camera*/
+#define AVSYS_STATE_ERR_IO_CONTROL (AVSYS_STATE_ERROR | AVSYS_IN_IO_CONTROL)
+#define AVSYS_STATE_ERR_UNAVAILABLE_DEVICE (AVSYS_STATE_ERROR | AVSYS_IN_DEVICE)
+#define AVSYS_STATE_ERR_DEVICE_WAIT_TIMEOUT (AVSYS_STATE_ERROR | AVSYS_IN_WAIT_RES)
+#define AVSYS_STATE_ERR_DEVICE_NOT_SUPPORT (AVSYS_STATE_ERROR | AVSYS_IN_SUPPORT)
+#define AVSYS_STATE_ERR_INVALID_STATE (AVSYS_STATE_ERROR | AVSYS_IN_STATE)
+#define AVSYS_STATE_ERR_PRIVILEGE (AVSYS_STATE_ERROR | AVSYS_IN_PRIVILEGE)
+
+
+#define AVSYS_FAIL(_A_) (AVSYS_STATE_ERROR & (_A_))
+#define AVSYS_SUCCESS(_A_) (!AVSYS_FAIL(_A_))
+#define AVSYS_WARING(_A_) (AVSYS_STATE_WARING & (_A_))
+#define AVSYS_ERROR(_A_) (AVSYS_STATE_ERROR & (_A_))
+
+#ifdef __cplusplus
+ }
+#endif
+
+#endif /* __AVSYS_ERROR_H__ */
--- /dev/null
+/*
+ * avsystem
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __AVSYS_TYPES_H__
+#define __AVSYS_TYPES_H__
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+/**
+ * Type definition of av system handle.
+ */
+typedef void *avsys_handle_t;
+
+#define AVSYS_INVALID_HANDLE NULL
+#define AVSYS_AUDIO_INVALID_HANDLE (-1)
+
+#ifdef __cplusplus
+ }
+#endif
+
+#endif /* __AVSYS_TYPES_H__ */
--- /dev/null
+/*\r
+ * avsystem\r
+ *\r
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.\r
+ *\r
+ * Contact: Jonghyuk Choi <jhchoi.choi@samsung.com>\r
+ *\r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ *\r
+ */\r
+\r
+#ifndef __AVSYSTEM_H__\r
+#define __AVSYSTEM_H__\r
+\r
+#include <avsys-types.h>\r
+#include <avsys-audio.h>\r
+#include <avsys-error.h>\r
+\r
+/**\r
+ @mainpage AV System\r
+\r
+ @par\r
+ This document provides necessary information for developers who are going\r
+ to use audio/video functionality.\r
+*/\r
+\r
+#endif /* __AVSYSTEM_H__ */\r
--- /dev/null
+installinitscriptdir = /etc/rc.d/init.d
+installinitscript_SCRIPTS = $(srcdir)/snd_init
--- /dev/null
+#!/bin/sh
+#
+# snd_init sound_initializer
+# chkconfig: 2345 30 30
+# description: snd_init runs sound_initializer -i which make shared memory for audio system
+#
+
+if [ -x /usr/bin/sound_initializer ]; then
+ /usr/bin/sound_initializer -i
+fi
--- /dev/null
+#!/bin/sh
+# install - install a program, script, or datafile
+
+scriptversion=2006-12-25.00
+
+# This originates from X11R5 (mit/util/scripts/install.sh), which was
+# later released in X11R6 (xc/config/util/install.sh) with the
+# following copyright and license.
+#
+# Copyright (C) 1994 X Consortium
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
+# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+# Except as contained in this notice, the name of the X Consortium shall not
+# be used in advertising or otherwise to promote the sale, use or other deal-
+# ings in this Software without prior written authorization from the X Consor-
+# tium.
+#
+#
+# FSF changes to this file are in the public domain.
+#
+# Calling this script install-sh is preferred over install.sh, to prevent
+# `make' implicit rules from creating a file called install from it
+# when there is no Makefile.
+#
+# This script is compatible with the BSD install script, but was written
+# from scratch.
+
+nl='
+'
+IFS=" "" $nl"
+
+# set DOITPROG to echo to test this script
+
+# Don't use :- since 4.3BSD and earlier shells don't like it.
+doit=${DOITPROG-}
+if test -z "$doit"; then
+ doit_exec=exec
+else
+ doit_exec=$doit
+fi
+
+# Put in absolute file names if you don't have them in your path;
+# or use environment vars.
+
+chgrpprog=${CHGRPPROG-chgrp}
+chmodprog=${CHMODPROG-chmod}
+chownprog=${CHOWNPROG-chown}
+cmpprog=${CMPPROG-cmp}
+cpprog=${CPPROG-cp}
+mkdirprog=${MKDIRPROG-mkdir}
+mvprog=${MVPROG-mv}
+rmprog=${RMPROG-rm}
+stripprog=${STRIPPROG-strip}
+
+posix_glob='?'
+initialize_posix_glob='
+ test "$posix_glob" != "?" || {
+ if (set -f) 2>/dev/null; then
+ posix_glob=
+ else
+ posix_glob=:
+ fi
+ }
+'
+
+posix_mkdir=
+
+# Desired mode of installed file.
+mode=0755
+
+chgrpcmd=
+chmodcmd=$chmodprog
+chowncmd=
+mvcmd=$mvprog
+rmcmd="$rmprog -f"
+stripcmd=
+
+src=
+dst=
+dir_arg=
+dst_arg=
+
+copy_on_change=false
+no_target_directory=
+
+usage="\
+Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
+ or: $0 [OPTION]... SRCFILES... DIRECTORY
+ or: $0 [OPTION]... -t DIRECTORY SRCFILES...
+ or: $0 [OPTION]... -d DIRECTORIES...
+
+In the 1st form, copy SRCFILE to DSTFILE.
+In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
+In the 4th, create DIRECTORIES.
+
+Options:
+ --help display this help and exit.
+ --version display version info and exit.
+
+ -c (ignored)
+ -C install only if different (preserve the last data modification time)
+ -d create directories instead of installing files.
+ -g GROUP $chgrpprog installed files to GROUP.
+ -m MODE $chmodprog installed files to MODE.
+ -o USER $chownprog installed files to USER.
+ -s $stripprog installed files.
+ -t DIRECTORY install into DIRECTORY.
+ -T report an error if DSTFILE is a directory.
+
+Environment variables override the default commands:
+ CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG
+ RMPROG STRIPPROG
+"
+
+while test $# -ne 0; do
+ case $1 in
+ -c) ;;
+
+ -C) copy_on_change=true;;
+
+ -d) dir_arg=true;;
+
+ -g) chgrpcmd="$chgrpprog $2"
+ shift;;
+
+ --help) echo "$usage"; exit $?;;
+
+ -m) mode=$2
+ case $mode in
+ *' '* | *' '* | *'
+'* | *'*'* | *'?'* | *'['*)
+ echo "$0: invalid mode: $mode" >&2
+ exit 1;;
+ esac
+ shift;;
+
+ -o) chowncmd="$chownprog $2"
+ shift;;
+
+ -s) stripcmd=$stripprog;;
+
+ -t) dst_arg=$2
+ shift;;
+
+ -T) no_target_directory=true;;
+
+ --version) echo "$0 $scriptversion"; exit $?;;
+
+ --) shift
+ break;;
+
+ -*) echo "$0: invalid option: $1" >&2
+ exit 1;;
+
+ *) break;;
+ esac
+ shift
+done
+
+if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
+ # When -d is used, all remaining arguments are directories to create.
+ # When -t is used, the destination is already specified.
+ # Otherwise, the last argument is the destination. Remove it from $@.
+ for arg
+ do
+ if test -n "$dst_arg"; then
+ # $@ is not empty: it contains at least $arg.
+ set fnord "$@" "$dst_arg"
+ shift # fnord
+ fi
+ shift # arg
+ dst_arg=$arg
+ done
+fi
+
+if test $# -eq 0; then
+ if test -z "$dir_arg"; then
+ echo "$0: no input file specified." >&2
+ exit 1
+ fi
+ # It's OK to call `install-sh -d' without argument.
+ # This can happen when creating conditional directories.
+ exit 0
+fi
+
+if test -z "$dir_arg"; then
+ trap '(exit $?); exit' 1 2 13 15
+
+ # Set umask so as not to create temps with too-generous modes.
+ # However, 'strip' requires both read and write access to temps.
+ case $mode in
+ # Optimize common cases.
+ *644) cp_umask=133;;
+ *755) cp_umask=22;;
+
+ *[0-7])
+ if test -z "$stripcmd"; then
+ u_plus_rw=
+ else
+ u_plus_rw='% 200'
+ fi
+ cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
+ *)
+ if test -z "$stripcmd"; then
+ u_plus_rw=
+ else
+ u_plus_rw=,u+rw
+ fi
+ cp_umask=$mode$u_plus_rw;;
+ esac
+fi
+
+for src
+do
+ # Protect names starting with `-'.
+ case $src in
+ -*) src=./$src;;
+ esac
+
+ if test -n "$dir_arg"; then
+ dst=$src
+ dstdir=$dst
+ test -d "$dstdir"
+ dstdir_status=$?
+ else
+
+ # Waiting for this to be detected by the "$cpprog $src $dsttmp" command
+ # might cause directories to be created, which would be especially bad
+ # if $src (and thus $dsttmp) contains '*'.
+ if test ! -f "$src" && test ! -d "$src"; then
+ echo "$0: $src does not exist." >&2
+ exit 1
+ fi
+
+ if test -z "$dst_arg"; then
+ echo "$0: no destination specified." >&2
+ exit 1
+ fi
+
+ dst=$dst_arg
+ # Protect names starting with `-'.
+ case $dst in
+ -*) dst=./$dst;;
+ esac
+
+ # If destination is a directory, append the input filename; won't work
+ # if double slashes aren't ignored.
+ if test -d "$dst"; then
+ if test -n "$no_target_directory"; then
+ echo "$0: $dst_arg: Is a directory" >&2
+ exit 1
+ fi
+ dstdir=$dst
+ dst=$dstdir/`basename "$src"`
+ dstdir_status=0
+ else
+ # Prefer dirname, but fall back on a substitute if dirname fails.
+ dstdir=`
+ (dirname "$dst") 2>/dev/null ||
+ expr X"$dst" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+ X"$dst" : 'X\(//\)[^/]' \| \
+ X"$dst" : 'X\(//\)$' \| \
+ X"$dst" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$dst" |
+ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+ s//\1/
+ q
+ }
+ /^X\(\/\/\)[^/].*/{
+ s//\1/
+ q
+ }
+ /^X\(\/\/\)$/{
+ s//\1/
+ q
+ }
+ /^X\(\/\).*/{
+ s//\1/
+ q
+ }
+ s/.*/./; q'
+ `
+
+ test -d "$dstdir"
+ dstdir_status=$?
+ fi
+ fi
+
+ obsolete_mkdir_used=false
+
+ if test $dstdir_status != 0; then
+ case $posix_mkdir in
+ '')
+ # Create intermediate dirs using mode 755 as modified by the umask.
+ # This is like FreeBSD 'install' as of 1997-10-28.
+ umask=`umask`
+ case $stripcmd.$umask in
+ # Optimize common cases.
+ *[2367][2367]) mkdir_umask=$umask;;
+ .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;;
+
+ *[0-7])
+ mkdir_umask=`expr $umask + 22 \
+ - $umask % 100 % 40 + $umask % 20 \
+ - $umask % 10 % 4 + $umask % 2
+ `;;
+ *) mkdir_umask=$umask,go-w;;
+ esac
+
+ # With -d, create the new directory with the user-specified mode.
+ # Otherwise, rely on $mkdir_umask.
+ if test -n "$dir_arg"; then
+ mkdir_mode=-m$mode
+ else
+ mkdir_mode=
+ fi
+
+ posix_mkdir=false
+ case $umask in
+ *[123567][0-7][0-7])
+ # POSIX mkdir -p sets u+wx bits regardless of umask, which
+ # is incompatible with FreeBSD 'install' when (umask & 300) != 0.
+ ;;
+ *)
+ tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
+ trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0
+
+ if (umask $mkdir_umask &&
+ exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1
+ then
+ if test -z "$dir_arg" || {
+ # Check for POSIX incompatibilities with -m.
+ # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
+ # other-writeable bit of parent directory when it shouldn't.
+ # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
+ ls_ld_tmpdir=`ls -ld "$tmpdir"`
+ case $ls_ld_tmpdir in
+ d????-?r-*) different_mode=700;;
+ d????-?--*) different_mode=755;;
+ *) false;;
+ esac &&
+ $mkdirprog -m$different_mode -p -- "$tmpdir" && {
+ ls_ld_tmpdir_1=`ls -ld "$tmpdir"`
+ test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
+ }
+ }
+ then posix_mkdir=:
+ fi
+ rmdir "$tmpdir/d" "$tmpdir"
+ else
+ # Remove any dirs left behind by ancient mkdir implementations.
+ rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null
+ fi
+ trap '' 0;;
+ esac;;
+ esac
+
+ if
+ $posix_mkdir && (
+ umask $mkdir_umask &&
+ $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
+ )
+ then :
+ else
+
+ # The umask is ridiculous, or mkdir does not conform to POSIX,
+ # or it failed possibly due to a race condition. Create the
+ # directory the slow way, step by step, checking for races as we go.
+
+ case $dstdir in
+ /*) prefix='/';;
+ -*) prefix='./';;
+ *) prefix='';;
+ esac
+
+ eval "$initialize_posix_glob"
+
+ oIFS=$IFS
+ IFS=/
+ $posix_glob set -f
+ set fnord $dstdir
+ shift
+ $posix_glob set +f
+ IFS=$oIFS
+
+ prefixes=
+
+ for d
+ do
+ test -z "$d" && continue
+
+ prefix=$prefix$d
+ if test -d "$prefix"; then
+ prefixes=
+ else
+ if $posix_mkdir; then
+ (umask=$mkdir_umask &&
+ $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
+ # Don't fail if two instances are running concurrently.
+ test -d "$prefix" || exit 1
+ else
+ case $prefix in
+ *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
+ *) qprefix=$prefix;;
+ esac
+ prefixes="$prefixes '$qprefix'"
+ fi
+ fi
+ prefix=$prefix/
+ done
+
+ if test -n "$prefixes"; then
+ # Don't fail if two instances are running concurrently.
+ (umask $mkdir_umask &&
+ eval "\$doit_exec \$mkdirprog $prefixes") ||
+ test -d "$dstdir" || exit 1
+ obsolete_mkdir_used=true
+ fi
+ fi
+ fi
+
+ if test -n "$dir_arg"; then
+ { test -z "$chowncmd" || $doit $chowncmd "$dst"; } &&
+ { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } &&
+ { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false ||
+ test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1
+ else
+
+ # Make a couple of temp file names in the proper directory.
+ dsttmp=$dstdir/_inst.$$_
+ rmtmp=$dstdir/_rm.$$_
+
+ # Trap to clean up those temp files at exit.
+ trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
+
+ # Copy the file name to the temp name.
+ (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") &&
+
+ # and set any options; do chmod last to preserve setuid bits.
+ #
+ # If any of these fail, we abort the whole thing. If we want to
+ # ignore errors from any of these, just make sure not to ignore
+ # errors from the above "$doit $cpprog $src $dsttmp" command.
+ #
+ { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } &&
+ { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } &&
+ { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } &&
+ { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } &&
+
+ # If -C, don't bother to copy if it wouldn't change the file.
+ if $copy_on_change &&
+ old=`LC_ALL=C ls -dlL "$dst" 2>/dev/null` &&
+ new=`LC_ALL=C ls -dlL "$dsttmp" 2>/dev/null` &&
+
+ eval "$initialize_posix_glob" &&
+ $posix_glob set -f &&
+ set X $old && old=:$2:$4:$5:$6 &&
+ set X $new && new=:$2:$4:$5:$6 &&
+ $posix_glob set +f &&
+
+ test "$old" = "$new" &&
+ $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
+ then
+ rm -f "$dsttmp"
+ else
+ # Rename the file to the real destination.
+ $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null ||
+
+ # The rename failed, perhaps because mv can't rename something else
+ # to itself, or perhaps because mv is so ancient that it does not
+ # support -f.
+ {
+ # Now remove or move aside any old file at destination location.
+ # We try this two ways since rm can't unlink itself on some
+ # systems and the destination file might be busy for other
+ # reasons. In this case, the final cleanup might fail but the new
+ # file should still install successfully.
+ {
+ test ! -f "$dst" ||
+ $doit $rmcmd -f "$dst" 2>/dev/null ||
+ { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
+ { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }
+ } ||
+ { echo "$0: cannot unlink or rename $dst" >&2
+ (exit 1); exit 1
+ }
+ } &&
+
+ # Now rename the file to the real destination.
+ $doit $mvcmd "$dsttmp" "$dst"
+ }
+ fi || exit 1
+
+ trap '' 0
+ fi
+done
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-end: "$"
+# End:
--- /dev/null
+#! /bin/sh
+# Common stub for a few missing GNU programs while installing.
+
+scriptversion=2006-05-10.23
+
+# Copyright (C) 1996, 1997, 1999, 2000, 2002, 2003, 2004, 2005, 2006
+# Free Software Foundation, Inc.
+# Originally by Fran,cois Pinard <pinard@iro.umontreal.ca>, 1996.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+# 02110-1301, USA.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+if test $# -eq 0; then
+ echo 1>&2 "Try \`$0 --help' for more information"
+ exit 1
+fi
+
+run=:
+sed_output='s/.* --output[ =]\([^ ]*\).*/\1/p'
+sed_minuso='s/.* -o \([^ ]*\).*/\1/p'
+
+# In the cases where this matters, `missing' is being run in the
+# srcdir already.
+if test -f configure.ac; then
+ configure_ac=configure.ac
+else
+ configure_ac=configure.in
+fi
+
+msg="missing on your system"
+
+case $1 in
+--run)
+ # Try to run requested program, and just exit if it succeeds.
+ run=
+ shift
+ "$@" && exit 0
+ # Exit code 63 means version mismatch. This often happens
+ # when the user try to use an ancient version of a tool on
+ # a file that requires a minimum version. In this case we
+ # we should proceed has if the program had been absent, or
+ # if --run hadn't been passed.
+ if test $? = 63; then
+ run=:
+ msg="probably too old"
+ fi
+ ;;
+
+ -h|--h|--he|--hel|--help)
+ echo "\
+$0 [OPTION]... PROGRAM [ARGUMENT]...
+
+Handle \`PROGRAM [ARGUMENT]...' for when PROGRAM is missing, or return an
+error status if there is no known handling for PROGRAM.
+
+Options:
+ -h, --help display this help and exit
+ -v, --version output version information and exit
+ --run try to run the given command, and emulate it if it fails
+
+Supported PROGRAM values:
+ aclocal touch file \`aclocal.m4'
+ autoconf touch file \`configure'
+ autoheader touch file \`config.h.in'
+ autom4te touch the output file, or create a stub one
+ automake touch all \`Makefile.in' files
+ bison create \`y.tab.[ch]', if possible, from existing .[ch]
+ flex create \`lex.yy.c', if possible, from existing .c
+ help2man touch the output file
+ lex create \`lex.yy.c', if possible, from existing .c
+ makeinfo touch the output file
+ tar try tar, gnutar, gtar, then tar without non-portable flags
+ yacc create \`y.tab.[ch]', if possible, from existing .[ch]
+
+Send bug reports to <bug-automake@gnu.org>."
+ exit $?
+ ;;
+
+ -v|--v|--ve|--ver|--vers|--versi|--versio|--version)
+ echo "missing $scriptversion (GNU Automake)"
+ exit $?
+ ;;
+
+ -*)
+ echo 1>&2 "$0: Unknown \`$1' option"
+ echo 1>&2 "Try \`$0 --help' for more information"
+ exit 1
+ ;;
+
+esac
+
+# Now exit if we have it, but it failed. Also exit now if we
+# don't have it and --version was passed (most likely to detect
+# the program).
+case $1 in
+ lex|yacc)
+ # Not GNU programs, they don't have --version.
+ ;;
+
+ tar)
+ if test -n "$run"; then
+ echo 1>&2 "ERROR: \`tar' requires --run"
+ exit 1
+ elif test "x$2" = "x--version" || test "x$2" = "x--help"; then
+ exit 1
+ fi
+ ;;
+
+ *)
+ if test -z "$run" && ($1 --version) > /dev/null 2>&1; then
+ # We have it, but it failed.
+ exit 1
+ elif test "x$2" = "x--version" || test "x$2" = "x--help"; then
+ # Could not run --version or --help. This is probably someone
+ # running `$TOOL --version' or `$TOOL --help' to check whether
+ # $TOOL exists and not knowing $TOOL uses missing.
+ exit 1
+ fi
+ ;;
+esac
+
+# If it does not exist, or fails to run (possibly an outdated version),
+# try to emulate it.
+case $1 in
+ aclocal*)
+ echo 1>&2 "\
+WARNING: \`$1' is $msg. You should only need it if
+ you modified \`acinclude.m4' or \`${configure_ac}'. You might want
+ to install the \`Automake' and \`Perl' packages. Grab them from
+ any GNU archive site."
+ touch aclocal.m4
+ ;;
+
+ autoconf)
+ echo 1>&2 "\
+WARNING: \`$1' is $msg. You should only need it if
+ you modified \`${configure_ac}'. You might want to install the
+ \`Autoconf' and \`GNU m4' packages. Grab them from any GNU
+ archive site."
+ touch configure
+ ;;
+
+ autoheader)
+ echo 1>&2 "\
+WARNING: \`$1' is $msg. You should only need it if
+ you modified \`acconfig.h' or \`${configure_ac}'. You might want
+ to install the \`Autoconf' and \`GNU m4' packages. Grab them
+ from any GNU archive site."
+ files=`sed -n 's/^[ ]*A[CM]_CONFIG_HEADER(\([^)]*\)).*/\1/p' ${configure_ac}`
+ test -z "$files" && files="config.h"
+ touch_files=
+ for f in $files; do
+ case $f in
+ *:*) touch_files="$touch_files "`echo "$f" |
+ sed -e 's/^[^:]*://' -e 's/:.*//'`;;
+ *) touch_files="$touch_files $f.in";;
+ esac
+ done
+ touch $touch_files
+ ;;
+
+ automake*)
+ echo 1>&2 "\
+WARNING: \`$1' is $msg. You should only need it if
+ you modified \`Makefile.am', \`acinclude.m4' or \`${configure_ac}'.
+ You might want to install the \`Automake' and \`Perl' packages.
+ Grab them from any GNU archive site."
+ find . -type f -name Makefile.am -print |
+ sed 's/\.am$/.in/' |
+ while read f; do touch "$f"; done
+ ;;
+
+ autom4te)
+ echo 1>&2 "\
+WARNING: \`$1' is needed, but is $msg.
+ You might have modified some files without having the
+ proper tools for further handling them.
+ You can get \`$1' as part of \`Autoconf' from any GNU
+ archive site."
+
+ file=`echo "$*" | sed -n "$sed_output"`
+ test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"`
+ if test -f "$file"; then
+ touch $file
+ else
+ test -z "$file" || exec >$file
+ echo "#! /bin/sh"
+ echo "# Created by GNU Automake missing as a replacement of"
+ echo "# $ $@"
+ echo "exit 0"
+ chmod +x $file
+ exit 1
+ fi
+ ;;
+
+ bison|yacc)
+ echo 1>&2 "\
+WARNING: \`$1' $msg. You should only need it if
+ you modified a \`.y' file. You may need the \`Bison' package
+ in order for those modifications to take effect. You can get
+ \`Bison' from any GNU archive site."
+ rm -f y.tab.c y.tab.h
+ if test $# -ne 1; then
+ eval LASTARG="\${$#}"
+ case $LASTARG in
+ *.y)
+ SRCFILE=`echo "$LASTARG" | sed 's/y$/c/'`
+ if test -f "$SRCFILE"; then
+ cp "$SRCFILE" y.tab.c
+ fi
+ SRCFILE=`echo "$LASTARG" | sed 's/y$/h/'`
+ if test -f "$SRCFILE"; then
+ cp "$SRCFILE" y.tab.h
+ fi
+ ;;
+ esac
+ fi
+ if test ! -f y.tab.h; then
+ echo >y.tab.h
+ fi
+ if test ! -f y.tab.c; then
+ echo 'main() { return 0; }' >y.tab.c
+ fi
+ ;;
+
+ lex|flex)
+ echo 1>&2 "\
+WARNING: \`$1' is $msg. You should only need it if
+ you modified a \`.l' file. You may need the \`Flex' package
+ in order for those modifications to take effect. You can get
+ \`Flex' from any GNU archive site."
+ rm -f lex.yy.c
+ if test $# -ne 1; then
+ eval LASTARG="\${$#}"
+ case $LASTARG in
+ *.l)
+ SRCFILE=`echo "$LASTARG" | sed 's/l$/c/'`
+ if test -f "$SRCFILE"; then
+ cp "$SRCFILE" lex.yy.c
+ fi
+ ;;
+ esac
+ fi
+ if test ! -f lex.yy.c; then
+ echo 'main() { return 0; }' >lex.yy.c
+ fi
+ ;;
+
+ help2man)
+ echo 1>&2 "\
+WARNING: \`$1' is $msg. You should only need it if
+ you modified a dependency of a manual page. You may need the
+ \`Help2man' package in order for those modifications to take
+ effect. You can get \`Help2man' from any GNU archive site."
+
+ file=`echo "$*" | sed -n "$sed_output"`
+ test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"`
+ if test -f "$file"; then
+ touch $file
+ else
+ test -z "$file" || exec >$file
+ echo ".ab help2man is required to generate this page"
+ exit 1
+ fi
+ ;;
+
+ makeinfo)
+ echo 1>&2 "\
+WARNING: \`$1' is $msg. You should only need it if
+ you modified a \`.texi' or \`.texinfo' file, or any other file
+ indirectly affecting the aspect of the manual. The spurious
+ call might also be the consequence of using a buggy \`make' (AIX,
+ DU, IRIX). You might want to install the \`Texinfo' package or
+ the \`GNU make' package. Grab either from any GNU archive site."
+ # The file to touch is that specified with -o ...
+ file=`echo "$*" | sed -n "$sed_output"`
+ test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"`
+ if test -z "$file"; then
+ # ... or it is the one specified with @setfilename ...
+ infile=`echo "$*" | sed 's/.* \([^ ]*\) *$/\1/'`
+ file=`sed -n '
+ /^@setfilename/{
+ s/.* \([^ ]*\) *$/\1/
+ p
+ q
+ }' $infile`
+ # ... or it is derived from the source name (dir/f.texi becomes f.info)
+ test -z "$file" && file=`echo "$infile" | sed 's,.*/,,;s,.[^.]*$,,'`.info
+ fi
+ # If the file does not exist, the user really needs makeinfo;
+ # let's fail without touching anything.
+ test -f $file || exit 1
+ touch $file
+ ;;
+
+ tar)
+ shift
+
+ # We have already tried tar in the generic part.
+ # Look for gnutar/gtar before invocation to avoid ugly error
+ # messages.
+ if (gnutar --version > /dev/null 2>&1); then
+ gnutar "$@" && exit 0
+ fi
+ if (gtar --version > /dev/null 2>&1); then
+ gtar "$@" && exit 0
+ fi
+ firstarg="$1"
+ if shift; then
+ case $firstarg in
+ *o*)
+ firstarg=`echo "$firstarg" | sed s/o//`
+ tar "$firstarg" "$@" && exit 0
+ ;;
+ esac
+ case $firstarg in
+ *h*)
+ firstarg=`echo "$firstarg" | sed s/h//`
+ tar "$firstarg" "$@" && exit 0
+ ;;
+ esac
+ fi
+
+ echo 1>&2 "\
+WARNING: I can't seem to be able to run \`tar' with the given arguments.
+ You may want to install GNU tar or Free paxutils, or check the
+ command line arguments."
+ exit 1
+ ;;
+
+ *)
+ echo 1>&2 "\
+WARNING: \`$1' is needed, and is $msg.
+ You might have modified some files without having the
+ proper tools for further handling them. Check the \`README' file,
+ it often tells you about the needed prerequisites for installing
+ this package. You may also peek at any GNU archive site, in case
+ some other package would contain this missing \`$1' program."
+ exit 1
+ ;;
+esac
+
+exit 0
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-end: "$"
+# End:
--- /dev/null
+
+Name: avsystem
+Summary: Audio Video System
+Version: 0.3.50
+Release: 1
+Group: TO_BE/FILLED_IN
+License: TO BE FILLED IN
+Source0: avsystem-%{version}.tar.bz2
+BuildRequires: pkgconfig(alsa)
+BuildRequires: pkgconfig(iniparser)
+BuildRequires: pkgconfig(mm-ta)
+BuildRequires: pkgconfig(mm-log)
+BuildRequires: pkgconfig(libexif)
+BuildRequires: pkgconfig(libpulse)
+BuildRequires: pkgconfig(libascenario)
+
+
+%description
+Audio Video System
+
+
+%package devel
+Summary: Audio Video System Development headers and libraries
+Group: Development/Libraries
+Requires: %{name} = %{version}-%{release}
+
+%description devel
+Audio Video System Development headers and libraries.
+
+
+%prep
+%setup -q -n %{name}-%{version}
+
+
+%build
+%autogen
+%configure \
+%ifarch %{ix86}
+ --enable-slp2 --enable-aquila --enable-pasimple
+%else
+ --enable-slp2 --enable-sdk --enable-aquila --enable-pasimple
+%endif
+
+make %{?jobs:-j%jobs}
+
+%install
+rm -rf %{buildroot}
+%make_install
+
+
+
+%post -p /sbin/ldconfig
+
+%files
+%defattr(-,root,root,-)
+/etc/rc.d/init.d/snd_init
+/usr/bin/camera_caps_generator
+/usr/bin/sound_initializer
+/usr/lib/libavsysaudio.so.0
+/usr/lib/libavsysaudio.so.0.0.1
+/usr/lib/libavsyscamera.so.0
+/usr/lib/libavsyscamera.so.0.0.0
+
+%files devel
+/usr/lib/libavsysaudio.so
+/usr/lib/pkgconfig/*.pc
+/usr/lib/libavsyscamera.so
+/usr/include/avsystem/avsys-audio.h
+/usr/include/avsystem/avsys-cam-exif.h
+/usr/include/avsystem/avsys-cam.h
+/usr/include/avsystem/avsys-error.h
+/usr/include/avsystem/avsys-types.h
+/usr/include/avsystem/avsystem.h
--- /dev/null
+pcfiles = avsystem.pc avsysaudio.pc
+
+all-local: $(pcfiles)
+
+%.pc: %.pc
+ cp $< $@
+
+pkgconfigdir= $(libdir)/pkgconfig
+pkgconfig_DATA= $(pcfiles)
+
+CLEANFILES= $(pcfiles)
+
+pcinfiles= avsystem.pc.in avsysaudio.pc.in
+
+EXTRA_DIST= $(pcinfiles)
+
--- /dev/null
+prefix = @prefix@
+exec_prefix= @exec_prefix@
+libdir = @libdir@
+includedir = @includedir@
+
+Name : avsysaudio
+Description : Multimedia Framework AV system Audio Library
+Requires : alsa libascenario mm-log libpulse-simple
+Version : @VERSION@
+Libs : -L${libdir} -lavsysaudio -lrt -lpthread
+Cflags : -I${includedir}/avsystem
--- /dev/null
+prefix = @prefix@
+exec_prefix= @exec_prefix@
+libdir = @libdir@
+includedir = @includedir@
+
+Name : avsystem
+Description : Multimedia Framework AV system Library
+Requires : avsysaudio
+Version : @VERSION@
+Libs :
+Cflags :
--- /dev/null
+prefix = @prefix@
+exec_prefix= @exec_prefix@
+libdir = @libdir@
+includedir = @includedir@
+
+Name : avsystem
+Description : Multimedia Framework AV system Library
+Requires : alsa libascenario
+Version : @VERSION@
+Libs : -L${libdir} -lavsysaudio -lrt -lpthread -lexif -liniparser -ldl
+Cflags : -I${includedir}/avsystem
--- /dev/null
+pcfiles = avsystem.pc avsysaudio.pc
+
+all-local: $(pcfiles)
+
+%.pc: %.pc
+ cp $< $@
+
+pkgconfigdir= $(libdir)/pkgconfig
+pkgconfig_DATA= $(pcfiles)
+
+CLEANFILES= $(pcfiles)
+
+pcinfiles= avsystem.pc.in avsysaudio.pc.in
+EXTRA_DIST= $(pcinfiles)
+
--- /dev/null
+prefix = @prefix@
+exec_prefix= @exec_prefix@
+libdir = @libdir@
+includedir = @includedir@
+
+Name : avsysaudio
+Description : Multimedia Framework AV system Audio Library
+Requires : alsa libpulse-simple
+Version : @VERSION@
+Libs : -L${libdir} -lavsysaudio -lrt -lpthread
+Cflags : -I${includedir}/avsystem
--- /dev/null
+prefix = @prefix@
+exec_prefix= @exec_prefix@
+libdir = @libdir@
+includedir = @includedir@
+
+Name : avsystem
+Description : Multimedia Framework AV system Library
+Requires : avsysaudio
+Version : @VERSION@
+Libs :
+Cflags :
--- /dev/null
+prefix = @prefix@
+exec_prefix= @exec_prefix@
+libdir = @libdir@
+includedir = @includedir@
+
+Name : avsystem
+Description : Multimedia Framework AV system Library
+Requires : alsa libascenario
+Version : @VERSION@
+Libs : -L${libdir} -lavsysaudio -lrt -lpthread -lexif -liniparser -ldl
+Cflags : -I${includedir}/avsystem
projects / platform / core / multimedia / avsystem.git / commitdiff